#Algol lambda calculus how to

A much cleaner picture emerges when one understands that the call-return jumping discipline engendered by the function-calls of lambda-calculus is a special case of the general jumping that continuations can do. Finally, I think it's conceptually deeply confused to 'add' continuations to lambda-calculus. If you write the very same semantics in pi-calculus, it's trivial and extremely transparent (see 'Control in the Pi-Calculus' by Honda et al). the reduction semantics of the lambda-mu-calculus is usually only handwaved). Moreover, adding jumps (which is what continuations are) to lambda-calculus results in an extremely complicated and hard to understand system (e.g.

#Algol lambda calculus how to

I don't think we know how to do all of classical logic yet. call-by-value, as in the Stewart-Ong lambda-mu-calculus). While continuations can express classical logic in some way, it's generally only possible to express certain cut elimination strategies (e.g. Regarding (2), I'm afraid I also disagree.

That's why process calculi were invented. Īs to (1) I disagree, it's difficult to express general concurrent/parallel computation in lambda-calculus. I'm not super familiar with semantics in linguistics, but I've always thought it was very cool that they also use some of the same tools as programming language theory! Wikipedia has more about this. It's a way to build up the meaning of, well, meaning. In particular, linguists use typed λ-calculi to construct formal semantics for sentences. One surprising use for the λ-calculus outside of CS is in linguistics. Seeing proofs as programs really helped me come to terms (heh) with mathematical logic. I really like this notion because it gives me a concrete, first-class object to represent a proof. In some sense, it is a sort of 'proof essence': the basic building block of what a proof is. Of course, as the accepted answer points out, the λ-calculus is also very useful for logic. Haskell uses a variant of System F which it actually calls 'Core' to underscore how core this concept is :). Most of Haskell is like this: while the surface language has become rather complex, the majority of the features boil away rather transparently into typed lambda terms. If you can express a feature just in terms of the λ-calculus, you can implement it almost for free. It's also great as the core of a programming language. Fast iteration for programming language designers. It allows somebody designing a language feature or part of a type system to experiment with that feature in isolation. The λ-calculus is basically the MVP of programming languages.