• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
LISP: Control Structures In Lisp
 

LISP: Control Structures In Lisp

on

  • 1,840 views

LISP: Control Structures In Lisp

LISP: Control Structures In Lisp

Statistics

Views

Total Views
1,840
Views on SlideShare
1,715
Embed Views
125

Actions

Likes
0
Downloads
0
Comments
0

3 Embeds 125

http://www.dataminingtools.net 119
http://dataminingtools.net 5
http://www.slideshare.net 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    LISP: Control Structures In Lisp LISP: Control Structures In Lisp Presentation Transcript

    • 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.
    • overview
      Constants and variables
      References
      Assignment
      Generalized variables
      Function invocation
      Simple sequencing
      Conditionals
      Blocks and Exits
      Iterations
      Mapping
    • Constants and variables
      CL 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 object
      function 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.
    • References
      Symbol-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 definition
      Special-form-p symbol returns a non-nil value if the symbol globally names a special form, else returns nil
    • Assignment
      The 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 variables
      The 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 invocation
      Any 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))6
      If 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,….an
      Ex: (cons 2 3)( 2 . 3 )
      (setq cons (symbol-function ‘+)#<Function +>
      (funcall cons 2 3) 5
      funcall fn &rest arguments
    • Simple sequencing
      These 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))
    • conditionals
      The 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 exits
      The 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.
    • Iteration
      Loop 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*.
    • Mapping
      Mapping 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-lists
      maplist function list &rest more-lists
      mapcfunction list &rest more-lists
      mapl function list &rest more-lists
      mapcan function list &rest more-lists
      mapcon function list &rest more-lists
    • mapcar function list &rest more-lists
      • mapcar 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.
      • The value returned by the mapcar is a list of the results of the successive calls to the function.
      Ex: (mapcar #’abs ‘(3 -4 2 -5 -6))(3 4 2 5 6) (mapcar #’ cons ‘(a b c) ‘(1 2 3))((a.1) (b.2) (c.3))
    • maplist function list &rest more-lists
      • maplist is similar to mapcar except that the function is applied to the lists and successive elements of the lists.
      Ex: (maplist #’ (lambda (x) (cons ‘foo x))
      ‘(a b c d))
       ((foo a b c d) (foo b c d) (foo c d) (foo d))
    • Visit more self help tutorials
      Pick 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