LISP: Control Structures In Lisp

Common Lisp provides with a variety of special structures for organizing the programs.Some have to do with the flow of control. These are called as control structures.Locally defined functions(flet, labels) and macros( macrolet) are quite flexible.CL provides: simple one-way conditionals (when and unless.)

the simple two-way conditionals (if)

more general multi-way conditionals( cond, case)Constructs for performing non local exits with various scoping disciplines are provided: block, return, return-from, catch and throw.

overviewConstants and variablesReferencesAssignmentGeneralized variablesFunction invocationSimple sequencingConditionalsBlocks and ExitsIterations Mapping

Constants and variablesCL provides two kinds of variables: ordinary variables and function names. One of them is used to name defined function, macros, and special forms , and the other to name data objects. The name of the ordinary variable may be obtained by simply writing the name of the variable as a form to be executed.The following functions and variables allow reference to the values of constants and variables:quote object simply returns the objectfunction fn if fn is a symbol, the functional definition associated with that symbol is returned. If fn is a lambda-expression, then a “lexical closure” is returned.

ReferencesSymbol-value symbol returns the dynamic current value of the symbol, error occurs if the symbol has no values.Symbol-function-symbol returns the current global function definition named by the symbol, error is signaled if the symbol has no function definition.Symbol-function is applicable only for global functions its not applicable for lexical function name produced by flet or labels.

Symbol-function can be called on any function on which fbound function is true.fbound in turn returns true for symbols which define a macro or a special form.When symbol-function is used with typef, its new value must be type function.fdefinition function-name returns the current global function definition named by the argument function name.

boundp symbol returns true if the symbol has a value, else returns false.fboundp symbol returns true if the function has global function definitionSpecial-form-p symbol returns a non-nil value if the symbol globally names a special form, else returns nil

AssignmentThe following allow the value associated with the current binding of the variable to be changed.(setq var1 form1 var2 form2 ….) here first the form1 is calculated and the value is stored in val1, then form2 is calculated and stored in form2 and so on..Setq returns the last value assigned, there must be even number of arguments forms.Ex: (setq x (* 3 2) y (cons x nil))retains the first set value of x as 6 and returns 6.Psetq {form}* is similar to setq except that assignments happen in parallel.Ex: (setq a 4) (setq b 6) (psetq a b b a) a=6 and b=4, thus the values of a and b are exchanged by using parallel assignment

Set symbol value1  allows the alteration of the dynamic variable , set allows the symbol to take value1 as its value.Ex: (set (if (eq a b) ‘c ‘d) ‘foo) sets either c to foo or d to foo depending on the outcome of the result, set returns the value as a result.makeunbound symbol causes the dynamic(special) variable named by symbol to become unbound.fmakeunbound symbol makes the analogous thing for the global function definition named by symbol.

Generalized variablesThe concept of the variables named by symbols can be generalized to any storage location that can remember one piece of data.Ex of such storage locations are the car and cdr of cons.Basic operations on variables are: access and update operations.The following table give the various access and update functions:

Setf is a macro that that examines an access form and produces a call to corresponding update function.Setf {place new-value}* takes a form place that when evaluated accesses a data object in some location and “inverts” it to produce a corresponding form to update the location.If more than one place-newvalue pair is specified, the pairs are processed sequentially; that is(setf place1 newvalue1, place2 newvalue2, …… placen newvaluen)

Rotatef{place}* each place form may be any form acceptable as a generalized variable to setf.In the form (rotatef place1,place2,...placen) the values of place1 to placen are being accessed and saved.It is as if all the places from an end-round shift register that is rotated one place to the left, with the value of place1 being shifted around to the end to placen. (setf place1 value1 place2 value2…) the subforms of place1 and value1 are evaluated, the location specified by place1 is modified to contain the value returned by value1, and then the rest of setf form is processed in a like manner.

Function invocationAny list that has no other interpretation to as a macro call or special form is taken to be a function call.This applies function to a list of arguments.The arguments of the function consists of the last arguments to apply appended to the end of the list of all the other arguments to apply but the function itself.Ex: (setf a ‘*) (apply a ‘( 3 2))6If the function takes keyword arguments , the keywords as well as the corresponding values must appear in the argument list.Ex: (apply # ‘(lamda (&key a b) (list a b)) ‘(:b 3))(nil 3)apply function arg &rest more-args

(funcall fn a1,a2,a3……an) applies the function fn to arguments a1,a2,….anEx: (cons 2 3)( 2 . 3 ) (setq cons (symbol-function ‘+)#<Function +> (funcall cons 2 3) 5funcall fn &rest arguments

Simple sequencingThese constructs simply evaluate all the argument forms in order. progn {form}*  progn construct takes a number of forms and evaluates them sequentially in order from left to right.The values of all forms but the last are discarded, whatever the last form evaluates is returned as the result. prog1 first {form}*  is similar to progn but it returns the value of its first form.prog2 first second {form}* is similar to prog1, but it returns the value of the second form. prog2 ( a b c d…….) is similar to (prog a( prog1 b c…..z))

conditionalsThe traditional conditional construct in lisp is cond.CL also produces the dispatching constructs case and typecase.If test then [else] first the form is evaluated. If the result is not nil, then the form is selected.(If test then else) is similar to (cond (test then) (t else))(when test form1 form2…)first evaluates test. If the result is nil, then no form is evaluated, and nil is returned.Otherwise the forms constitute an implicit progn and are evaluated sequentially from left to right, and the value of the last one is returned .

(unless test form1 form2….) first evaluates test. If the result is not nil, then the forms are not evaluated, and nill is returned.Otherwise the form constitutes an implicit progn and are evaluated sequentially from left to right, and the value of the last one is returned.(cond (p…) (q…) (r…) ……… (t…))Is similar to if p then… else if q then…. else if r then….. ….. else……

typecase keyform {(type {form}* )}* typecase is a conditional that chooses one of it clauses by examining the type of an object. Its form is as follows:(typecase keyform (type-1 consequent-1-1 consequent-1-2…..) (type-2 consequent-2-1 …..) (type-3 consequent-3-1 ….) ….. )

Blocks and exitsThe block and return-form constructs provide a structured lexical non-local exit facility.block name {form}* the block construct executes each form from left to right, returning whatever is returned by the last form.

return-from name [result] return-from is used to return from a block or from such constraints as do and prog that implicitly establish a block.The name is not evaluated and must be a symbol.The evaluation of result produces multiple values, those multiple values are returned by the construct exited.return [result] (return form) is identical in meaning to (return-from nil form)It returns from a block named nil.

IterationLoop construct provides a trivial iteration facility. It controls no variables, and simply executed its body repeatedly.loop {form}* each form is evaluated from left to right, when the last form has been evaluated, then the first form is evaluated again, and so on in a never ending cycle.Its execution must be terminated explicitly, using return or throw.

Do and do*Macro syntax:do ({var [init [step]])}*) (end-test {result}*) {declaration}* {tag|statement}*do* ({var [init [step]])}*) (end-test {result}*) {declaration}* {tag|statement}* The do special form provides a generalized iteration facility, with an arbitrary number of “index variables”.

Do form looks like this(do ((var1 init1 step1) (var1 init1 step1) …….(var1 init1 step1) (end-test . result) {declaration}* .tagbody) The do* looks exactly the same except that the name do is replaced by do*.

MappingMapping is type of iteration in which a function is successively applied to pieces of one or more sequences.The result of the iteration is a sequence containing the respective results of the function applications.The function map may be used to map over any kind of sequence.

The following functions operate only on lists:mapcar function list &rest more-listsmaplist function list &rest more-listsmapcfunction list &rest more-listsmapl function list &rest more-listsmapcan function list &rest more-listsmapcon function list &rest more-lists

mapcar function list &rest more-listsmapcar operates on successive elements of lists, first the function is applied to the function of each list, then to the cadr of each list, and so on.

LISP: Control Structures In Lisp

Recommended

More Related Content

What's hot (20)

Similar to LISP: Control Structures In Lisp (20)

More from LISP Content (10)

Recently uploaded (20)

LISP: Control Structures In Lisp