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

LISP:Declarations In Lisp

on

  • 667 views

LISP:Declarations In Lisp

LISP:Declarations In Lisp

Statistics

Views

Total Views
667
Views on SlideShare
641
Embed Views
26

Actions

Likes
0
Downloads
0
Comments
0

2 Embeds 26

http://www.dataminingtools.net 23
http://dataminingtools.net 3

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:Declarations In Lisp LISP:Declarations In Lisp Presentation Transcript

  • Declarations in Lisp
  • Declarations
    Declarations allow the user to specify extra information about the program to Lisp system.
    Declarations are truly optional but special declarations do effect the interpretation of the variable bindings and references and so must be specified wherever necessary.
    Declarations are one of the good ways to add documentation to the program.
  • overview
    Declaration syntax
    Declaration specifiers
    Type declaration for forms
  • Declaration syntax
    declare construct is used to embed declarations within the executable code.
    A declare form is known as the declaration.
    A declaration may occur only at the beginning of the bodies of the certain special forms.
    declare {decl-spec}*
  • Declarations may occur in the lambda expressions and in the forms listed below:
  • Variable bindings appear only to the bindings made by the form at the head of whose body they appear.
    (defun foo (x)
    (declare (type float x))..
    (let (( x’a)) …)
    ….)
    The type declaration applies only to the outer binding of the x and not to the binding made in the let.
    The scope of the declaration always includes the body forms, as well as any “stepper” or “result” forms, of the special forms or lambda-expressions.
    If the declaration applies to a name binding, then the scope of declaration also includes the scope of the name binding.
  • locally {declaration}* {form}*
    This macro is used to make local pervasive declarations where desired.
    This construct does not bind any variables.
    Special declaration may be used with lacally to pervasively affect references to, rather than bindings of, variables.
    The function proclaim takes a decl-spec as its argument and puts it into effect globally.
  • proclaim decl-spec
    The proclaim takes decl-spec as the argument and puts it into effect globally.
    Ex: (proclaim ‘(type float tolerance)) specifies that the dynamic value of the tolerance should always be a floating-point number.
    A proclaim takes special decl-spec as applying to all bindings as well as to all references of the mentioned variables.
    This macro is syntactically like declare and semantically like proclaim.
    It is an executable form and may be used anywhere proclaim may be called.
    declaim {decl-spec}*
  • Declaration specifiers
    List of valid declaration specifiers for use in declare.
    (special var1 var2….) specifies that all of the variables named are to be considered special.
    (type var1, var2,…) affects only variable bindings and specifies that the variables mentioned will take on values only of the specified type.
  • (ftype type function-name-1, function-name-2,…) specifies that the named functions will be of the function type type.
    Ex: (declare (ftype(function (integer list) t) nth)
    (ftype (function (number) float) sin cos))
    To extend ftype declaration specifiers to accept any function-name, one may write
    (declaim (ftype (function (list) t) (setf cadr)))
  • (inline function1, function2,…)specifies that it is desirable for the compiler to open code calls to the specified functions.
    The compiler is free to ignore this declaration.
    (notinline function1, function2,…)specifies that it is undesirable for the compiler to compile the specified functions inline.
    This declaration is pervasive and the compiler is not free to ignore this declaration.
    (ignore var1,var2,….) affects only variable bindings and specifies that the bindings of the specified variables are never used.
    (optimize (quality1 value1) (quality2 vale2)…) advises compiler that each quality must be given attention according to the specified corresponding value.
  • (declaration name1, name2,…) advises the compiler that each namej is a valid but non-standard declaration name.
    The is kind of declaration may be used only as a proclamation.
    Ex: (proclaim ‘(declaration author
    target-language
    target-machine))
     (proclaim ‘(target-language ada))
    (proclaim ‘(target-machine IBM-650))
    (defun strangep(x)
    (declare (author “Harry Tweeker”))
    (member x’(strange weird odd peculiar)))
  • Type declarations for forms
    The special form is defined to declare the type of value held by a bound variable.
    (the type form)the type of value means the type of value of is declared to be of type type.
    the value-type formthe form is evaluated and whatever it produces is returned by the form, it is an error if what is returned by the form does not confirm to the data-type specified by value-type.
  • Examples:
    (the string (copy-seq x)) the result will be a string.
    (the integer (+ x 3)) the result of + will be an integer.
    (+ (the integer x) 3)the value of x will be an integer.
  • 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