Jump to ratings and reviews
Rate this book

An Introduction to Functional Programming Through Lambda Calculus

Rate this book
Functional programming is rooted in lambda calculus, which constitutes the worlds smallest programming language. This well-respected text offers an accessible introduction to functional programming concepts and techniques for students of mathematics and computer science. The treatment is as nontechnical as possible, and it assumes no prior knowledge of mathematics or functional programming. Cogent examples illuminate the central ideas, and numerous exercises appear throughout the text, offering reinforcement of key concepts. All problems feature complete solutions.

336 pages, Paperback

First published February 1, 1989

Loading interface...
Loading interface...

About the author

Greg Michaelson

18 books5 followers

Ratings & Reviews

What do you think?
Rate this book

Friends & Following

Create a free account to discover what your friends think of this book!

Community Reviews

5 stars
90 (41%)
4 stars
79 (36%)
3 stars
42 (19%)
2 stars
5 (2%)
1 star
2 (<1%)
Displaying 1 - 27 of 27 reviews
Profile Image for Kiran Gangadharan.
34 reviews19 followers
May 4, 2016
A good introduction to Lambda Calculus. It establishes the theory and concepts in the first two chapters and then takes the reader on a journey to understand how a more powerful high level language could be constructed from a simple foundation. Finally, it concludes with a short introduction to ML and Lisp.
Profile Image for Tom Schulte.
2,936 reviews58 followers
March 24, 2012
Probably, imperative programming is the inevitable professional path of the budding programmer that picks up this book. However, the career programmer can benefit from seeing how “the other half lives”. As one who has trained and hired software engineers over the years, I have seen that a mindset of iteration and conditional statements can often lead to inefficient designs. Someone with only an introductory knowledge of LISP or Haskell or general declarative principles as outlined here often can come up with more compact and efficient designs in object-oriented programming (OOP). The excellent chapter here on recursion highlights a key concept I find taught better through functional programming. I recommend that those serious about OOP read this as a “mind hack” to spark innovation and a fresh assessment of the tools at hand.

(Look for my full review to appear in MAA Reviews: http://mathdl.maa.org/mathDL/19/)
9 reviews
October 25, 2020
Good book on how functional programming and lambda calculus relates. It specifically mentions that it will not cover language / compiler construction for functional languages, but I feel that the content is broad enough for the reader to connect the dots (with a little bit of additional research) on how to construct such language / compiler.

It covers introduction to lambda calculus too so it's quite a good book if you have no exposure to lambda calculus. It's guided to introduce functional programming though so it might be a bit disconnected with other books about lambda calculus.

The only reason I rate this as 4 instead of 5 is because the code listings in the Kindle edition are too small to read and not resizable. I wish it could be a bit larger, better if it can be resized.
Profile Image for Stijn.
71 reviews
December 31, 2015
Excellent introduction on how to build core programming language aspects from pure lambda calculus. The Lambda calculus techniques could me more detailed, but that's not the point of this book I guess.

The ending chapters are less interesting, as they provide little fundamental insights anymore. The chapters on ML and Lisp I only skimmed through briefly and could have been omitted for me.
Profile Image for Phil Eaton.
78 reviews97 followers
February 3, 2019
Excellent coverage of practical lambda calculus. However the model gets hand-wavier over time without looking at a concrete implementation. And the type checking is only ever introduced at runtime.

The last two chapters cover Standard ML and Common Lisp and don't really add much. There's little more to be wished for, perhaps in a book dedicated to Hindley-Milner unification.
Profile Image for Fotis Koutoulakis.
75 reviews8 followers
July 11, 2022

This is an amazing little book that helps bridge the gap of how you arrive at ML or Lisp from the pure untyped Lambda calculus.

You start with some historical reference, and then from basic primitives*, you build booleans and conditionals, natural numbers**, lists (which are effectively sequenced pairs), strings (as lists of characters, with characters corresponding to church numerals), trees, and then graft on a type system on top of the result.

You also do meet recursion through the applicative order Y-combinator.

The last couple of chapter are effectively intros to Standard ML and Common Lisp, with a bit of an explanation of how the preceding ideas are applied within those languages. I had never worked with Standard ML and Common Lisp, but I managed to breeze through them because of previous experience with OCaml and Scheme.

One thing worth of reference is that the book has copious exercises in each chapter, and the last 30-40 pages are solutions to these exercises, which is not something that you see often enough in books IMO.

*: (e.g. the pair constructor λa.λb.λc.((c a) b), the selector for the first element λa.λb.a, the selector for the second element λa.λb.b)
**: using Peano arithmetic encoded in lambda calculus (zero/succ zero, etc)
Profile Image for Jakub.
18 reviews18 followers
August 24, 2014
Interesting in the beginning, but the book got boring pretty quick. Maybe I just wasn't in the mood, but I didn't really enjoy reading it that much. I'll probably have to look at it again in a few months to see if I really missed something.
Profile Image for Eric.
627 reviews5 followers
November 20, 2018
The eBook was poorly formatted at times, and this had more hand holding than I would’ve liked, but was overall a good read. “Introduction” is accurate.
Profile Image for Alejandro.
7 reviews2 followers
January 12, 2017
This is a great book to understand the underpinings of functional languages such as Elm, Haskell or F#.

Working through the exercises is hard but worth it for the comprehension it provides.

11 reviews
August 4, 2021
The book explains how a functional programming language could be built upon the lambda calculus's simple principles. The book starts off with some lambda-calculus basics and gradually builds a language on top of that. In the ending chapters, SML and Lisp are compared to the foundations taught in this book.
I already knew some functional programming before starting this book and was mainly interested in how such programming languages construct their functionality (e.g. recursion).

- The starting chapters are very interesting. They explained exactly what I came for: How the lambda calculus as a turing-complete system can be used to build actual logic.
- Some chapters in the middle are also interesting, but at times I felt that some of it could be omitted or shortened. E.g. the stuff about the trees lost something after lists have already been described throughout.
- I found that the analysis of actual functional programming languages can only offer most of the value if you already know some of them. The SML part reminded me of F# (which is somewhat based on SML) and so I found it an interesting read. For the Lisp part, I think I'd need more experience/knowledge to actually appreciate the content.

All in one, I'm glad I picked this book because it sharpened my understanding of functional languages in a way that I hoped it would. In my opinion, some parts are a bit too lengthy / could be omitted so I can't give the book a full five-star rating.
65 reviews9 followers
November 9, 2020
Amazing book on understanding Lambda calculus, starting from the basics all the way upto programming in Lisp. The book is great, but expects that you are not easily frightened by greek alphabets!

I tried understanding the Y combinator multiple times (starting in 2016). But it wasn't until a few weeks ago when I read about it here, did I finally understand it properly. I think it's very important to understand the why of things before simply diving into it.

Anyway, great book especially the first few chapters. Please do the exercises, they really help you understand what's going on. I took my own sweet time to complete this and I hope you do the same.
Profile Image for Peter Aronson.
361 reviews11 followers
November 18, 2022
Four-and-three-quarters stars. A solid little book that starts with explaining Lambda Calculus clearly, then uses it to build up a functional programming language, step by step. Finally, it shows how the same functionality can be achieved in Standard ML and Common LISP.

What I like about this book is it doesn't skip steps, and doesn't leave things as an exercise for the reader -- this is very helpful when having problems with a concept, and can easily be skipped when you are not. Even all the exercises are fully worked out.

I picked up this book when I was having trouble grokking an explanation of Lambda Calculus in another book, and it did the trick for me!
Profile Image for Anthony O'Connor.
Author 4 books20 followers
March 8, 2021

It is very hard to write a great text on programming of any type and good instances are rare. This book isn’t one of them. You can plough your way through it and gain some value. But a few really good examples would have been useful. There is some interesting historical background and theoretical context but only a bit. The sketches of ML and Lisp in relation to the lambda calculus are without much value unless you already know ML and Lisp. So overall - pretty solid but nothing to get too excited about.
June 30, 2019
The book begins with an explanation of the basic principles of the Lambda calculus and moves swiftly to clear demonstrations of how familiar programming concepts can be expressed in it. Later on, it shows how complex abstractions expressed in Lambda Calculus can be translated into Common Lisp or SML.

This is the best and most practical book I've found for teaching Lambda Calculus to programmers in a way that will shape their coding habits.
13 reviews
January 11, 2023
I have been working in a functional programming language for the last four years. Over the years, there have been many frustrations with this language in trying to understand why it is the way it is. Part of these frustrations are rooted in certain proprietary aspects of the language, which sometimes make it difficult to know what is going on when something goes wrong. But a large part was also from not understanding why it is doing things the way it is doing them.

The approach taken by this book, to root functional programming in the lambda calculus was immensely helpful for understanding the general case for these kinds of languages. Probably the most helpful was to see how simple data structures can be "simulated" with functions. This helped to recast my thinking away from the standard languages (python etc.). I stopped thinking about iteration, and started thinking about recursion as well.

While the material was helpful, it was the presentation that kept me from giving this 4/5. It was a little opaque at times, and the examples were not always helpful.
1 review
September 23, 2019
The book has an excellent learning curve and takes you from very simple untyped lambda calculus and builds up at a nice speed towards defining something which, if you squint your eyes a little bit, could resemble something like ML or F#
Profile Image for Oleg Dats.
39 reviews10 followers
February 19, 2022
This amazing book will guide you on how to create a functional programming language from scratch. Extending this language with types. Great explanation of data structures such as lists, strings, and trees.
Knowing Lambda calculus is fundamental for any software engineer.
Profile Image for Jamal Burgess.
6 reviews1 follower
October 10, 2017
This gave me a really good foundation for thinking functionally. Definitely recommend though it started off a bit slow.
Profile Image for Abhijit Gupta.
14 reviews
April 15, 2020
Awesome! Some books don’t require a detailed review. This one happens to be one of them.
Profile Image for Ivan Andrus.
29 reviews
March 19, 2016
I had never studied the lambda calculus, but I knew enough lisp to be bored after the first two chapter or so. I did learn some stuff though, and I'm glad I read it because now I know enough to talk intelligently. I found it to be pretty easy reading, though the typography was poor and there were several typos.
2 reviews1 follower
February 14, 2018
After 6 years on a computer related major and 2 years of professional experience in programming, I didn't think I'd find so many new concepts on a programming book. I couldn't be more wrong.

This book provided me a good introduction to the world of functional programming. It has changed the way that I code (even in imperative languages) just by reading it.
Profile Image for Nicola.
7 reviews24 followers
November 12, 2014
Starting from \ calculus author bring you to practical functional languages step by step
Displaying 1 - 27 of 27 reviews

Can't find what you're looking for?

Get help and learn more about the design.