lisp programming languge
DESCRIPTION
Basic Description on the Lisp Programming Language with some history background and some practical examples with the outputTRANSCRIPT
LISP
Lisp Programming Language
LISP
What is LISP?
• A LISt Processing language
– The basic data structure is linked list and Atoms.
• A functional programming language
– Each expression in LISP is a function that returns a value
• An interpretive language
– Running LISP programs involves interacting with the LISP interpreter.
– Clisp is the common lisp interpreter available only for Linux.
– Recently Compilers have been made for this language but they are not used a lot.
LISP
History
• First developed by John McCarthy as a language for symbolic (rather than numeric) computation in 1958 based on Fortran Syntax
• Very SLOW:
– no compilation of source to machine code
– inefficient garbage collector
• Historical Reason– Most AI programs in the U.S. have been developed in LISP
– However, most AI programs in Europe have been developed in PROLOG
LISP
Terminology
•Write a program => Define a set of functions
•Running a program => Evaluating an expression
•Simple syntax: operator precedence issues eliminated
•Lists (or S-expressions) are important:•Functions are defined as lists•Lists can be manipulated easily in Lisp•Functions can be manipulated easily
LISP
Functions
• Lisp is a functional language – So everything is a function
-> Functions in other languages
var sum := sqrt(x)
Print sum
In lisp this function is:
-> (sqrt x)
• Most LISP functions require you to think and use Prefix Notation – you have to think backwards
– (print (+ 5 (sqrt 6)))
• And there are primary effects and side effects– In ‘pure’ Lisp, we ONLY get values by executing a function.
– We DON’T set a variable to a new value INSIDE a function….that is a side effect of executing a function. (You all probably do that all the time in Java or C++)
LISP How the Lisp Functions work –
The read-eval loop
• Evaluation process starts with an “S” expression (i.e., a function and operands to that function) This one adds two numbers….
(+ 3 4)
Parentheses – Notification to evaluate
Function name – Go get function (in this case ‘+’ is
the add function)
space - separator
operands -- value for function
Parentheses – stop evaluation and return the
answer
LISP
How Lisp Interpreter Works
•Programs are lisp objects (i.e. functions)•Evaluation of a lisp object returns a new object.•Evaluation is simply a function called EVAL that maps lisp objects to lisp objects:
•EVAL: object => object•we will use the symbol => to represent evaluation
•The Lisp interpreter is a loop consisting of:
•read a lisp expression•call EVAL on it•print out the result
LISP
Let’s start with the math functions
• There are many built in arithmetic functions
• You then put these arithmetic functions together
LISP
Arithmetic Functions
(+ numbers…) -- adding
(- numbers…) -- subtracting
(* numbers…) -- multiplication
(/ numbers…) -- division
(1+ number) – plus 1 (this is hard to read)
(1- number) – minus 1
(abs number) etc…..
(acos number)
LISP
Examples:
LISP
Atoms
• Atoms:
– Number
» examples: 3, 8.9, etc.
– Symbol
» An object written as a sequence of characters
» Symbols are usually manipulated as names that are “bound” to other lisp objects
• Symbol FOO might be bound to 4.2
LISP
Lists
•Lists :•Anything with parentheses around it.•()•(a)•(this is one too)•(a list of (two) lists)•(a (very (very (very (inscrutable) list)))
LISP
A Special Symbol: NIL
• NIL represents an empty list.
• NIL is a terminator of a list.
• A list is usually built by inserting its elements into NIL in the reverse order .
• NIL can also represent “false''.
• The special symbol representing “true” is T.
LISP
Taking lists apart
• (first <a list>) returns the first element of the list.
• (rest <a list>) returns the remaining list (i.e., everything except the first element).
LISP
Quote
• Quote symbol ‘ is a short hand for the function called QUOTE.
• (QUOTE <arg>)
• QUOTE is a special function that prevents LISP from evaluating its argument.
• QUOTE returns the argument literately.
Example: (quote (dummy-fn 2))
==> (DUMMY-FN 2)
LISP
Basic Evaluation Rules
• A number evaluates to itself
• A symbol evaluates to its value.
• A list is evaluated by
– treating the first element as a function
– evaluating each arguments of the function in a left-to-right order
• An expression preceded by a quote symbol ‘ evaluates to the expression itself.
LISP
Assignment and Binding
• A symbol (or variable) can be assigned a value (called its binding) using SETQ.
• (SETQ <symbol-name> <anything>)
Example: (SETQ A ‘(A B C)) ==> (A B C)
A evaluates to ==> (A B C)
• Evaluating a symbol that does not have a value assigned (i.e., no binding) causes error
LISP
All other functions do NOT change the bindings
• In particular, FIRST and REST are non-destructive.
> (setq my-friends ‘(Superman Batman Robin) )
(Superman Batman Robin)
> (first (rest my-friends))
Batman
> my-friends
(Superman Batman Robin)
LISP
Defining My-Own Functions
• A function is defined using DEFUN
• (DEFUN <fn-name> (<arg1> ...<argK>) <exp1> ... <expN> )
• All arguments are passed by value.
• The body of the function may contain any number of expressions (i.e., function calls).
• The function returns the value returned by the last expression.
LISP
Defining A Function
(defun square (x)
(times x x) )
(defun add-friend (new-friend friends)
(cons new-friend friends) )
LISP
Predicates – Checking to see if something is true….
• Functions that return ``true’’ (i.e., T) or ``false’’ (i.e., NIL).
type-testing predicates
• (NULL <item>) returns T if <item> is NIL (empty list), otherwise NIL.
• (LISTP <item>) returns T if <item> is a list, otherwise NIL.
• (ATOM <item>) returns T if <item> is an atom (i.e., a symbol, a number, or NIL).
• (NUMBERP <item>) returns T if <item> is a number
LISP
Conditional Expression
• COND is an N-branch conditional expression(COND ( <test1> <exp11> ... <exp1L> ) ( <test2> <exp21> ... <exp2M> ) ... ( <testK> <expK1> ... <expKN> ) )• Each test is evaluated sequentially until a test
returns true.• Expressions following that test will be
executed.• COND returns the value returned by the last
expression associated with the test.
LISP Terminates a COND with a T
condition(defun select-character (enemy) (cond ( (equal enemy ‘Penguin) ‘Batman) ( (equal enemy ‘Catwoman) ‘J-Bond ) ( (equal enemy ‘Black-Knight) ‘(White-Knight King-Arthur ) ) ( T ; for all other enemies ‘SuperMan) ; ask Superman for help ))
LISP
Using AND, OR in COND(defun Evaluate-feeling ( sentence )
(cond ( (OR (member ‘hate sentence)
(member ‘dislike sentence))
‘hatred)
( (AND (member ‘I sentence)
(member ‘feel sentence) )
‘self-centered )
( T
‘happy)
) ; end of cond
) ; end of defun
LISP
Loops
i=1, while i <= 3: => (loop for i in ‘(1 2 3) do (print i)) 1 2 3 i=1, while i <= 3: (different step) => (loop for i from 1.0 to 3.0 by 0.5 do (print i))
i=3, while i >= 1: => (loop for i from 3 downto 1 do (print i)) 3 2 1
LISP
Conclusion
Things to remember:
•Lisp is considered the mother of a lot of functional languages like Scheme and Haskell …..•Common Lisp has dynamic type checking•Lisp is interpreted.
The reason why Lisp is dead:•Stock hardware platforms becoming faster than special purpose hardware•Low Interoperability with other languages