• Save
LISP: Loops In Lisp
Upcoming SlideShare
Loading in...5
×
 

LISP: Loops In Lisp

on

  • 1,572 views

LISP: Loops In Lisp

LISP: Loops In Lisp

Statistics

Views

Total Views
1,572
Views on SlideShare
1,556
Embed Views
16

Actions

Likes
0
Downloads
0
Comments
0

2 Embeds 16

http://www.dataminingtools.net 15
http://dataminingtools.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: Loops In Lisp LISP: Loops In Lisp Presentation Transcript

  • Loops in Lisp
  • overview
    Parsing loop clauses
    Loop syntax
    Loop constructs
    Iteration control
    Conditional and unconditional execution
    Data types
  • A loop is a series of expressions that are executed one or more times, a process known as iteration.
    The driving element of the loop facility is the loop macro.
    The expanded form consists of three basic parts in the tag body:
    • Loop prologue contains forma that are executed before execution begins.
    • Loop body contains those forms that are executed during iteration.
    • Stepping is the process of assigning the variable the next item in the series of items.
    • Loop epilogue contains forms that are executed after iteration terminates.
  • Parsing loop clauses
    Syntactic part of the loop construct are called clauses.
    The scope of each clause is determined by the top level parsing of that clause’s keyword.
    Example for a loop with six clauses:
    (loop for I from 1 to (compute-to-value)
    while (not (unacceptable i))
    collect (square i)
    do (format t “Working on ~D now” i)
    when (evenp i)
    do (format t “ ~D is a non-odd number” i)
    finally (format t “About to exit!”))
  • Order of execution
    Clauses are executed in the loop body in the order they appear in the source
    Execution is repeated until a clause terminates a loop or until the CL return, go or throw form is encountered.
    All variables are initialized first regardless of where the establishing clauses appear in the source
    The code for any initially clauses is collected into one progn in the order in which the clauses appear in the source.
    The code for any finally clauses is collected into one progn in the order in which the clauses appear in the source.
  • A with clause introduces variable binding and an optional initial value.
    Iteration control clauses implicitly perform the following actions:
    • Initializing variables
    • Stepping variables, generally between each execution of the loop body.
    • Performing termination tests, generally just before the execution of the loop body.
  • Kinds of loops
    Variable initialization and stepping:
    • The for and as constructs provide iteration control clauses that establish a variable to be initialized.
    • The with construct is similar to a single let construct.
    • The repeat construct causes the iteration to terminate after a specified number of times.
  • Value accumulation:
    • The collect construct takes one form in its clause and adds the value of that form to the end of a list of values.
    • Append construct takes one form in its clause and appends the value of that form to the end of a list of values
    • The sum construct takes one form in its clause that must evaluate to a number and adds that number into a running total.
    • The count construct takes one form in its clause and counts the number of times that form evaluates to a non-nil value.
    • The minimize construct takes one form In clause and determines the minimum value obtained by evaluating the form.
    • The maximizeconstruct takes one form In clause and determines the maximum value obtained by evaluating the form.
  • Termination conditions
    Loop-finish lisp macro terminates iteration and returns any accumulated result.
    For and as constructs provides termination test that is determined by the iteration control clause.
    The repeat number causes termination after a specified number of iterations.
    While construct takes one form, a condition, and terminates the iteration if the condition evaluates to a nil.
    The until construct is the inverse of while. It terminates.
  • The always construct takes one form and terminates the loop if the form ever evaluates to nil.
    The never construct takes one form and terminates the loop if the form ever evaluates to non-nill
    The thereis construct takes one form and terminates the loop if the form ever evaluates to a non-nill.
    Unconditional execution:
    The do construct simply evaluates all forms in its clause.
    The return construct takes one form and returns its value.
  • Conditional execution:
    If construct one form as a predicate and a clause that is executed when the predicate is true.
    The when construct is a synonym for fi.
    The else construct provides an optional component of if, when and unless clauses that is executed when the prediction is false.
    The end construct provides an optional component to mark the end of a conditional clause.
  • Miscellaneous operations
    The named construct assigns a name to a loop construct.
    The initially construct causes its forms to be evaluated in the loop prologue, which proceeds all loop code except for initial settings specified by the constructs with, for, or as.
    The finally construct causes its forms to be evaluated in the loop epilogue after normal iteration terminates.
  • Loop syntax
    A loop consists of following type of clauses:
    Initial-final ::=initially|finally
    Variables ::=with|initial-final|for-as|repeat
    Main ::=unconditional|accumulation
    |conditional|termination|initial-final
    Loop ::=(loop [named name] {variables}* {main}* )
  • (loop {tag|expr}* )
    Where expr is any CL expression that can be evaluated , and tag is any symbol not identifiable as a loop keyword.
    (loop do {tag|expr}*)
    A loop prologue consists of any automatic variable initializations prescribed by the variable clauses, along with any initially clauses in the order they appear in the source.
  • Examples for loops:
    ;;; To print some numbers
    (loop as i from 1 to 4
    do (print i))
    1
    2
    3
    4
    NIL
    ;;; To print every third number
    (loop for i from 10 downto 1 by 3
    do (print i))
    10
    7
    4
    1
    NIL
  • ;;; step incrementally from the default starting value
    (loop as i below 5
    do (print i))
    0
    1
    2
    3
    4
    NIL
  • ;;; to print every other item in a list.
    (loop for item in ‘(1 2 3 4 5) bt #’ cddr
    do (print item))
    1
    3
    5
    NIL
    ;;; collect successive tails of a list
    (loop for sublist on ‘(a b c d)
    collect sublist)
    • ((A B C D) (B C D) (C D) (D))
  • ;;; print a list by using destructing with loop keyword ON.
    (loop for (item) on ‘(1 2 3)
    do (print item))
    • 1
    2
    3
    NIL
    ;;; print items in a list without using destructing
    (loop for item in ‘(1 2 3)
    do (print item))
    • 1
    2
    3
    NIL
  • End-test control
    The loop keywords always, never, thereis, until, and while designate constructs that use a single test condition to determine when loop loop iteration should terminate.
    while expr while construct allows iteration to continue until the specified expression expr evaluates to nil.
    until expr until construct is equivalent to while, if the value of the specified expression is non-nil, iteration terminates.
    always expralways takes one form and terminates the loop if the form ever evaluates to nil.
  • Never expr never form takes one form and terminates the loop if the form ever evaluates to non-nill.
    thereis expr thereis construct takes one form and terminates the loop if the form ever evaluates to a non-nil.
    While and until constructs causes termination, control is passed to the loop epilogue, where any finally clauses will be executed.
  • Ex:
    (loop for i from 0 to 10
    always ( < i 11)) T
    (loop for i from 0 to 10
    never (> i 11)) T
    (loop for i from 0 to 10
    always ( < i 9)
    finally (print “you won’t see this”))NIL
    (loop never t
    finally (print “you won’t see this”))NIL
  • (loop thereis “Here is my value”
    finally (print “you won’t see this”)) “here is my value”
    (loop for i from 0 to 10
    thereis (when (> i 10) i) ) 11
    (loop for i from 1 to 10
    thereis (> i 11)
    finally (print i)) 11
    NIL
  • Unconditional execution
    The loop construct do takes one or more expressions and simply evaluates them in order.
    do {expr} do construct simply evaluates the specified expressions wherever they occur in the expanded form of loop.
    Ex: (loop for ifrom 1 to 5
    do (print i))
    • 1
    2
    3
    4
    5
    NIL.
  • return expr return construct terminates the loop and returns the value of the specified expression as the value of the loop .
    Ex: (loop for item in ‘( 1 2 3 a 4 5)
    when (not (numberp item))
    return (cerror “enter new value”
    “non-numeric value: ~s”
    item))
     Error: non-numeric value: A
  • Data types
    type-spec argument that allows you to specify certain data types for loop variables.
    The type-spec argument syntax:
    type-spec ::=of-type d-type-spec
    d-type-spec ::=type-specifier|(d-type-spec . D-type-spec)
    The type-spec argument is used for destructing
  • 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