lambda calculus beep boop

recursion: https://beep-boop-bap.glitch.me/

soundtest

Sounds.playStuff([{ beops: "beep beep boop boop pling bap".split(" ")}])

commands for slides

Exp u ::=	x	variable
	λx.u	abstraction
	u1 u2	application

this is mostly about syntax really

also it's like stupid I guess

semantics though

replace references to parameter with argument

(λa.λb.λc.c a b) foo bar quux
(λb.λc.c foo b) bar quux
(λc.c foo bar) quux
quux foo bar

some lambdas

0 is λf.λx.x
1 is λf.λx.f x
2 is λf.λx.f (f x)
3 is λf.λx.f (f (f x))
5 is λf.λx.f (f (f (f (f x))))
and so on

some lambdas

+ is λa.λb.λf.λx.a f (b f x)
(f applied a times to f applied b times to x)

* is λa.λb.λf.λx.a (b f) x
(f applied b times a times to x)

can try

xxxxxxxxxx
 
2 ≜ λf.λx.f (f x)
3 ≜ λf.λx.f (f (f x))
+ ≜ λa.λb.λf.λx.a f (b f x)
* ≜ λa.λb.λf.λx.a (b f) x
​
+ 2 2
+ 2 3
​

is traditional
possibly shoutability concerns
variables can be named almost anything
is the untyped lambda calculus sound?
has greek letters in it (hci?)
parentheses)))
variable capture thing

variable capture thing

λy.(λx.λy.x) y

variable capture thing

λy.(λx.λy.x) y

λy.λy.y

oh no

variable capture thing

λy.(λx.λy.x) y

rename inner y before reducing

xxxxxxxxxx
 
λy.(λx.λy.x) y

de bruijn index

Exp u ::=	n	variable
	λu	abstraction
	u1 u2	application

λz.(λy.y (λx. x)) (λx.z x)

some lambdas

0 is λλ1
1 is λλ2 1
2 is λλ2 (2 1)
3 is λλ2 (2 (2 1))
5 is λλ2 (2 (2 (2 (2 1))))
and so on

some lambdas

+ is λλλλ4 2 (3 2 1)
(um)

* is λλλλ4 (3 2) 1
(uh)

some lambdas

+ is λa.λb.λf.λx.a f (b f x)
(f applied a times to f applied b times to x)

* is λa.λb.λf.λx.a (b f) x
(f applied b times a times to x)

λa.λb.λf.λx.a f (b f x)

λλλλ4 2 (3 2 1)

2 + 3

(λλλλ4 2 (3 2 1)) (λλ2 (2 1)) (λλ2 (2 (2 1)))
(λλλ(λλ2 (2 1)) 2 (3 2 1)) (λλ2 (2 (2 1)))
λλ(λλ2 (2 1)) 2 ((λλ2 (2 (2 1))) 2 1)
λλ(λ3 (3 1)) ((λλ2 (2 (2 1))) 2 1)
λλ2 (2 ((λλ2 (2 (2 1))) 2 1))
λλ2 (2 ((λ3 (3 (3 1))) 1))
λλ2 (2 (2 (2 (2 1))))

2 * 3

(λλλλ4 (3 2) 1) (λλ2 (2 1)) (λλ2 (2 (2 1)))
(λλλ(λλ2 (2 1)) (3 2) 1) (λλ2 (2 (2 1)))
λλ(λλ2 (2 1)) ((λλ2 (2 (2 1))) 2) 1
λλ(λ(λλ2 (2 (2 1))) 3 ((λλ2 (2 (2 1))) 3 1)) 1
λλ(λλ2 (2 (2 1))) 2 ((λλ2 (2 (2 1))) 2 1)
λλ(λ3 (3 (3 1))) ((λλ2 (2 (2 1))) 2 1)
λλ2 (2 (2 ((λλ2 (2 (2 1))) 2 1)))
λλ2 (2 (2 ((λ3 (3 (3 1))) 1)))
λλ2 (2 (2 (2 (2 (2 1)))))

variable capture thing

λy.(λx.λy.x) y

λ(λλ2) 1

variable capture thing

λ(λλ2) 1

λλ2

λy.(λx.λy.x) y

λy2.(λx.λy.x) y2

λy2.λy.y2

λ(λλ2) 1

λλ2

λ(λλ2 (λ3)) 1

λλ2 (λ3)

anyway

arithmetic instead of variable capture
subtract 1 from free variables in the function
number of parameter-variable in function increases with depth in syntax tree
add depth to free variables in argument when replacing

fewer possible variable names
still uses greek letters
also still parentheses
maths

beep boop

Exp u ::=	boop b	variable
	beep u	abstraction
	pling u1 u2	application

Boops b ::=	bap	bap
	boop b	boop

so the identity function is beep boop bap

nice

so the identity function is beep boop bap

λx.x

beep boop bap

some beep boops

0 is beep beep boop bap
1 is beep beep pling boop boop bap boop bap
2 is beep beep pling boop boop bap pling boop boop bap boop bap
3 is beep beep pling boop boop bap pling boop boop bap pling boop boop bap boop bap
5 is beep beep pling boop boop bap pling boop boop bap pling boop boop bap pling boop boop bap pling boop boop bap boop bap
and so on

some beep boops

+ is beep beep beep beep pling pling boop boop boop boop bap boop boop bap pling pling boop boop boop bap boop boop bap boop bap
* is beep beep beep beep pling pling boop boop boop boop bap pling boop boop boop bap boop boop bap boop bap

2 + 3

pling pling beep beep beep beep pling pling boop boop boop boop bap boop boop bap pling pling boop boop boop bap boop boop bap boop bap beep beep pling boop boop bap pling boop boop bap boop bap beep beep pling boop boop bap pling boop boop bap pling boop boop bap boop bap

we can try

for keyboard: a = beep, s = boop d = bap, f = pling, backspace = undo, space = "next"

>

with tree

lambdatree!

>

more lambdaer

>
_

also actual sounds

>
_

no parentheses
a small set of not very difficult words
solves hci issues by being intuitive for both humans and computers

cannot syntax error

xxxxxxxxxx
 
λf.λx.f (f x
λf.λx f (f x)
x.x

>
_

so uh what else?

I mean, there's fish?

Einar always has some fish

Svg.create( 600, 600, Mirror.mirrorShapes( 600, Picture.squareLimitColor( 4, Magic.createPicture(Fish.fancy())) (Lens.create( Box.create( Vector.create(100, 100), Vector.create(400, 0), Vector.create(0, 400)), Hue.create("black")))).map(r => r.shape.toSvgElement(r.style)))

>
_

some other picture combinator thing

maybe more legible

>
_

can make it sound different

>
_

(supersaw stolen from @mollerse. code.)

forever

omega!

>
_

conclusion

you totally can use numbers instead of variable names
if you use a symbol for function application you can drop the parentheses
- it's like reverse reverse polish notation
  - I mean polish notation
    - do you just call it notation here?
and I mean why would/wouldn't you do none/some/all of those things?
for some things, numbers and that is a good starting point

code

https://glitch.com/edit/#!/beep-boop-bap