Lambda? You Keep Using that Letter

Lambda?You Keep Using that Letter
@KevlinHenney

AWS
Half-Life
wavelength
decay constant
calculus

In 1911 Russell & Whitehead published Principia
Mathematica, with the goal of providing a solid
foundation for all of mathematics.
In 1911 Russell & Whitehead published Principia
Mathematica, with the goal of providing a solid
foundation for all of mathematics. In 1931 Gödel’s
Incompleteness Theorem shattered the dream,
showing that for any consistent axiomatic system
there will always be theorems that cannot be
proven within the system.
Adrian Colyer
https://blog.acolyer.org/2020/02/03/measure-mismeasure-fairness/

One premise of many models of fairness in
machine learning is that you can measure (‘prove’)
fairness of a machine learning model from within
the system – i.e. from properties of the model itself
and perhaps the data it is trained on.
To show that a machine learning model is fair, you
need information from outside of the system.
Adrian Colyer
https://blog.acolyer.org/2020/02/03/measure-mismeasure-fairness/

We demand rigidly
defined areas of doubt
and uncertainty!

Despite the fancy name, a
lambda is just a function...
peculiarly... without a name.
https://rubymonk.com/learning/books/1-ruby-primer/chapters/34-lambdas-and-blocks-in-ruby/lessons/77-lambdas-in-ruby

There are only two hard things
in Computer Science: cache
invalidation and naming things.
Phil Karlton

We select a particular list of
symbols, consisting of the
symbols { , }, ( , ), λ, [ , ],
and an enumerably infinite
set of symbols a, b, c, · · · to
be called variables.

And we define the word
formula to mean any finite
sequence of symbols out of
this list.

f → λ x· y x
variable
abstraction
application

f → λ x· y x
abbreviation free variable
bound variable

square → λ 😠· 😠 × 😠

☐ → λ 😠· 😠 × 😠

AN UNSOLVEABLE
PROBLEM OF
ELEMENTARY
NUMBER THEORY

0 → λ f· λ x· x
1 → λ f· λ x· f(x)
2 → λ f· λ x· f(f(x))
3 → λ f· λ x· f(f(f(x)))
4 → λ f· λ x· f(f(f(f(x))))
5 → λ f· λ x· f(f(f(f(f(x)))))

0 → λ f x· x
1 → λ f x· f(x)
2 → λ f x· f(f(x))
3 → λ f x· f(f(f(x)))
4 → λ f x· f(f(f(f(x))))
5 → λ f x· f(f(f(f(f(x)))))

0 → λ f x· x
1 → λ f x· f x
2 → λ f x· f2 x
3 → λ f x· f3 x
4 → λ f x· f4 x
5 → λ f x· f5 x
6

0 → λ f x· f0 x
1 → λ f x· f1 x
2 → λ f x· f2 x
3 → λ f x· f3 x
4 → λ f x· f4 x
5 → λ f x· f5 x
6

You may have heard of lambdas
before. Perhaps you’ve used
them in other languages.

function square(x) {
return x * x
}

square = function(x) {
return x * x
}

square = (x) => {
return x * x
}

square = x => {
return x * x
}

They’re anonymous, little
functional spies sneaking
into the rest of your code.

Excel is the world’s
most popular
functional language
Simon Peyton-Jones

http://xkcd.com/224/
We lost the documentation on quantum mechanics.
You'll have to decode the regexes yourself.

proc (real) real square;
square := (real x) real: x * x;
real result := square (7);

Lambdas in Ruby are
also objects, just like
everything else!

The venerable master Qc Na was walking with his
student, Anton. Hoping to prompt the master into
a discussion, Anton said “Master, I have heard
that objects are a very good thing — is this true?”
Qc Na looked pityingly at his student and replied,
“Foolish pupil — objects are merely a poor man’s
closures.”
http://people.csail.mit.edu/gregs/ll1-discuss-archive-html/msg03277.html

The concept of closures was developed in the
1960s for the mechanical evaluation of
expressions in the λ-calculus.
Peter J. Landin defined the term closure in
1964 as having an environment part and a
control part.
https://en.wikipedia.org/wiki/Closure_(computer_programming)

Joel Moses credits Landin with introducing
the term closure to refer to a lambda
expression whose open bindings (free
variables) have been closed by (or bound in)
the lexical environment, resulting in a closed
expression, or closure.

This usage was subsequently adopted by
Sussman and Steele when they defined
Scheme in 1975, a lexically scoped variant of
LISP, and became widespread.

Chastised, Anton took his leave from his master
and returned to his cell, intent on studying
closures. He carefully read the entire “Lambda:
The Ultimate...” series of papers and its cousins,
and implemented a small Scheme interpreter with a
closure-based object system.

(define (eval exp env)
(cond ((self-evaluating? exp) exp)
((variable? exp) (lookup-variable-value exp env))
((quoted? exp) (text-of-quotation exp))
((assignment? exp) (eval-assignment exp env))
((definition? exp) (eval-definition exp env))
((if? exp) (eval-if exp env))
((lambda? exp)
(make-procedure (lambda-parameters exp)
(lambda-body exp)
env))
((begin? exp)
(eval-sequence (begin-actions exp) env))
((cond? exp) (eval (cond->if exp) env))
((application? exp)
(apply (eval (operator exp) env)
(list-of-values (operands exp) env)))
(else
(error "Unknown expression type -- EVAL" exp))))

This work developed out of an initial attempt
to understand the actorness of actors.
This interpreter attempted to intermix the
use of actors and LISP lambda expressions in
a clean manner.
“Scheme: An Interpreter for Extended Lambda Calculus”
Gerald Jay Sussman & Guy L Steele Jr

When it was completed, we discovered that
the “actors” and the lambda expressions
were identical in implementation.
“Scheme: An Interpreter for Extended Lambda Calculus”
Gerald Jay Sussman & Guy L Steele Jr

On his next walk with Qc Na, Anton attempted
to impress his master by saying “Master, I have
diligently studied the matter, and now understand
that objects are truly a poor man’s closures.”
Qc Na responded by hitting Anton with his stick,
saying “When will you learn? Closures are a poor
man’s object.”

At that moment, Anton became enlightened.

λ-calculus was the
first object-oriented
language.

const newStack = () => {
const items = []
return {
depth: () => items.length,
top: () => items[0],
push: newTop => { items.unshift(newTop) },
pop: () => { items.shift() },
}
}

One of the most powerful
mechanisms for program
structuring [...] is the block
and procedure concept.
Ole-Johan Dahl and C A R Hoare
“Hierarchical Program Structures”

begin
ref(Rock) array items(1:capacity);
integer count;
integer procedure Depth; ...
ref(Rock) procedure Top; ...
procedure Push(top); ...
procedure Pop; ...
count := 0
end;

A procedure which is capable of
giving rise to block instances which
survive its call will be known as a
class; and the instances will be
known as objects of that class.
Ole-Johan Dahl and C A R Hoare
“Hierarchical Program Structures”

class Stack(capacity);
integer capacity;
begin
ref(Rock) array items(1:capacity);
integer count;
integer procedure Depth; ...
ref(Rock) procedure Top; ...
procedure Push(top); ...
procedure Pop; ...
count := 0
end;

We could, of course, use any notation
we want; do not laugh at notations;
invent them, they are powerful.
In fact, mathematics is, to a large
extent, invention of better notations.
Richard Feynman

()->{}((Runnable)()->{}).run()

f → λ x· ☹️
variable
abstraction

“Oh God,” muttered Ford, slumped against
a bulkhead and started to count to ten.
He was desperately worried that one day
sentient life forms would forget how to do this.
Only by counting could humans demonstrate
their independence of computers.

_0 = f => x => x
_1 = f => x => f(x)
_2 = f => x => f(f(x))
_3 = f => x => f(f(f(x)))
_4 = f => x => f(f(f(f(x))))
_5 = f => x => f(f(f(f(f(x)))

_0(n => n + 1)(0)
_1(n => n + 1)(0)
_2(n => n + 1)(0)
_3(n => n + 1)(0)
_4(n => n + 1)(0)
_5(n => n + 1)(0)
0
1
2
3
4
5

_0(n => n + ‘1’)(‘’)
_1(n => n + ‘1’)(‘’)
_2(n => n + ‘1’)(‘’)
_3(n => n + ‘1’)(‘’)
_4(n => n + ‘1’)(‘’)
_5(n => n + ‘1’)(‘’)
1
11
111
1111
11111

true → λ a b· a
false → λ a b· b

7 * 7 < limit
ifTrue: [^ ‘👍’]
ifFalse: [^ ‘👎’]

True
ifTrue: toDo ifFalse: ignore
^ toDo value

False
ifTrue: ignore ifFalse: toDo
^ toDo value

pair → λ x y f· f(x)(y)
first → λ p· p(λ x y· x)
second → λ p· p(λ x y· y)

pair → λ x y f· f x y
first → λ p· p true
second → λ p· p false
nil → λ x· true

cons → λ x y f· f x y
car → λ p· p true
cdr → λ p· p false
nil → λ x· true

https://twitter.com/richardadalton/status/591534529086693376

def fizzbuzz(n)
{
result = ''
if (n % 3 == 0)
result += 'Fizz'
if (n % 5 == 0)
result += 'Buzz'
if (!result)
result += n
result
}

The default action is executed only if some
previous actions were not executed.
Maciej Piróg
“FizzBuzz in Haskell by Embedding a Domain-Specific Language”

def fizzbuzz(n)
{
[0: 'Fizz'].get(n % 3, '') +
[0: 'Buzz'].get(n % 5, '') ?:
n.toString()
}

We ask if we can accomplish this without
having to check the conditions for the previous
actions twice.
Maciej Piróg

def fizzbuzz(n)
{
if (n % 15 == 0)
'FizzBuzz'
else if (n % 3 == 0)
'Fizz'
else if (n % 5 == 0)
'Buzz'
else
n.toString()
}

def fizzbuzz(n)
{
if (n % 3 == 0 && n % 5 == 0)
'FizzBuzz'
else if (n % 3 == 0)
'Fizz'
else if (n % 5 == 0)
'Buzz'
else
n.toString()
}

We ask if we can accomplish this without
having to check the conditions for the previous
actions twice; in other words, if we can make
the control flow follow the information flow
without loosing modularity.
Maciej Piróg

def fizzbuzz(n)
{
id = {x -> x}
}

def fizzbuzz(n)
{
id = {it}
val = {x -> {_ -> x}}
}

def fizzbuzz(n)
{
id = {it}
val = {{_ -> it}}
fizz = n % 3 ? id : {val('Fizz' + it(''))}
buzz = n % 5 ? id : {val('Buzz' + it(''))}
fizz(buzz({it.toString()}))(n)
}

(1..100).each {println fizzbuzz(it)}

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

I have yet to see any problem,
however complicated, which,
when you looked at it in the
right way, did not become still
more complicated.
Anderson's Law

We shall not cease from exploration
And the end of all our exploring
Will be to arrive where we started
And know the place for the first time.
T S Eliot

Lambda? You Keep Using that Letter

Lambda? You Keep Using that Letter

More Related Content

What's hot

Similar to Lambda? You Keep Using that Letter

More from Kevlin Henney

Recently uploaded

Lambda? You Keep Using that Letter