The DICT Development Group

  lambda abstraction
       
          A term in lambda-calculus denoting a function.  A lambda
          abstraction begins with a lower-case lambda (represented as
          "\" in this document), followed by a variable name (the "bound
          variable"), a full stop and a lambda expression (the body).
          The body is taken to extend as far to the right as possible
          so, for example an expression,
       
          	\ x . \ y . x+y
       
          is read as
       
          	\ x . (\ y . x+y).
       
          A nested abstraction such as this is often abbreviated to:
       
          	\ x y . x + y
       
          The lambda expression (\ v . E) denotes a function which takes
          an argument and returns the term E with all free occurrences
          of v replaced by the actual argument.  Application is
          represented by juxtaposition so
       
          	(\ x . x) 42
       
          represents the identity function applied to the constant 42.
       
          A lambda abstraction in Lisp is written as the symbol
          lambda, a list of zero or more variable names and a list of
          zero or more terms, e.g.
       
          	(lambda (x y) (plus x y))
       
          Lambda expressions in Haskell are written as a backslash,
          "\", one or more patterns (e.g. variable names), "->" and an
          expression, e.g. \ x -> x.
       
          (1995-01-24)