There are thus two equivalent ways to define a function named square which computes the square of its argument:

(setq square (lambda(x) (* x x)))

or

(de square(x) (* x x))

The evaluation of the list (lambda...) returns a function that setq stores into symbol square . The function de is a shorthand for this manipulation.

A function behaves as any atom does. Its class however defines how to evaluate a list whose first element evaluation returns that function. The evaluation of a list whose first element is a symbol, the value of which is a function, thus simply calls that function. The evaluation of the following list then returns 25

 (square 5)

But the evaluation of the following list also returns 25

 ((lambda(x) (* x x)) 5)

There are several kinds of functions in Lush; briefly described hereafter:

• DX functions are written in C, using the standard Lisp to C interface package. Most of the C functions are written as DX.
  
• DY functions are directly written in C. These functions are usually control structures, like cond , progn , etc...
  
• DE functions are written in Lisp. These functions evaluate their arguments before calling their body. Most Lisp functions are DE functions.
  
• DF functions are also written in Lisp. They do not however evaluate their arguments before giving control to the function body.
  
• DM functions are also known as ``macro functions''. They are written in Lisp. Their argument list includes the function name itself, and its elements are not evaluated. The body of the function is supposed to return an evaluable list, known as the macro expansion. This list is then evaluated in the calling context, and gives the result of the function call.
  
• DMD functions are a refinement of DM functions. Unlike the DM functions, their argument list does not include the function name. The result of the body evaluation replaces the calling form itself in the calling context. The evaluation process is then restarted. This replacement process happens just once, because the code is physically replaced by the result of the macro expansion during the first call.
  
• DMC are known as ``macro characters''. These are not real function. They are bound to a single character name and take no arguments. Once the Lush reader reaches such a character, it calls the function body and substitutes the result to the macro-character.
  

Valid formal argument lists may be a single symbol, a list of symbols, or something more complex like (a b (c d) . f) , or (a b &optional c d) .

If the formal argument list is a single symbol, it will be bound to the list of arguments when the function is called.

If the formal argument list is a list, its ``car'' will be matched against the ``car'' of the actual arguments, and its ``cdr'' will be matched against the ``cdr'' of the actual arguments.

Example:

? (de surface((x1 y1) (x2 y2) )
       (* (- x1 x1) (- y2 y2)) )
= surface
? (surface '(4 5) '(8 10))
= 40

Moreover, two symbols &optional and &rest in argument lists have a special meaning, similar to the Common Lisp conventions.

Only symbols and lists composed of a symbol and a default value may follow the &optional symbol in the formal argument list. These symbols are optional arguments. If they are omitted, they are bound to their default value, or the empty list.

Example:

? (de printline(s &optional (indent 0) (terminate "."))
       (tab indent)
       (printf "%s%s\n" s terminate) )
= printline
? (printline "hello")
hello.
= ()
? (printline "hello" 6)
      hello.
= ()
? (printline "hello" 6 "@")
      hello@
= ()

Finally, the formal argument list may be terminated by &rest followed by another symbol. The list of all remaining actual arguments will be bound to that symbol.

Creates a new function which evaluates its arguments (DE) and stores this function into the value field of symbol symb .

A valid argument list args may be a single symbol, a list of symbols or something more complex like (a b (c d) . f) . A valid function body body is a list of Lush expressions which are evaluated whenever the function is called.

Whenever a DE function is called,

• The previous values of the argument names are saved,
  
• The actual arguments are evaluated and stored in the corresponding argument names,
  
• Each expression in the function body is evaluated and the last result is saved,
  
• The previous values of the argument names are restored,
  
• The saved result is returned.
  

Example:

? (de square (x) (* x x)) 
= square 
? (square 9) 
= 81 
? (de first-arg l
         (car l) )
= first-arg
? (first-arg 'a 'b)
= a
? (first-arg 'prems 'deuse 'troise 'quatrz)
= prems

Creates a new function which does not evaluates its arguments (DF) and stores this function into the value field of symbol symb .

A valid argument list args may be a single symbol, a list of symbols or something more complex like (a b (c d) . f) . A valid function body body is a list of Lush expressions which are evaluated whenever the function is called.

Whenever a DF function is called,

• The previous values of the argument names are saved,
  
• The actual arguments are not evaluated but directly stored in the corresponding argument names,
  
• Each expression in the function body is evaluated and the last result is saved,
  
• The previous values of the argument names are restored,
  
• The saved result is returned.
  

Example: Defining a control structure

? (df ifn(cond no . yes)
      (if (not (eval cond))
          (eval no)
        (apply progn yes)) )
= ifn
? (ifn (= 2 3) 1 2))
= 2

Such a definition causes problems if some subexpression depend on a the value of a symbol named like a function argument.

? (ifn (= 2 3) cond 2)
= (= 2 3)

The previous expression should indeed return the value of symbol cond in the current context rather than the value of symbol cond in the context of function ifn .

This problem is alleviated by using ``macro functions''.

Creates a macro-function (DM) and stores it into the value field of symbol symb . The body of a DM function actually computes the expression which will be evaluated in the calling context. This expression can be found with the function macro-expand .

A valid argument list args may be a single symbol, a list of symbols or something more complex like (a b (c d) . f) . A valid function body body is a list of Lush expressions which are evaluated whenever the function is called.

Whenever a DM function is called,

• The previous values of the argument names are saved,
  
• The elements of the entire calling expression, including the function name, are stored in the corresponding argument names,
  
• Each expression in the function body is evaluated and the last result (known as the macro expansion) is saved,
  
• The previous values of the argument names are restored,
  
• The saved macro-expansion is evaluated,
  
• The result is returned.
  

Example:

? (dm ifn(fname cond . rest) 
      (list 'if (list 'not cond) . rest) )
= ifn
? (ifn (= 2 3) "yes" "no")
= "yes"
? (setq cond "yes")
= "yes"
? (ifn (= 2 3) cond)
= "yes"

Example:

? (dm ifn(fname cond . rest) 
      (list 'if (list 'not cond) . rest) )
= ifn
? (macro-expand (ifn (= 2 3) "yes" "no"))
= (if (not (= 2 3)) "yes" "no")

Creates a DMD function and stores it into symbol symb . DMD functions display two differences with DM functions:

• Unlike the DM functions, their argument list does not include the function name.
  
• The result of the body evaluation replaces the calling form itself in the calling context.
  

A valid argument list args may be a single symbol, a list of symbols or something more complex like (a b (c d) . f) . A valid function body body is a list of Lush expressions which are evaluated whenever the function is called.

Whenever a DMD function is called,

• The previous values of the argument names are saved,
  
• The arguments are stored in the corresponding argument names,
  
• Each expression in the function body is evaluated and the last result (known as the macro expansion) is saved,
  
• The previous values of the argument names are restored,
  
• The macro expansion is physically installed in the calling form using function displace , replacing forever the call to the DMD function in the calling code,
  
• The saved macro-expansion is evaluated,
  
• The result is returned.
  

Example:

? (dmd ifn(cond . rest)
       (list 'if (list 'not cond) . rest) )
= ifn
? (de if-test(n)
       (ifn (= n 2) "yes" "no") )
= if-test
? (if-test 2)
= "no"
? (pretty if-test)
(de if-test(n)
   (if (not (= n 2)) "yes" "no") )
= (if-test)

There are three kinds of macro-characters:

• The first ones are single character macro-characters. When the Lush reader encounters one of them, it immediately calls the associated DMC function and returns its result.
  
• Caret macro-characters have a two character name, whose first character is a caret ^ . A caret DMC behaves exactly like a single characters DMC: When the reader encounters a caret followed by another character, it immediately calls the associated DMC function and returns its result.

  Caret macro-character may also be abbreviated by typing the corresponding control character (if this control character exists and is not intercepted by the operating system). If you are running WinLush, the fastest method consists in typing Ctrl+Shift+Letter . It is always possible however to type the caret followed by the character.
  

• Hash macro-characters are also two character macro-characters, whose first character is a hash sign # . If their body returns (), nothing is read. If it returns a one element list, this element is read. If it returns anything else, an error is signaled.

  Hash macro characters are useful for conditionally reading certain pieces of code.

  
  

Since the reader performs special actions whenever it encounters a macro-character, it is advisable to surround the name of symbol symb with vertical bars | .

Examples:

The macro character ' which expands into a call to function quote is defined as :

(dmc |'| (list 'quote (read)))

The macro character ^P which expands into a call to function pretty is defined as :

(dmc |^P| (list 'pretty (read)))

The following macro-character #! could be used to signal debug instructions that will be not read if variable ndebug is set.

(dmc |#!| (let ((inst (read))) (when (not ndebug) inst)))

Returns a function which evaluates its arguments (DE). This function operates like function de but does not store the function in a particuler symbol.

Example:

? ((lambda (x)
     (* x x) ) (+ 4 5))
= 81

Returns a function which does not evaluates its arguments (DF). This function operates like function df but does not store the function in a particuler symbol.

Example:

? ((flambda (x)
     (print x) ) (+ 4 5))
(+ 4 5)
= (+ 4 5)

Returns a macro-function (DM). This function operates like function dm but does not store the function in a particuler symbol.

Example:

? (funcdef caddr)
= (lambda (l)
    (car (cddr l)) )

Actually, pretty sends a pretty message to f . Each class defines how an instance of that class will be displayed. In particular, functions are displayed by printing an indented version of the definition of the functions f1 to fn.

Example

? (pretty caddr)
(de caddr (l)
  (car (cddr l)) )
= t

Example:

? ^Paddpath
(de addpath (dir)
  (setq dir (concat_fname dir))
  (let ((oldpath (path))
        (newpath (list dir)) )
    (while oldpath
      (when (<> dir (car oldpath))
        (setq newpath (nconc1 newpath (car oldpath))) )
      (setq oldpath (cdr oldpath)) )
    (apply path newpath) ) )
= ()

Function defun defines a global DE function named name . Whereas function de defines symbol name in the current scope, function defun defines symbol name in the global scope.

Function defun defines a global DM function named name . Whereas function dm defines symbol name in the current scope, function defun defines symbol name in the global scope. The argument list args only matches the arguments of the macro. It should not contain a symbol for matching the function name itself.