lambda abstraction


Also found in: Dictionary.

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.
References in periodicals archive ?
To account for the meaning of diminutive verbs, in other words predicates and not entities, Jurafsky introduces lambda abstraction specification, and defines it as a mechanism that "takes one predicate in the form and replaces it with a variable...this process takes the original concept 'small (x)' and replaces it with 'lambda (y) smaller than the prototypical exemplar (x) on the scale (y)'" (Jurafsky 1996:555).
There are, however, a few major issues with the notion of lambda abstraction specification as a semantic mechanism.
The model proposed by Jurafsky (1996), however, does not provide an explanatory basis for the description of diminutive verbs in Croatian, namely because the central meaning 'small in size' cannot be applied to actions, but also because it uses lambda abstraction specification as the main mechanism for semantic shifts of diminutive verbs.
(b) the cost of evaluating the bodies of any lambda abstractions in exp (however many times they are called), but excluding