A brief introduction to lisp language

A Brief Introduction to
Lisp Language
Tianyu Gu
tigu1400@student.miun.se

A Brief History
● Originally specified in 1958, Lisp is the second-oldest high-level
programming language in widespread use today; only Fortran is
older (by one year).
● Lisp stands for LISt Processing(while Fortran stands for
FORmula TRANslator).
● 1958 ~ 1980: Various dialects and systems, MacLisp, InterLisp,
and Lisp Machines.
● 1975 ~ 1980: Scheme, the first dialect choosing lexical scope,
developed in MIT.
● 1980 ~ 1990: Common Lisp, an industry-level language,
published in ANSI standard.
● 1990 ~ Now: Various implementation for Common Lisp and
Scheme; More 3rd party libraries; A new dialect Clojure.

First Impression
// C Code
int factorial(int n){
if(n==0)
return 1;
else
return n *
factorial(n-1);
}
;; Common Lisp Code
(defun factorial (n)
(if (= n 0)
1
(* n
(factorial (- n
1)))))

First Impression: Evolution
// C code, using tail recursion
int factorial_helper(int result, int count){
if(count == 0) return result;
else
return factorial_helper(result*count, count-1);
}
int factorial(int n){
return factorial_helper(1, n);
}
;; Common Lisp code, using tail recursion
(declare (optimize (speed 3)))
(labels ((iter (result count)
(if (= count 0)
result
(iter (* result count) (1-
count)))))
(iter 1 n)))

First Impression: Final 'Product'
;;;; can even use a function called ‘disassemble’
;;;; to check the assemble code.
(declare (optimize (speed 3)))
(labels ((iter (result count)
(declare (type fixnum result count))
(if (= count 0)
result
(iter (the fixnum (* result count))
(the fixnum (- count 1))))))
(iter 1 n)))

Multi-Paradigms: Functional
Lambda(λ)
((lambda (x y) (+ x y)) 1 2) => 3
Map
(map 'list #'(lambda (x) (1+ x)) (list 0 1 2 3)) => (1 2 3 4)
Filter
(remove-if-not #'oddp (list 1 2 3 4 5 6)) => (1 3 5)
Fold(foldr in ML)
(reduce #'+ (list 1 2 3 4 5)) => 15
Curried Function, Lazy Evaluation, and more...

Multi-Paradigms: Imperative
Common Lisp does provide imperative operators
like:
(setf x 10) ⇔ x := 10
And for functional functions, Common Lisp also
provides their ‘destructive’ version:
map <-> map-into
filter(remove-if-not) <-> delete-if-not
And even more: goto, for, while...

Multi-Paradigms: OOP
● Common Lisp has its own implementation for object
oriented programming, which is called CLOS.
● Unlike Java or C++, Common Lisp uses an approach
called Generic Function instead of Message Passing.
● Basically, all the methods belongs to generic function
instead of a specific class.
● For example, if there's a human class and there's a
method called speak, then I create an instance of human
called 'me':
o In message passing style-> me.speak("Hello")
o In generic function style-> speak(me, "Hello")

Multi-Paradigms: OOP
A 'men' will have different behavior.
It’s called method combination.

What Makes Lisp Special?
1. S-Expression
1. Macro

S-Expression
In Common Lisp, a s-exp would be like:
s-exp : (op s-exp1 s-exp2 ...)
op: a function | a macro | a special form
And interestingly, a s-exp could be ‘made’ like this:
(cons 1 2) => (1 . 2)
(cons 1 (cons 2 nil)) => (1 . (2 . nil)) => (1 2)
(cons ‘+ (cons 1 (cons 2 nil))) => (+ 1 2)
(eval (cons ‘+ (cons 1 (cons 2 nil)))) => 3

S-Expression
A s-exp looks like a linked list but actually a tree.
(car (list ‘+ 1 2)) => ‘+
(cdr (list ‘+ 1 2)) => (1 2)
+
1
2 nil
Writing s-expressions is actually writing the
Abstract Syntax Tree(AST).

S-Expression: Benefits
1. There will be no lexical analysis because
all the codes already are the AST.
2. There will be no need to worry about the
Operator Precedence.
3. Very convenient to represent data
structures like trees and graphs.

Macro:
Why Lisp is Called
Programmable Programming Language?
● Unlike functions, macros will be expanded
first before evaluated;
● After expanding finished, the whole s-expression
generated by macro will be
evaluated;
● So a macro is actually a function that
transforms arguments to s-expressions.

Macro: A Simple Example
In this case, it acts like a inline function.

Macro:
A Real (but a little silly) Example
Macros can do something that a function can never do.

Macro: A Real Example
Macros can do something that a function can never do.

Macro: Even Let Evaluation
Happens During ‘Compiling’ Time
As mentioned before, a macro will be expanded before
evaluated -- even before compiled.
‘Counting how many numbers’
happens before run time.

Lisp:
An ‘Edge’ of Programming Languages
C++, Java ... Python, Ruby … ML, Haskell
C Lisp

We toast the Lisp programmer who pens
his thoughts within nests of parentheses.
-- Alan J. Perlis
<SICP>’s foreword
Thanks for watching!

A brief introduction to lisp language

Recommended

More Related Content

What's hot (19)

Viewers also liked (20)

Similar to A brief introduction to lisp language (20)

A brief introduction to lisp language

Editor's Notes