Introduction to Programming in LISP

Introduction to Programming in
LISP
...
Akash Sethi
Software Consultant
Knoldus Software LLP.

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

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.

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.

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.

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

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.

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

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))

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.

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

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

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

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

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))))

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.

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)

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)

References
● http://mitpress.mit.edu/sicp/

Introduction to Programming in LISP

Recommended

More Related Content

What's hot (20)

Similar to Introduction to Programming in LISP (20)

More from Knoldus Inc. (20)

Recently uploaded (20)

Introduction to Programming in LISP