lambda abstraction

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)