What do

*you*think?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

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

Displaying 1 - 27 of 27 reviews

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.

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/)

(Look for my full review to appear in MAA Reviews: http://mathdl.maa.org/mathDL/19/)

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.

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.

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.

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.

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.

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.

July 11, 2022

Excellent.

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)

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)

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.

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.

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.

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

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.

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.

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.

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.

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!

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!

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.

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.

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.

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.

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#

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.

Knowing Lambda calculus is fundamental for any software engineer.

October 10, 2017

This gave me a really good foundation for thinking functionally. Definitely recommend though it started off a bit slow.

April 27, 2018

Pretty good and easy introduction to lambda calculus.

September 7, 2019

Excellent read, no matter how much experience you have.

April 15, 2020

Awesome! Some books don’t require a detailed review. This one happens to be one of them.

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.

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.

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.

November 12, 2014

Starting from \ calculus author bring you to practical functional languages step by step

December 3, 2014

Best introduction to lambda calculus and functional programming

December 4, 2016

Much better on 2nd reading.

this book is helpful.

Displaying 1 - 27 of 27 reviews