LISP: Loops In Lisp

overviewParsing loop clausesLoop syntaxLoop constructsIteration controlConditional and unconditional executionData 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 clausesSyntactic 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 executionClauses are executed in the loop body in the order they appear in the sourceExecution 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 sourceThe 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 loopsVariable 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 conditionsLoop-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-nillThe 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 operationsThe 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 syntaxA loop consists of following type of clauses:Initial-final ::=initially|finallyVariables ::=with|initial-final|for-as|repeatMain ::=unconditional|accumulation|conditional|termination|initial-finalLoop ::=(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 4NIL;;; 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 controlThe 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.

LISP: Loops In Lisp

Recommended

More Related Content

What's hot (18)

Similar to LISP: Loops In Lisp (20)

More from LISP Content (12)

Recently uploaded (20)

LISP: Loops In Lisp