A form is anything which is to be evaluated .
Lisp is formed of two things : atoms and cons .
atom is anything which is not a
cons , a
cons holds two references.
list is formed of zero or more
cons , where the second element of each
cons , is a reference to the next
cons , and the last element of the last
cons is either a reference to the
nil element , which represents the empty list
() , or nothing , or the last element of the last
cons is a reference to an atom . In the latter case , this list is called a dotted list . The elements of a list , are enclosed between a left parenthesis
( , and a right one
This being said , a form or what can be evaluated in lisp , is either an
atom or a
cons, or more generally , instead or saying a
cons , a
Evaluating atom forms
An atom form can be either , a self evaluating atom , or it can be a symbol .
Self evaluating atoms
If the form is an atom , an atom can be an atom which evaluates to itself , hence the value of evaluating the atom form , is the atom itself .
As an example , when evaluating a number such as
1 , it evaluates to
1 , or when evaluating a string such as
"Hello world " , it evaluates to
"Hello world " .
> 1 ;;;evaluating 1 , yields ;;;1 . 1 > "Hello world" ;;;evaluating "Hello world" , ;;;yields "Hello world" . "Hello world"
If the form is an atom , an atom can also be a symbol . A symbol has , among other things , a name , a function property , and a value property .
If the form , is just a symbol , then what is evaluated is its value property . Some symbols evaluate to themselves , for example
nil which is the empty list
() , are both symbols , that evaluates to themselves .
>(symbolp nil ) ;;;symbolp checks if the passed ;;;argument is a symbol , it ;;;returns true , since nil ;;;is a symbol . T > nil ;;;nil evaluates to itself nil > (set 'ip "192.168.0.1" ) ;;;set the value property of ;;;the symbol ip to the string ;;;192.168.0.1 . ip is quoted ;;;using ' as not to be evaluated . > ip ;;;ip is evaluated , this returns ;;;the attribute value , which is : "192.168.0.1"
Evaluating list forms
If what is to be evaluated is a non empty list , hence a list which contains some elements , then this list is called a compound form . The empty list
( ) is a symbol , and it evaluates to itself .
A list , depending on the first element , that it has , is called either : a function form , a lambda form , a macro form or a special form .
What is a function form ?
A function performs a computation , such as an addition , or a regular expression matching .
A function form is just a non empty list , which has as a first element , a symbol , which has a function property , that defines a function .
How a function form is evaluated , is that first the remaining elements of the list , known as the
cdr of the list , are evaluated one after another , from left to right in order . Once their evaluation is done , their evaluation is applied to the function .
The standard does not specify , if the symbol which contains the function definition , is evaluated before, or after , or in between , the evaluation of the arguments .
> (+ 1 pi ) ;;;This is a function form , ;;;+ is a symbol , which has ;;;its function property defining ;;;a function . ;;;First the remainder elements of ;;;the list are evaluated from left ;;;to right , one after the other . ;;;1 evaluates to 1 . ;;;pi is a symbol , its value property ;;;is evaluated , this returns : ;;; 3.1415926535897932385L0 . ;;;The standard does not specify , ;;;when symbol + is evaluated . ;;;Evaluating the symbol + , returns ;;;its function definition . ;;;Once arguments and function definition ;;;evaluation is done , the function ;;;is called with the evaluated arguments . ;;;The addition of 1 and ;;; 3.1415926535897932385L0 , is ;;;equal to 4.1415926535897932383L0 . 4.1415926535897932383L0
To check if the function property , of a symbol is of a function type ,
functionp can be used , this is not the same as checking , if a symbol has its function property bounded , in this case
fboundp can be used .
>(functionp '+ ) ;;;' is used to quote a ;;;symbol , as not to be ;;;evaluated . ;;;The symbol + is not ;;;of type function , it ;;;is a symbol which has ;;;some properties . NIL >(functionp #'+ ) ;;;#' returns the value ;;;of the property : function ;;; of a symbol . ;;;The function property of ;;;+ is of a function type . T >(fboundp '+ ) ;;;Checks if the symbol + ;;;has its property : function ;;;bounded . T
What is a lambda form ?
A lambda form , is a non empty list , which has as a first element , a lambda expression .
A lambda expression is a function , which has no name , and is defined by using a list , which first element is the symbol
lambda , followed by a list , that contains the function parameters , known as , a lambda list , a lambda list can be empty , as such the function receives no arguments . The lambda list is followed by zero or more optional forms , which constitutes the function body . If the lambda function , has no body , it just returns
nil , otherwise it returns the value of the last evaluated form .
The evaluation of a lambda form , is equivalent to using
funcall . What this means , is that since
funcall is a function , all its arguments are first evaluated from left to right , hence the lambda expression is first evaluated , followed by the remainder elements of the list , finally
funcall will apply the gotten function , from the lambda expression , to the evaluated arguments , and returns the result .
> ((lambda (x ) (* x x ) ) 2 ) ;;;This is a lambda form , since ;;;the first element of the list ;;;is a lambda expression . ;;;The lambda expression is first ;;;evaluated to get its function ;;;definition . ;;;The second element of the form , ;;;is 2 , it evaluates to itself , ;;;which is 2 . ;;;The gotten function is applied ;;;to the argument 2 , this ;;;returns 4 . 4
What is a macro form ?
A function performs a computation , such as an addition , or sorting some elements , whereas a macro function , returns another form to be evaluated , in other words , it returns a new program .
A macro form , is a non empty list , which has as a first element a symbol , which has its function property , defining a macro .
To check if the function property of a symbol , defines a macro ,
macro-function can be used .
macro-function returns nil , if the property function of a symbol , does not define a macro .
> (defmacro sub(var ) `(- ,var 1 ) ) ;;;Define the symbol sub , ;;;function property with ;;;a macro definition . SUB >> (macro-function '+ ) ;;;The property function of the ;;;symbol + , is not a macro ;;; definition , hence ;;; macro-function returns NIL . NIL > (macro-function 'sub ) ;;;The symbol sub function property ;;;is a macro definition , hence ;;;macro-function does not return ;;;nil . #<FUNCTION SUB (SYSTEM::<MACRO-FORM> SYSTEM::<ENV-ARG>) (DECLARE (CONS SYSTEM::<MACRO-FORM>)) (DECLARE (IGNORE SYSTEM::<ENV-ARG>)) (IF (NOT (SYSTEM::LIST-LENGTH-IN-BOUNDS-P SYSTEM::<MACRO-FORM> 2 2 NIL)) (SYSTEM::MACRO-CALL-ERROR SYSTEM::<MACRO-FORM>) (LET* ((VAR (CADR SYSTEM::<MACRO-FORM>))) (BLOCK SUB `(- ,VAR 1))))>
A macro form is evaluated , by first evaluating the macro , and expanding it , replacing the macro form . The arguments are evaluated as part of the expanded form .
> (defmacro sub(var ) `(- ,var 1 ) ) ;;;Defines the function property ;;;of the symbol sub , as being ;;;a macro defintion . > (sub pi) ;;;sub function property , is a macro ;;;definition , hence what happens first, ;;;is that sub is expanded , and the form ;;;is replaced , by sub expansion . ;;;pi as a symbol , is not evaluated , ;;;first , it is only evaluated , ;;;when evaluating the replacement ;;;form , which is now : ;;;(- pi 1 ) ;;;This is a function form , ;;;the cdr of the list , ;;;which is its remainder , ;;;is evaluated . ;;; pi is evaluated to get ;;;3.1415926535897932385L0 ;;;1 is evaluated to 1 . ;;;The standard does not specify , ;;;when the symbol - is evaluated , ;;;to get its function definition . ;;;It can be , before , after , or ;;;in between evaluating the arguments. ;;;Once the elements of the list ;;;are evaluated , the function ;;;- is applied to the gotten ;;;arguments , and the returned ;;;value is 2.1415926535897932385L0 2.1415926535897932385L0
What is a special form ?
A special form , is a form , which has as its first element , a special operator . The special operators are :
block catch eval-when flet function go if labels let let* load-time-value locally macrolet multiple-value-call multiple-value-prog1 progn progv quote return-from setq symbol-macrolet tagbody the throw unwind-protect
A special form , might have a special syntax , or a special evaluation rule , for example it might not evaluate all of its arguments .
> (if t 1 pi ) ;;;In this example , pi is ;;;never evaluated , since ;;;the condition is true , ;;;hence what is evaluated ;;;is 1 , which evaluates , ;;;to itself . 1