Source : Free On-Line Dictionary of Computing

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)