Scheme and Haskell are two of my favorite programming languages, and I know both are implementations of the lambda calculus. I'd like to learn more about that, but I haven't been able to find good sources. Most of the time I do find it mentioned, it's mentioned in passing, for example in SICP or the Little Schemer.<p>Some things I'd like to know:<p>- How to construct lambda functions from Turing machines and vice versa<p>- How to think about the Y-combinator (this is now almost un-googleable)<p>- What variants of the lambda calculus have been constructed and what their properties are<p>- How lambda functions relate to functions in the mathematical sense. Are they the same? Can you call them on real numbers? Are they continuous? Etc<p>Extra points if you can recommend a full theoretical treatment. I'm interested in really digging in to this topic.
Those topics fall under the general heading of Mathematical Logic.<p>Wikipedia is usually a pretty good place to start for any such question:<p><a href="https://en.wikipedia.org/wiki/Lambda_calculus" rel="nofollow">https://en.wikipedia.org/wiki/Lambda_calculus</a><p>there are a lot of external links and references there.<p>I don't know if there's a lot of work still being done with the original untyped lambda calculus but typed lambda calculi (or analogous models), on which I believe Haskell is based, are another story.<p>You may also find this interesting:<p><a href="https://softwarefoundations.cis.upenn.edu/current/lf-current/index.html" rel="nofollow">https://softwarefoundations.cis.upenn.edu/current/lf-current...</a><p>It's an introduction to the coq proof assistant which is based (at least to the best of my understanding) on a kind of typed lambda calculus. In the first few chapters you will learn how to construct the natural numbers and formally (ie. in a machine verifiable way) prove theorems about them.
It’s not exactly what you’re asking for, but have you come across the book Programming Language Foundations in Agda?<p><a href="https://plfa.github.io/" rel="nofollow">https://plfa.github.io/</a><p>The second part discusses lamda calculus and formalizes a version in Agda. The first part should introduce enough Agda to understand the second part.<p>If you like Haskell and Scheme, I think you would enjoy Agda as well. It’s (to simplify a lot) lambda calculus extended with dependent types, which imho feels more consistent and cohesive to understand than Haskell and all the various ghc extensions (for me at least, it was easier to understand the advanced extensions after having dealt with a fully dependently typed language)<p>I also think Benjamin Pierce’s Types and Programming Languages ( <a href="https://www.cis.upenn.edu/~bcpierce/tapl/" rel="nofollow">https://www.cis.upenn.edu/~bcpierce/tapl/</a> ) could be useful to you. It introduces lambda calculus as the computational foundation, and then builds various type theories on top of that.
Type 'cmu lecture notes lambda calculus' into google. Or <a href="https://www.cs.cmu.edu/~rwh/pfpl/" rel="nofollow">https://www.cs.cmu.edu/~rwh/pfpl/</a> and his various lectures from OPLSS on YouTube too. The original Church thesis is on google scholar.<p>Look on arxiv <a href="https://arxiv.org/abs/1503.09060" rel="nofollow">https://arxiv.org/abs/1503.09060</a>
Y combinator is a fixed-point combinator. [1]<p>[1] <a href="https://en.wikipedia.org/wiki/Fixed-point_combinator" rel="nofollow">https://en.wikipedia.org/wiki/Fixed-point_combinator</a>