Introduction to Programming in LISP
Download as ODP, PDF1 like948 views
The document introduces programming in Lisp, detailing its significance and fundamentals such as expression evaluation, variable definitions, and procedure definitions. It highlights why learning Lisp is beneficial for understanding functional programming languages and provides insight into concepts like recursion and iteration. The content emphasizes key features of Lisp, including its history, syntax, and practical applications, particularly in artificial intelligence.
Introduction to Programming in LISP
- 1. Introduction to Programming in LISP ... Akash Sethi Software Consultant Knoldus Software LLP.
- 2. Agenda โ Why LISP โ What is LISP โ Timeline of Lisp dialects โ Fundamentals of LISP โ Expression Evaluation in LISP โ Defining Variables โ Evaluating Combinations โ Procedure Definitions โ The Substitution Model for Procedure Application โ Conditional Expressions โ Linear Recursion and Iteration
- 3. Why LISP The Key motivations behind Learning LISP are as follow:- โ Some of the features of Scala are inherited from LISP. โ Scala is Hybrid Programming Language. It consist features of both Functional and Object Oriented Programming Language. โ We most of us know the Object Oriented programming Language like JAVA, C++ etc. โ Undersanding the Basics of LISP can help us understand the other functional programming languages like clojure.
- 4. What is LISP โ LISP, an acronym for list processing, is a programming language that was designed for easy manipulation of data strings. โ Developed in 1959 by John McCarthy, โ It is a commonly used language for artificial intelligence (AI) programming. โ It is one of the oldest programming languages still in relatively wide use. โ All program code is written as s-expressions, or parenthesized lists.
- 5. Timeline of Lisp dialects
- 6. What is LISP โ LISP, an acronym for list processing, is a programming language that was designed for easy manipulation of data strings. โ Developed in 1959 by John McCarthy, โ It is a commonly used language for artificial intelligence (AI) programming. โ It is one of the oldest programming languages still in relatively wide use. โ All program code is written as s-expressions, or parenthesized lists.
- 7. Fundamentals of LISP Every powerful language has three mechanisms for accomplishing this :- โ Primitive expressions, which represent the simplest entities the language is concerned with, โ Means of combination, by which compound elements are built from simpler ones, and โ Means of abstraction, by which compound elements can be named and manipulated as units.
- 8. Expression Evaluation in LISP Expressions representing numbers may be combined with an expression representing a primitive procedure (such as + or *) to form a compound expression that represents the application of the procedure to those numbers. For example:- (+ 137 349) 486 (- 1000 334) 666 (* 5 99) 495 (/ 10 5) 2
- 9. Expression Evaluation in LISP Expressions such as these, formed by delimiting a list of expressions within parentheses in order to denote procedure application, are called combinations. โ The leftmost element in the list is called the operator, and the other elements are called operands. โ The value of a combination is obtained by applying the procedure specified by the operator to the arguments that are the values of the operands. โ The convention of placing the operator to the left of the operands is known as prefix notation. โ No ambiguity can arise, because the operator is always the leftmost element and the entire combination is delimited by the parentheses.
- 10. Defining Variables Define is LISP language's simplest means of abstraction, for it allows us to use simple names to refer to the results of compound operation. (define pi 3.14159) (define radius 10) (* pi (* radius radius)) 314.159 (define circumference (* 2 pi radius)) Circumference 62.8318
- 11. Evaluating Combinations To evaluate a combination, do the following: โ 1. Evaluate the subexpressions of the combination. โ 2. Apply the procedure that is the value of the leftmost subexpression (the operator) to the arguments that are the values of the other subexpressions (the operands). (* (+ 2 (* 4 6)) (+ 3 5 7))
- 12. Evaluating Combinations Each combination is represented by a node with branches corresponding to the operator and the operands of the combination stemming from it. The terminal nodes (that is, nodes with no branches stemming from them) represent either operators or numbers. Viewing evaluation in terms of the tree, we can imagine that the values of the operands percolate upward, starting from the terminal nodes and then combining at higher and higher levels. the ``percolate values upward'' form of the evaluation rule is an example of a general kind of process known as tree accumulation.
- 13. Procedure Definitions A much more powerful abstraction technique by which a compound operation can be given a name and then referred to as a unit. (define (square x) (* x x)) We can understand this in the following way: (define (square x) (* x x)) square something, multiply it by itself. We have here a compound procedure, which has been given the name square. The procedure represents the operation of multiplying something by itself. The thing to be multiplied is given a local name, x, which plays the same role that a pronoun plays in natural language. Evaluating the definition creates this compound procedure and associates it with the name square
- 14. The Substitution Model for Procedure Application There Exists 2 type of Orders to Evaluate any Procedure in LISP. โ Normal Order โ Applicative Order โ Normal Order :- the interpreter first evaluates the operator and operands and then applies the resulting procedure to the resulting arguments
- 15. Normal Order Normal Order Example :- (sum-of-squares (+ 5 1) (* 5 2)) (+ (square 6) (square 10 ) ) If we use the definition of square, this reduces to (+ (* 6 6) (* 10 10)) which reduces by multiplication to (+ 36 100) and finally to 136
- 16. Applicative Order โ Applicative Order :- An alternative evaluation model would not evaluate the operands until their values were needed. Instead it would first substitute operand expressions for parameters until it obtained an expression involving only primitive operators, and would then perform the evaluation. (sum-of-squares (+ 5 1) (* 5 2)) (+ (square (+ 5 1)) (square (* 5 2)) ) (+ (* (+ 5 1) (+ 5 1)) (* (* 5 2) (* 5 2))) followed by the reductions (+ (* 6 6) (* 10 10)) (+ 36 100) 136
- 17. Conditional Expressions Most of the time situation arises when we need to perform some operation based on some condition. For Example :- Finding the Absolute value. Condition will be :- โ IF x > 0 return x IF x = 0 return 0 IF x < 0 return -x This construct is called a case analysis, and there is a special form in Lisp for notating such a case analysis. It is called cond (which stands for โโconditionalโโ), and it is used as follows: โ (define (abs x) (cond ((> x 0) x) ((= x 0) 0) ((< x 0) (- x))))
- 18. Linear Recursion and Iteration โ Recursion:- the repeated application of a recursive procedure or definition. โ Iteration:- the repetition of a process. Example:- Finding the Factorial of some number.This can easily implemented in 2 ways . โ Using Recusrion โ Using Iteration.
- 19. Linear Recursion โ Factorial Using the Recursion in LISP (define (factorial n) (if (= n 1) 1 (* n (factorial (- n 1))))) โ Here, Time Complexity is O(x) โ Space Complexity is O(x)
- 20. Linear Recursion
- 21. Iteration โ Factorial Using the Iteration in LISP (define (factorial n) (fact-iter 1 1 n)) (define (fact-iter product counter max-count) (if (> counter max-count) product (fact-iter (* counter product) (+ counter 1) max-count))) โ Here, Time Complexity is O(x) โ Space Complexity is O(1)
- 22. Iteration
- 24. Thank You