LISP:Program structure in lisp
2 likes2,204 views
Program structure in Lisp can be summarized as follows: 1. Forms are the basic units of computation and come in various types like self-evaluating forms, symbols, lists, and special forms. 2. Variables and functions are defined using symbols and lambda expressions. Variables can be global or local while functions can be named or anonymous. 3. Control structures like conditionals and loops are implemented using special forms. Macros allow defining new syntactic constructs that are expanded before evaluation. 4. Top-level forms interact through a read-eval-print loop and can declare global variables, constants, and functions. Special forms control aspects like compilation and loading.
![Special (dynamic)Special formsCommon lisp special forms:While the lisp is being evaluated as a form, if the first element is one of the element in the above table, then it is called a special form.Ex: (if p (+ x 4) 5) means if p then x+4 else 5block if progvcatch labels quote[compiler-let] let return-fromdeclare let* setqeval-when macrolet tagbodyflet multiple-value-call thefunction multiple-value-prog1 throwgo progn unwind-protect](https://image.slidesharecdn.com/programstructureinlisp-100315065916-phpapp02/85/LISP-Program-structure-in-lisp-7-320.jpg)
LISP:Program structure in lisp
- 1. Program structure in Lisp
- 2. overviewFormsVariablesMacrosFunction callsNamed functionsLambda expressionsTop-level formsDeclaring global variables and named constantsControl of time and evaluation
- 3. formsForms are the standard units of iteration in CL implementation.A form is simply a data object meant to be evaluated as a program to produce one or more values.Meaning full forms may be further divided into:Self-evaluating forms(numbers)
- 5. ListsLists can further be divided as: special forms, macro calls and function calls.All characters, numbers, string, and bit-vectors are all self-evaluating forms.When such an object is evaluated, that object is returned as the value of the form.
- 6. VariablesSymbols are used as the names for the variables in CL programs.When a symbol is evaluated as the form, the value of the variable it names is produced.Ex: (setq w 8)produces 8Types of variables:Lexical (static)
- 7. Special (dynamic)Special formsCommon lisp special forms:While the lisp is being evaluated as a form, if the first element is one of the element in the above table, then it is called a special form.Ex: (if p (+ x 4) 5) means if p then x+4 else 5block if progvcatch labels quote[compiler-let] let return-fromdeclare let* setqeval-when macrolet tagbodyflet multiple-value-call thefunction multiple-value-prog1 throwgo progn unwind-protect
- 8. It is recommended that the program-analyzing program process a form that is a list whose car is a symbol as follows:If the program has particular knowledge about the symbol, process the form using special –purpose code. All the symbols in the previous table fall under this category.
- 9. If the macro-function is true of the symbol, apply either macro-expand or macroexpand-1, as appropriate to the entire form and then start over.
- 10. Otherwise, assume it as a function call.MacrosA macro is essentially a function from forms to forms.Given a call to a macro, compute a new form to be evaluated in the place of the macro call.There are a number of standard forms in CL, to define a new form use defmacro.
- 11. Function callsWhile the list is being evaluated as a form, if the first element is not a symbol that names a special form or a macro, the it is considered as a function call.The first element of the list is taken as the name of the function.All the remaining elements of the list are evaluated and one value is obtained from each form, and these values become the arguments to the function.Whatever values the function returns becomes the values of the function-call forms.
- 12. Function calls continued..Ex: (+ 3 (* 1 2)) here, + is not a special form or macro. So 3 and (* 1 2) are considered as arguments of the function call, again 1 2 are taken as arguments of the function call (* 1 2) and the value 2 is returned. The values 2 and 3 are given as arguments for the addition function to produce the result 5. Thus, ( + 3 (* 1 2))5
- 13. FunctionsTwo ways to indicate the function as the function-call form are: using symbols to name the functions
- 14. using a lambda-expression whose first element in the list is lambda.Lambda expressions or the symbols when used in programs as the name of the functions, can appear only as the first element of the function-call form, or the second element of the function special form.A global name can be given to a function using the defun construct.A local name is given to the function using the flet or labels construct.
- 15. Lambda-expressionsA lambda-expression has the following syntax:(lambda lambda-list .body)The first element must be lambda, the second element must be the list, and specifies names for the parameters of the listThe body may consists of zero or more number of forms.Each element in the lambda-list is either a parameter specifier or the lambda-list keyword.(lambda-list keywords begin with &)Var or svar must be a symbol( the name of the variable),Each keyword must be a keyword symbol, such as :start
- 16. A lambda-list has five partsSpecifiers for the required parameters: these are parameter specifiers up to the first lambda-list keyword.Specifiers for the optional parameters: these are the specifiers following the lambda-list keyword &optional up to the next lambda-list keyword or the end of the list.A specifier for a rest parameterSpecifiers for the keyword parametersSpecifiers for the aux parameters: If the lambda-list keyword &key is present, all specifiers after it are auxiliary variable specifiers.
- 17. Top-level formsThe standard way to interact with CL implementation is via a read-eval-print loop.The system reads a form from the same input source, evaluates it and then prints the value to the output sink.Top-level special forms are used:To define globally named functions
- 18. Define macros
- 20. Define global values for special variablesIf progn appears at top-level, then all forms within that progn are considered by the compiler to be top-level forms.
- 21. Defining named functionsdefun special form is used for defining named functions. evaluating the defun form causes the symbol name to be a global name for the function specified by the lambda-expression.(defun (setf cadr)…) is used to define a setf expansion function to cadr.Forms constitute the body of the defined function, they are executed as an implicit progn.defun name lambda-list [[ {declaration}* | doc-string]] {form}*
- 22. Declaring global variables and named constantsThe following special forms are used to specify globally defined variables: defvar
- 23. defparameter
- 24. defconstant (used for defining named constants)Syntax:defvar name [initial-value [documentation]]defparameter name initial-value [documentation]defconstant name initial-value [documentation]
- 25. (defvar variable) proclaims the variable to be special.defvar also gives a good option to provide the comment for the variableEx: (defvar *visible-windows* 0 “number of visual windows at least partially visible on the screen”)defparameter is similar to defvar, but it requires an initial value-form, always evaluates the form, and assigns the result to the variable.defconstant is like defparameter but does assert that the value of the variable name is fixed and does license the compiler to build assumptions about the value into program being compiled.
- 26. Control of time and executionThe eval-when special code allows pieces of code to be executed only at compile-time, only at load time, or when interrupted but not compiled.eval-when ({situation}*) {from}*The body of the eval-when form is processed as an implicit progn only if the situation is a symbol, either compile, eval or load.Eval specifies that the interpreter should process the body.Compile specifies that the compiler should evaluate the body at compile time.Load specifies that the compiler should arrange to evaluate the forms in the body when the compiled file containing the eval-when form is loaded.
- 27. Procedure for processing a form:If the form is an eval-formif the situation load is specified:
- 28. if the situation compile is specified, or if the current processing mode is compile-time-too and the situation eval is specified, the process each of the forms in the body in compile-time-too mode.
- 30. if the situation load is not specified:
- 31. if the situation compile is specified, or if the current processing mode is compile-time-too and the situation eval is specified, then evaluate each of the forms in the body in the compiler’s executing environment.
- 32. else, ignore the eval-when form entirelyEx: the use of eval-when is that if the compiler is to be able to properly read a file that uses user defined reader macro characters , it is necessary to write(eval-when (compile load eval) (set-macro-character #\$ #’(lambda (stream char) (declare (ignore char)) (list ‘dollar (read stream))))) This causes the call to set-macro-character to be executed in the compiler’s execution environment, thereby modifying its readers syntax table.
- 33. Visit more self help tutorialsPick a tutorial of your choice and browse through it at your own pace.The tutorials section is free, self-guiding and will not involve any additional support.Visit us at www.dataminingtools.net