|
|
| Line 1: |
Line 1: |
| The '''simply typed lambda calculus''' (<math>\lambda^\to</math>), a form
| | Consuelo is what people call her and she completely loves this title. For many years he's been operating as an information officer and his salary has been really satisfying. I am truly fond of [http://browse.deviantart.com/?qh=§ion=&global=1&q=bottle+tops bottle tops] gathering and I'll be beginning some thing else alongside with it. Hawaii is exactly where he's always been living and his parents reside nearby. She's not great at style but you might want to verify her website: http://bme.med.[http://www.Dailymail.co.uk/home/search.html?sel=site&searchPhrase=tsinghua tsinghua].edu.cn/wiki/index.php?title=Marriage_And_Nya_Internet_Casinon_Have_More_In_Common_Than_You_Think<br><br> |
| of [[type theory]], is a [[typed lambda calculus|typed interpretation]] of the [[lambda calculus]] with only one [[type constructor]]: <math>\to</math> that builds [[function type]]s. It is the canonical and simplest example of a typed lambda calculus. The simply typed lambda calculus was originally introduced by [[Alonzo Church]] in 1940 as an attempt to avoid paradoxical uses of the [[untyped lambda calculus]], and it exhibits many desirable and interesting properties.
| |
|
| |
|
| The term ''simple type'' is also used to refer to extensions of the simply typed lambda calculus such as [[cartesian product|products]], [[coproduct]]s or [[natural number]]s ([[Dialectica interpretation|System T]]) or even full [[recursion]] (like [[Programming language for Computable Functions|PCF]]). In contrast, systems which introduce polymorphic types (like [[System F]]) or [[dependent type]]s (like the [[LF (logical framework)|Logical Framework]]) are not considered ''simply typed''. The former are still considered ''simple'' because the [[Church encoding]]s of such structures can be done using only <math>\to</math> and suitable type variables, while polymorphism and dependency cannot.
| | my blog :: [http://bme.med.tsinghua.edu.cn/wiki/index.php?title=Marriage_And_Nya_Internet_Casinon_Have_More_In_Common_Than_You_Think nya internet casino på nätet] |
| | |
| == Syntax ==
| |
| | |
| In this article, we use <math>\sigma</math> and <math>\tau</math> to range over types. Informally, the ''function type'' <math>\sigma \to \tau</math> refers to the set of functions that, given an input of type <math>\sigma</math>, produce an output of type <math>\tau</math>.
| |
| By convention, <math>\to</math> associates to the right: we read <math>\sigma\to\tau\to\rho</math> as <math>\sigma\to(\tau\to\rho)</math>.
| |
| | |
| To define the types, we begin by fixing a set of ''base types'', <math>B</math>. These are sometimes called ''atomic types'' or ''type constants''. With this fixed, the syntax of types is:
| |
| | |
| :<math>\tau ::= \tau \to \tau \mid T \quad \mathrm{where} \quad T \in B</math>.
| |
| | |
| For example, if <math>B = \{a, b\}</math>, then <math>a</math>, <math>b</math>, <math>a \to a</math>, <math>a \to b</math>, and <math>a \to b \to a</math> are all valid types (among others).
| |
| | |
| We also fix a set of ''term constants'' for the base types. For example, we might assume a base type <tt>nat</tt>, and the term constants could be the natural numbers. In the original presentation, Church used only two base types: <math>o</math> for "the type of propositions" and <math>\iota</math> for "the type of individuals". The type <math>o</math> has no term constants, whereas <math>\iota</math> has one term constant. Frequently the calculus with only one base type, usually <math>o</math>, is considered.
| |
| | |
| The syntax of the simply typed lambda calculus is essentially that of the lambda calculus itself. We write <math>x\!:\!\tau</math> to denote that the variable <math>x</math> is of type <math>\tau</math>. The term syntax is then:
| |
| | |
| :<math>e ::= x \mid \lambda x\!:\!\tau.e \mid e \, e \mid c</math>
| |
| | |
| where <math>c</math> is a term constant.
| |
| | |
| That is, ''variable reference'', ''abstractions'', ''application'', and ''constant''. A variable reference <math>x</math> is ''bound'' if it is inside of an abstraction binding <math>x</math>. A term is ''closed'' if there are no unbound variables.
| |
| | |
| Compare this to the syntax of untyped lambda calculus:
| |
| | |
| :<math>e ::= x \mid \lambda x.e \mid e \, e</math>
| |
| | |
| We see that in typed lambda calculus every function (''abstraction'') must specify the type of its argument.
| |
| | |
| == Typing rules ==
| |
| | |
| To define the set of well typed lambda terms of a given type, we will define a typing relation between terms and types. First, we introduce ''typing contexts'' or ''[[typing environment]]s'' <math>\Gamma,\Delta,\dots</math>, which are sets of typing assumptions. A ''typing assumption'' has the form <math>x\!:\!\sigma</math>, meaning <math>x</math> has type <math>\sigma</math>.
| |
| | |
| The ''typing relation'' <math>\Gamma\vdash e\!:\!\sigma</math> indicates that <math>e</math> is a term of type <math>\sigma</math> in context <math>\Gamma</math>. It is therefore said that "<math>e</math> is ''well-typed'' (at <math>\sigma</math>)". Instances of the typing relation are called ''typing judgements''. The validity of a typing judgement is shown by providing a ''typing derivation'', constructed using [[type rules|typing rules]] (wherein the premises above the line allow us to derive the conclusion below the line). Simply-typed lambda calculus uses these rules:
| |
| | |
| {| align="center" cellpadding="9"
| |
| | align="center" | <math>{x\!:\!\sigma \in \Gamma}\over{\Gamma \vdash x\!:\!\sigma }</math> (1) <math>{c \textrm{~is~a~constant~of~type~} T}\over{\Gamma\vdash c\!:\!T}</math> (2)
| |
| |-
| |
| | align="center" | <math>{\Gamma,x\!:\!\sigma\vdash e\!:\!\tau}\over{\Gamma\vdash (\lambda x\!:\!\sigma.~e)\!:\!(\sigma \to \tau)}</math> (3) <math>{\Gamma\vdash e_1\!:\!\sigma\to\tau\quad\Gamma\vdash e_2\!:\!\sigma}\over{\Gamma\vdash e_1~e_2\!:\!\tau}</math> (4)
| |
| |}
| |
| | |
| In other words,
| |
| # If <math>x</math> has type <math>\sigma</math> in the context, we know that <math>x</math> has type <math>\sigma</math>.
| |
| # Term constants have the appropriate base types.
| |
| # If, in a certain context with <math>x</math> having type <math>\sigma</math>, <math>e</math> has type <math>\tau</math>, then, in the same context without <math>x</math>, <math>\lambda x\!:\!\sigma.~e</math> has type <math>\sigma \to \tau</math>.
| |
| # If, in a certain context, <math>e_1</math> has type <math>\sigma \to \tau</math>, and <math>e_2</math> has type <math>\sigma</math>, then <math>e_1~e_2</math> has type <math>\tau</math>.
| |
| | |
| Examples of closed terms, ''i.e.'' terms typable in the empty context, are:
| |
| *For every type <math>\tau</math>, a term <math>\lambda x\!:\!\tau.x\!:\!\tau\to\tau</math> (identity function/I-combinator),
| |
| *For types <math>\sigma,\tau</math>, a term <math>\lambda x\!:\!\sigma.\lambda y\!:\!\tau.x\!:\!\sigma \to \tau \to \sigma</math> (the K-combinator), and
| |
| *For types <math>\tau,\tau',\tau''</math>, a term <math>\lambda x\!:\!\tau\to\tau'\to\tau''.\lambda y\!:\!\tau\to\tau'.\lambda z\!:\!\tau.x z (y z) : (\tau\to\tau'\to\tau'')\to(\tau\to\tau')\to\tau\to\tau''</math> (the S-combinator).
| |
| These are the typed lambda calculus representations of the basic combinators of [[combinatory logic]].
| |
| | |
| Each type <math>\tau</math> is assigned an order, a number <math>o(\tau)</math>. For base types, <math>o(T)=0</math>; for function types, <math>o(\sigma\to\tau)=\mbox{max}(o(\sigma)+1,o(\tau))</math>. That is, the order of a type measures the depth of the most left-nested arrow. Hence:
| |
| | |
| : <math>o(\iota \to \iota \to \iota) = 1</math>
| |
| | |
| : <math>o((\iota \to \iota) \to \iota) = 2</math>
| |
| | |
| == Semantics ==
| |
| | |
| === Intrinsic vs. extrinsic interpretations ===
| |
| | |
| Broadly speaking, there are two different ways of assigning meaning to the simply typed lambda calculus, as to typed languages more generally, sometimes called ''intrinsic'' vs. ''extrinsic'', or ''[[Alonzo Church|Church]]-style'' vs. ''[[Haskell Curry|Curry]]-style''.<ref>{{cite book
| |
| | first = John | last = Reynolds | author-link=John_C._Reynolds
| |
| | publisher = Cambridge University Press
| |
| | location = Cambridge, England
| |
| | title=Theories of Programming Languages
| |
| | year=1998
| |
| }}</ref>
| |
| An intrinsic/Church-style semantics only assigns meaning to well-typed terms, or more precisely, assigns meaning directly to typing derivations. This has the effect that terms differing only by type annotations can nonetheless be assigned different meanings. For example, the identity term <math>\lambda x\!:\!\texttt{int}.~x</math> on integers and the identity term <math>\lambda x\!:\!\texttt{bool}.~x</math> on booleans may mean different things. (The classic intended interpretations
| |
| are the identity function on integers and the identity function on boolean values.)
| |
| In contrast, an extrinsic/Curry-style semantics assigns meaning to terms regardless of typing, as they would be interpreted in an untyped language. In this view, <math>\lambda x\!:\!\texttt{int}.~x</math> and <math>\lambda x\!:\!\texttt{bool}.~x</math> mean the same thing (''i.e.'', the same thing as <math>\lambda x.~x</math>).
| |
| | |
| The distinction between intrinsic and extrinsic semantics is sometimes associated with the presence or absence of annotations on lambda abstractions, but strictly speaking this usage is imprecise. It is possible to define a Curry-style semantics on annotated terms simply by ignoring the types (''i.e.'', through [[type erasure]]), as it is possible to give a Church-style semantics on unannotated terms when the types can be deduced from context (''i.e.'', through [[type inference]]). The essential difference between intrinsic and extrinsic approaches is just whether the typing rules are viewed as defining the language, or as a formalism for verifying properties of a more primitive underlying language. Most of the different semantic interpretations discussed below can be seen through either Church or Curry goggles.
| |
| | |
| === Equational theory ===
| |
| | |
| The simply typed lambda calculus has the same [[equational theory]] of βη-equivalence as [[Untyped_lambda_calculus#Reduction|untyped lambda calculus]], but subject to type restrictions. The equation for [[beta reduction]]
| |
| :<math>(\lambda x\!:\!\sigma.~t)\,u =_{\beta} t[x:=u]</math>
| |
| holds in context <math>\Gamma</math> whenever <math>\Gamma,x\!:\!\sigma \vdash t\!:\!\tau</math> and <math>\Gamma\vdash u\!:\!\sigma</math>, while the equation for [[eta reduction]]
| |
| :<math>\lambda x\!:\!\sigma.~t\,x =_\eta t</math>
| |
| holds whenever <math>\Gamma\vdash t\!:\sigma \to \tau</math> and <math>x</math> does not appear free in <math>t</math>.
| |
| | |
| === Operational semantics ===
| |
| | |
| Likewise, the [[operational semantics]] of simply typed lambda calculus can be fixed as for the untyped lambda calculus, using [[call by name]], [[call by value]], or other [[evaluation strategy|evaluation strategies]]. As for any typed language, [[type safety]] is a fundamental property of all of these evaluation strategies. Additionally, the [[strong normalization]] property [[Simply typed lambda calculus#Important results|described below]] implies that any evaluation strategy will terminate on all simply typed terms.
| |
| | |
| === Categorical semantics ===
| |
| The simply typed lambda calculus (with <math>\beta\eta</math>-equivalence) is the [[internal language]] of [[Cartesian closed categories]] (CCCs), as was first observed by [[Joachim Lambek|Lambek]]. Given any specific CCC, the basic types of the corresponding lambda calculus are just the [[object (category theory)|objects]], and the terms are the [[morphism]]s. Conversely, every simply typed lambda calculus gives a CCC whose objects are the types, and morphisms are equivalence classes of terms.
| |
| | |
| To make the correspondence clear, a [[type constructor]] for the [[Cartesian product]] is typically added to the above. To preserve the [[product (category theory)|categoricity of the Cartesian product]], one adds [[type rule]]s for ''pairing'', ''projection'', and a ''unit term''. Given two terms <math>s\!:\!\sigma</math> and <math>t\!:\!\tau</math>, the term <math>(s,t)</math> has type <math>\sigma\times\tau</math>. Likewise, if one has a term <math>u\!:\!\tau_1\times\tau_2</math>, then there are terms <math>\pi_1(u)\!:\!\tau_1</math> and <math>\pi_2(u)\!:\!\tau_2</math> where the <math>\pi_i</math> correspond to the projections of the Cartesian product. The ''unit term'', of type 1, is written as <math>()</math> and vocalized as 'nil', is the [[final object]]. The equational theory is extended likewise, so that one has
| |
| :<math>\pi_1(s\!:\!\sigma,t\!:\!\tau) = s\!:\!\sigma</math>
| |
| :<math>\pi_2(s\!:\!\sigma,t\!:\!\tau) = t\!:\!\tau</math>
| |
| :<math>(\pi_1(u\!:\!\sigma\times\tau) , \pi_2(u\!:\!\sigma\times\tau)) =u\!:\!\sigma\times\tau</math>
| |
| :<math>t\!:\!1 = ()</math>
| |
| This last is read as "''if t has type 1, then it reduces to nil''".
| |
| | |
| The above can then be turned into a category by taking the types as the [[object (category theory)|objects]]. The [[morphism]]s <math>\sigma\to\tau</math> are [[equivalence class]]es of pairs <math>(x\!:\!\sigma, t\!:\!\tau)</math> where ''x'' is a variable (of type <math>\sigma</math>)and ''t'' is a term (of type <math>\tau</math>), having no free variables in it, except for (optionally) ''x''. Closure is obtained from [[currying]] and [[apply|application]], as usual.
| |
| | |
| More precisely, there exist [[functor]]s between the category of Cartesian closed categories, and the category of simply-typed lambda theories.
| |
| | |
| It is common to extend this case to [[closed monoidal category|closed symmetric monoidal categories]] by using a [[linear type system]]. The reason for this is that the CCC is a special case of the closed symmetric monoidal category, which is typically taken to be the [[category of sets]]. This is fine for laying the foundations of [[set theory]], but the more general [[topos]] seems to provide a superior foundation.
| |
| | |
| === Proof-theoretic semantics ===
| |
| | |
| The simply typed lambda calculus is closely related to the implicational fragment of propositional [[intuitionistic logic]], i.e., [[minimal logic]], via the [[Curry–Howard isomorphism]]: terms correspond precisely to proofs in [[natural deduction]], and [[Type inhabitation|inhabited types]] are exactly the [[tautology (logic)|tautologies]] of minimal logic.
| |
| | |
| == Alternative syntaxes ==
| |
| | |
| The presentation given above is not the only way of defining the syntax of the simply typed lambda calculus. One alternative is to remove type annotations entirely (so that the syntax is identical to the untyped lambda calculus), while ensuring that terms are well-typed via [[Type inference|Hindley-Milner type inference]]. The inference algorithm is terminating, sound, and complete: whenever a term is typable, the algorithm computes its type. More precisely, it computes the term's [[principal type]], since often an unannotated term (such as <math>\lambda x.~x</math>) may have more than one type (<math>\texttt{int} \to \texttt{int}</math>, <math>\texttt{bool} \to \texttt{bool}</math>, etc., which are all instances of the principal type <math>\alpha \to \alpha</math>).
| |
| | |
| Another alternative presentation of simply typed lambda calculus is based on '''bidirectional type checking''', which requires more type annotations than Hindley-Milner inference but is easier to describe. The [[type system]] is divided into two judgments, representing both ''checking'' and ''synthesis'', written <math>\Gamma \vdash e \Leftarrow \tau</math> and <math>\Gamma \vdash e \Rightarrow \tau</math> respectively. Operationally, the three components <math>\Gamma</math>, <math>e</math>, and <math>\tau</math> are all ''inputs'' to the checking judgment <math>\Gamma \vdash e \Leftarrow \tau</math>, whereas the synthesis judgment <math>\Gamma \vdash e \Rightarrow \tau</math> only takes <math>\Gamma</math> and <math>e</math> as inputs, producing the type <math>\tau</math> as output. These judgments are derived via the following rules:
| |
| {| align="center" cellpadding="9"
| |
| | align="center" | <math>{x\!:\!\sigma \in \Gamma}\over{\Gamma \vdash x \Rightarrow \sigma }</math> [1] <math>{c \textrm{~is~a~constant~of~type~} T}\over{\Gamma\vdash c \Rightarrow T}</math> [2]
| |
| |-
| |
| | align="center" | <math>{\Gamma,x\!:\!\sigma\vdash e\Leftarrow \tau}\over{\Gamma\vdash \lambda x.~e \Leftarrow \sigma \to \tau}</math> [3] <math>{\Gamma\vdash e_1\Rightarrow \sigma\to\tau\quad\Gamma\vdash e_2\Leftarrow\sigma}\over{\Gamma\vdash e_1~e_2 \Rightarrow \tau}</math> [4]
| |
| |-
| |
| | align="center" | <math>{\Gamma\vdash e \Rightarrow \tau}\over{\Gamma\vdash e\Leftarrow \tau}</math> [5] <math>{\Gamma\vdash e \Leftarrow \tau}\over{\Gamma\vdash (e\!:\!\tau)\Rightarrow \tau}</math> [6]
| |
| |}
| |
| Observe that rules [1]–[4] are nearly identical to rules (1)–(4) above, except for the careful choice of checking or synthesis judgments. These choices can be explained like so:
| |
| # If <math>x\!:\!\sigma</math> is in the context, we can synthesize type <math>\sigma</math> for <math>x</math>.
| |
| # The types of term constants are fixed and can be synthesized.
| |
| # To check that <math>\lambda x.~e</math> has type <math>\sigma \to \tau</math> in some context, we extend the context with <math>x\!:\!\sigma</math> and check that <math>e</math> has type <math>\tau</math>.
| |
| # If <math>e_1</math> synthesizes type <math>\sigma \to \tau</math> (in some context), and <math>e_2</math> checks against type <math>\sigma</math> (in the same context), then <math>e_1~e_2</math> synthesizes type <math>\tau</math>.
| |
| Observe that the rules for synthesis are read top-to-bottom, whereas the rules for checking are read bottom-to-top. Note in particular that we do '''not''' need any annotation on the lambda abstraction in rule [3], because the type of the bound variable can be deduced from the type at which we check the function. Finally, we explain rules [5] and [6] as follows:
| |
| <ol start="5">
| |
| <li>To check that <math>e</math> has type <math>\tau</math>, it suffices to synthesize type <math>\tau</math>.</li>
| |
| <li>If <math>e</math> checks against type <math>\tau</math>, then the explicitly annotated term <math>(e\!:\!\tau)</math> synthesizes <math>\tau</math>.
| |
| </li>
| |
| </ol>
| |
| Because of these last two rules coercing between synthesis and checking, it is easy to see that any well-typed but unannotated term can be checked in the bidirectional system, so long as we insert "enough" type annotations. And in fact, annotations are needed only at β-redexes.
| |
| | |
| == General observations ==
| |
| | |
| Given the standard semantics, the simply typed lambda calculus is [[Normalization property (lambda-calculus)|strongly normalizing]]: that is, well-typed terms always reduce to a value, i.e., a <math>\lambda</math> abstraction. This is because recursion is not allowed by the typing rules: it is impossible to find types for [[fixed-point combinator]]s and the looping term <math>\Omega = (\lambda x.~x~x) (\lambda x.~x~x)</math>. Recursion can be added to the language by either having a special operator <math>\texttt{fix}_\alpha</math>of type <math>(\alpha \to \alpha) \to \alpha</math> or adding general [[recursive type]]s, though both eliminate strong normalization.
| |
| | |
| Since it is strongly normalizing, it is [[decidability (logic)|decidable]] whether or not a simply typed lambda calculus program halts: it does! We can therefore conclude that the language is ''not'' [[Turing complete]].
| |
| | |
| == Important results ==
| |
| | |
| * Tait showed in 1967 that <math>\beta</math>-reduction is [[Normalization property (lambda-calculus)|strongly normalizing]]. As a corollary <math>\beta\eta</math>-equivalence is [[decidability (logic)|decidable]]. Statman showed in 1977 that the normalisation problem is not [[elementary recursive]]. A purely semantic normalisation proof (see [[normalisation by evaluation]]) was given by Berger and Schwichtenberg in 1991.
| |
| * The [[unification (computing)|unification]] problem for <math>\beta\eta</math>-equivalence is undecidable. Huet showed in 1973 that 3rd order unification is undecidable and this was improved upon by Baxter in 1978 then by Goldfarb in 1981 by showing that 2nd order unification is already undecidable. Whether higher order matching (unification where only one term contains existential variables) is decidable is still open. [2006: Colin Stirling, Edinburgh, has published a proof-sketch in which he claims that the problem is decidable; however, the complete version of the proof is still unpublished]
| |
| * We can encode [[natural number]]s by terms of the type <math>(o\to o)\to(o \to o)</math> ([[Church numeral]]s). Schwichtenberg showed in 1976 that in <math>\lambda^\to</math> exactly the extended [[polynomial]]s are representable as functions over Church numerals; these are roughly the polynomials closed up under a conditional operator.
| |
| * A ''full model'' of <math>\lambda^\to</math> is given by interpreting base types as [[Set (mathematics)|sets]] and function types by the set-theoretic [[function space]]. Friedman showed in 1975 that this interpretation is [[Completeness|complete]] for <math>\beta\eta</math>-equivalence, if the base types are interpreted by infinite sets. Statman showed in 1983 that <math>\beta\eta</math>-equivalence is the maximal equivalence which is ''typically ambiguous'', i.e. closed under type substitutions (''Statman's Typical Ambiguity Theorem''). A corollary of this is that the ''finite model property'' holds, i.e. finite sets are sufficient to distinguish terms which are not identified by <math>\beta\eta</math>-equivalence.
| |
| * Plotkin introduced logical relations in 1973 to characterize the elements of a model which are definable by lambda terms. In 1993 Jung and Tiuryn showed that a general form of logical relation (Kripke logical relations with varying arity) exactly characterizes lambda definability. Plotkin and Statman conjectured that it is decidable whether a given element of a model generated from finite sets is definable by a lambda term (''Plotkin-Statman-conjecture''). The conjecture was shown to be false by Loader in 1993.
| |
| | |
| == Notes ==
| |
| | |
| {{reflist}}
| |
| | |
| == See also ==
| |
| * Article [http://plato.stanford.edu/entries/type-theory-church/ Church's Type Theory] in the Stanford Encyclopedia of Philosophy.
| |
| * [[Type inference#Hindley–Milner type inference algorithm|Hindley-Milner type inference algorithm]]
| |
| | |
| == References ==
| |
| | |
| * A. Church: A Formulation of the Simple Theory of Types, JSL 5, 1940
| |
| * [[William W. Tait|W.W.Tait]]: Intensional Interpretations of Functionals of Finite Type I, JSL 32(2), 1967
| |
| * G.D. Plotkin: Lambda-definability and logical relations, Technical report, 1973
| |
| * G.P. Huet: The Undecidability of Unification in Third Order Logic Information and Control 22(3): 257-267 (1973)
| |
| * H. Friedman: Equality between functionals. LogicColl. '73, pages 22-37, LNM 453, 1975.
| |
| * H. Schwichtenberg: Functions definable in the simply-typed lambda calculus, Arch. Math Logik 17 (1976) 113-114.
| |
| * R. Statman: The Typed lambda-Calculus Is not Elementary Recursive FOCS 1977: 90-94
| |
| * W. D. Goldfarb: The undecidability of the 2nd order unification problem, TCS (1981), no. 13, 225- 230.
| |
| * R. Statman. <math>\lambda</math>-definable functionals and <math>\beta\eta</math> conversion. Arch. Math. Logik, 23:21–26, 1983.
| |
| * J. Lambek: Cartesian Closed Categories and Typed Lambda-calculi. Combinators and Functional Programming Languages 1985: 136-175
| |
| * U. Berger, H. Schwichtenberg: An Inverse of the Evaluation Functional for Typed lambda-calculus LICS 1991: 203-211
| |
| * Jung, A.,Tiuryn, J.:A New Characterization of Lambda Definability, TLCA 1993
| |
| * R. Loader: [http://homepages.ihug.co.nz/~suckfish/papers/Church.pdf The Undecidability of λ-definability], appeared in the Church Festschrift, 2001
| |
| * H. Barendregt, [ftp://ftp.cs.ru.nl/pub/CompMath.Found/HBK.ps Lambda Calculi with Types], Handbook of Logic in Computer Science, Volume II, Oxford University Press, 1993. ISBN 0-19-853761-1.
| |
| * L. Baxter: The undecidability of the third order dyadic unification problem, Information and Control 38(2), 170-178 (1978)
| |
| | |
| == External links ==
| |
| | |
| * {{cite web |last=Loader |first=Ralph |title=Notes on Simply Typed Lambda Calculus |date=February 1998 |url=http://www.lfcs.inf.ed.ac.uk/reports/98/ECS-LFCS-98-381/}}
| |
| | |
| [[Category:Lambda calculus]]
| |
| [[Category:Theory of computation]]
| |