Programming with Nothing

PROGRAMMING
@tomstuart — RU3Y MANOR — 2011-10-29
WITH
NOTHING

View Slide

RUBY
I LOVE

View Slide

expressive
ﬂexible
beautiful
loads of language features
loads of core functionality
loads of standard libraries
loads of third-party libraries

View Slide

RUBY
LET’S RUIN

View Slide

How much can Ruby do
if we remove all its features?

View Slide

no gems
no standard library
no modules
no classes
no objects
no methods

View Slide

no control ﬂow
no assignment
no arrays
no strings
no numbers
no booleans

View Slide

GAME
JUST A

View Slide

NOT
SOFTWARE
ENGINEERING
ADVICE

View Slide

HERE ARE THE
RULES

View Slide

create procs
call procs
(abbreviate with constants)

View Slide

HERE IS THE
GOAL

View Slide

”
Write a program that prints the numbers
from 1 to 100. But for multiples of three
print “Fizz” instead of the number and
for the multiples of ﬁve print “Buzz”. For
numbers which are multiples of both
three and ﬁve print “FizzBuzz”.
“
— Imran Ghory

View Slide

LET’S
TALK ABOUT
PROCS

View Slide

Procs are just plumbing.
lambda { |x| x + 1 }.call(41)
= 41 + 1
The rest of the language
does the actual work.

View Slide

Procs don’t need
multiple arguments.

View Slide

lambda { |x, y|
x + y
}.call(3, 4)
is the same as
lambda { |x|
lambda { |y|
x + y
}
}.call(3).call(4)

View Slide

The only way to use
the body of a proc
is to call it.

View Slide

lambda { |x| p.call(x) }
If p is a proc, then
is the same as just
p

View Slide

SYNTAX TIME
STOP

View Slide

Proc.new { |x| x + 1 }
proc { |x| x + 1 }
lambda { |x| x + 1 }
-> x { x + 1 }
Creating a proc:
1.9
1.8

View Slide

1.9
1.8
p === 41
Calling a proc:
p.call(41)
p[41]
p.(41)

View Slide

I’m going to say:
lambda { |x| x + 1 }.call(41)
Instead of:
-> x { x + 1 }[41]

View Slide

GO

View Slide

(1..100).
if (n % 15).zero?
elsif (n % 3).zero?
elsif (n % 5).zero?
else
end
end
each
puts
puts
puts
puts
'FizzBuzz'
'Fizz'
'Buzz'
n.to_s
do |n|

View Slide

(1..100).
if (n % 15).zero?
elsif (n % 3).zero?
elsif (n % 5).zero?
else
end
end
'FizzBuzz'
'Fizz'
'Buzz'
n.to_s
map do |n|

View Slide

Numbers

View Slide

How do we represent numbers
using no data, only code?
All our code can do
is make or call a proc.

View Slide

Represent a number n with code
that calls a proc n times.

View Slide

def zero(proc, x)
x
end
def one(proc, x)
proc[x]
end
def two(proc, x)
proc[proc[x]]
end
def three(proc, x)
proc[proc[proc[x]]]
end

View Slide

ZERO = -> p { -> x { x } }
ONE = -> p { -> x { p[x] } }
TWO = -> p { -> x { p[p[x]] } }
THREE = -> p { -> x { p[p[p[x]]] } }

View Slide

def to_integer(proc)
proc[-> n { n + 1 }][0]
end
>> to_integer(ZERO)
=> 0
>> to_integer(THREE)
=> 3

View Slide

FIVE = -> p { -> x { p[p[p[p[p[x]]]]] } }
FIFTEEN = -> p { -> x { p[p[p[p[p[p[p[p[p[
p[p[p[p[p[p[x]]]]]]]]]]]]]]] } }
HUNDRED = -> p { -> x { p[p[p[p[p[p[p[p[p[
p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[
p[p[p[p[p[p[p[x]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] } }

View Slide

1 100
15
3
5
(
if (n %
'FizzBuzz'
elsif (n %
'Fizz'
elsif (n %
'Buzz'
else
n.to_s
end
end
).zero?
).zero?
).zero?
.. ).map do |n|

View Slide

ONE HUNDRED
FIFTEEN
THREE
FIVE
(
if (n %
'FizzBuzz'
elsif (n %
'Fizz'
elsif (n %
'Buzz'
else
n.to_s
end
end
).zero?
).zero?
).zero?
.. ).map do |n|

View Slide

This code doesn’t work:
the numbers aren’t Fixnums.
The numeric operations
must be replaced too.

View Slide

Booleans

View Slide

How do we represent booleans
using no data, only code?

View Slide

Booleans are used for
choosing between two options.
Represent a boolean with code
that chooses one of two values.

View Slide

def true(x, y)
x
end
def false(x, y)
y
end

View Slide

TRUE = -> x { -> y { x } }
FALSE = -> x { -> y { y } }

View Slide

def to_boolean(proc)
proc[true][false]
end
>> to_boolean(TRUE)
=> true
>> to_boolean(FALSE)
=> false

View Slide

def if(proc, x, y)
proc[x][y]
end

View Slide

b [x]
}
-> x {
}
IF = -> b {
TRUE = -> x { -> y { x } }
FALSE = -> x { -> y { y } }
-> y {
[y]
}

View Slide

b [x]
-> x {
}
}
IF = -> b {
TRUE = -> x { -> y { x } }
FALSE = -> x { -> y { y } }

View Slide

b
}
IF = -> b {
TRUE = -> x { -> y { x } }
FALSE = -> x { -> y { y } }

View Slide

b
IF = -> b { }
TRUE = -> x { -> y { x } }
FALSE = -> x { -> y { y } }
proc [true][false]
end

View Slide

proc [true][false]
end
b
IF = -> b { }
TRUE = -> x { -> y { x } }
FALSE = -> x { -> y { y } }
IF[ ]

View Slide

(n % THREE).zero?
(n % FIVE).zero?
(ONE..HUNDRED).map do |n|
(n % FIFTEEN).zero?
'FizzBuzz'
'Fizz'
'Buzz'
n.to_s
end
if
elsif
elsif
else
end

View Slide

(n % THREE).zero?
(n % FIVE).zero?
(n % FIFTEEN).zero?
'FizzBuzz'
'Fizz'
'Buzz'
n.to_s
end
IF[ ][
][IF[ ][
][IF[ ][
][
]]]

View Slide

Predicates

View Slide

if == 0
else
end
false
true
n
end
def zero?(n)
ZERO = -> p { -> x { x } }
ONE = -> p { -> x { p[x] } }
TWO = -> p { -> x { p[p[x]] } }
THREE = -> p { -> x { p[p[p[x]]] } }

View Slide

end
[-> x { }][ ]
false true
n
def zero?(n)
ZERO = -> p { -> x { x } }
ONE = -> p { -> x { p[x] } }
TWO = -> p { -> x { p[p[x]] } }
THREE = -> p { -> x { p[p[p[x]]] } }

View Slide

IS_ZERO = -> n { n[-> x { FALSE }][TRUE] }
>> to_boolean(IS_ZERO[ZERO])
=> true
>> to_boolean(IS_ZERO[THREE])
=> false

View Slide

( ).zero?
( ).zero?
( ).zero?
IF[
'FizzBuzz'
][IF[
'Fizz'
][IF[
'Buzz'
][
n.to_s
]]]
end
][
][
][
n % FIFTEEN
n % THREE
n % FIVE

View Slide

][
][
][
IS_ZERO[ ]
IS_ZERO[ ]
IS_ZERO[ ]
n % FIFTEEN
n % THREE
n % FIVE
IF[
'FizzBuzz'
][IF[
'Fizz'
][IF[
'Buzz'
][
n.to_s
]]]
end

View Slide

Numeric operations

View Slide

Here’s some basic arithmetic
I made earlier:
INCREMENT = -> n { -> f { -> x { f[n[f][x]] } } }
DECREMENT = -> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }]
[-> y { x }][-> y { y }] } } }
ADD = -> m { -> n { n[INCREMENT][m] } }
SUBTRACT = -> m { -> n { n[DECREMENT][m] } }
MULTIPLY = -> m { -> n { n[ADD[m]][ZERO] } }
POWER = -> m { -> n { n[MULTIPLY[m]][ONE] } }

View Slide

def mod(m, n)
if n <= m
mod(m - n, n)
else
m
end
end

View Slide

m
def less_or_equal?(m, n)
end
- <= 0
n

View Slide

n
m
def less_or_equal?(m, n)
end
IS_ZERO[SUBTRACT[ ][ ]]

View Slide

IS_LESS_OR_EQUAL =
-> m { -> n {
IS_ZERO[SUBTRACT[m][n]]
} }

View Slide

def mod(m, n)
if n <= m
mod(m - n, n)
else
m
end
end

View Slide

MOD =
-> m { -> n {
IF[IS_LESS_OR_EQUAL[n][m]][
MOD[SUBTRACT[m][n]][n]
][
m
]
} }

View Slide

PROBLEM

View Slide

>> to_integer(MOD[THREE][TWO])
SystemStackError: stack level too deep

View Slide

Ruby’s if/else statement only
evaluates one of its two blocks.
Our IF implementation takes two
values, not blocks to evaluate.

View Slide

][
m
]
} }
MOD =
-> m { -> n {

View Slide

-> x {
[x]
}
][
m
]
} }
MOD =
-> m { -> n {

View Slide

>> to_integer(MOD[THREE][TWO])
=> 1
>> to_integer(MOD[
POWER[THREE][THREE]
][
ADD[THREE][TWO]
])
=> 2

View Slide

ANOTHER
PROBLEM

View Slide

=
-> m { -> n {
IF[IS_LESS_OR_EQUAL[n][m][
-> x {
[x]
}
[SUBTRACT[m][n]][n]
][
m
]
} }
MOD
MOD
This is not
an abbreviation.

View Slide

We can solve this problem
with the “Y combinator”,
a famous piece of helper code
for deﬁning recursive functions.

View Slide

Y = -> f { -> x { f[x[x]] }
[-> x { f[x[x]] }] }

View Slide

Actually, this loops forever too.
We need a modiﬁed version.

View Slide

] }
] }] }
x[x]
x[x]
= -> f { -> x { f[
[-> x { f[
Y

View Slide

] }
] }] }
x[x]
x[x]
= -> f { -> x { f[
[-> x { f[
Z -> y { [y] }
-> y { [y] }

View Slide

[SUBTRACT[m][n]][n][x]
-> m { -> n {
MOD =
-> x {
}
][
m
]
} }
MOD

View Slide

[SUBTRACT[m][n]][n][x]
-> m { -> n {
MOD =
-> x {
}
][
m
]
} }
Z[-> f {
f
}]

View Slide

IF[IS_ZERO[
'FizzBuzz'
][IF[IS_ZERO[
'Fizz'
][IF[IS_ZERO[
'Buzz'
][
n.to_s
]]]
end
FIFTEEN
THREE
FIVE
%
%
%
n
n
n
]][
]][
]][

View Slide

]][
]][
]][
FIFTEEN
THREE
FIVE
MOD[ ][ ]
MOD[ ][ ]
MOD[ ][ ]
IF[IS_ZERO[
'FizzBuzz'
][IF[IS_ZERO[
'Fizz'
][IF[IS_ZERO[
'Buzz'
][
n.to_s
]]]
end
n
n
n

View Slide

Lists

View Slide

PAIR = -> x { -> y { -> f { f[x][y] } } }
LEFT = -> p { p[-> x { -> y { x } } ] }
RIGHT = -> p { p[-> x { -> y { y } } ] }

View Slide

EMPTY = PAIR[TRUE][TRUE]
UNSHIFT = -> l { -> x {
PAIR[FALSE][PAIR[x][l]]
} }
IS_EMPTY = LEFT
FIRST = -> l { LEFT[RIGHT[l]] }
REST = -> l { RIGHT[RIGHT[l]] }

View Slide

def range(m, n)
if m <= n
range(m + 1, n).unshift(m)
else
[]
end
end

View Slide

RANGE =
Z[-> f {
-> m { -> n {
IF[IS_LESS_OR_EQUAL[m][n]][
-> x {
UNSHIFT[f[INCREMENT[m]][n]][m][x]
}
][
EMPTY
]
} }
}]

View Slide

( .. )
IF[IS_ZERO[MOD[n][FIFTEEN]]][
'FizzBuzz'
][IF[IS_ZERO[MOD[n][THREE]]][
'Fizz'
][IF[IS_ZERO[MOD[n][FIVE]]][
'Buzz'
][
n.to_s
]]]
end
ONE HUNDRED .map do |n|

View Slide

'FizzBuzz'
'Fizz'
'Buzz'
][
n.to_s
]]]
end
RANGE[ ][ ]
ONE HUNDRED .map do |n|

View Slide

FOLD =
Z[-> f {
-> l { -> x { -> g {
IF[IS_EMPTY[l]][
x
][
-> y {
g[f[REST[l]][x][g]][FIRST[l]][y]
}
]
} } }
}]
MAP =
-> k { -> f {
FOLD[k][EMPTY][
-> l { -> x { UNSHIFT[l][f[x]] } }
]
} }

View Slide

n
'FizzBuzz'
'Fizz'
'Buzz'
][
n.to_s
]]]
.map do | |
end
RANGE[ONE][HUNDRED]

View Slide

RANGE[ONE][HUNDRED] n
'FizzBuzz'
'Fizz'
'Buzz'
][
n.to_s
]]]
MAP[ ][-> {
}]

View Slide

Strings

View Slide

Strings can be represented
as lists of numbers.
Just choose an encoding.

View Slide

def to_char(c)
'0123456789BFiuz'.slice(to_integer(c))
end
def to_string(s)
to_array(s).map { |c| to_char(c) }.join
end

View Slide

TEN = MULTIPLY[TWO][FIVE]
RADIX = TEN
TO_STRING =
Z[-> f { -> n { PUSH[
IF[IS_LESS_OR_EQUAL[n][DECREMENT[RADIX]]][
EMPTY
][
-> x {
f[DIV[n][RADIX]][x]
}
]
][MOD[n][RADIX]] } }]

View Slide

MAP[RANGE[ONE][HUNDRED]][-> n {
][
]]]
}]
.to_s
n
'FizzBuzz'
'Fizz'
'Buzz'

View Slide

'FizzBuzz'
'Fizz'
'Buzz'
][
]]]
}]
TO_STRING[ ]
n

View Slide

FIZZBUZZ
FIZZ
BUZZ
][
]]]
}]
TO_STRING[ ]
n

View Slide

The constants are
just abbreviations.
Replace each constant
with its deﬁnition
to get the full program.

View Slide

-> k { -> f { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { ->g { -> b { b }[-> p { p[-> x { -> y { x } } ] }[l]][x][-> y { g[f[-> l { -> p
{ p[-> x { -> y { y } } ] }[-> p { p[-> x { -> y { y } } ] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } } ] }[-> p { p[-> x {-> y { y } } ] }[l]] }[l]][y] }] } } } }][k][-> x { -
> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> l { -> x { -> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x]
[y] } } }[x][l]] } }[l][f[x]] } }] } }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[->y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y
{ y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }][-> y { x }][-> y { y }] } } }][m] } }[m][n]] } }[m][n]][-> x { -> l { -> x { -> x { ->
y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[f[-> n { -> f { -> x { f[n[f][x]] } } }[m]][n]][m][x] }][-> x { -> y { -> f { f[x][y] } } }[->
x { -> y { x } }][-> x { -> y { x } }]] } } }][-> f { -> x { f[x] } }][-> f { -> x { f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f
[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[x]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]] }}]][-> n { -> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n
{ -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }][-> y { x }][-> y { y }] } } }]
[m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }][-> y { x }][-> y { y }] } } }][m] } }[m][n]][n][x] }][m] } } }][n][-> f { -> x
{ f[f[f[f[f[f[f[f[f[f[f[f[f[f[f[x]]]]]]]]]]]]]]] } }]]][-> k { -> l { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p
{ p[-> x { -> y { x } } ] }[l]][x][-> y { g[f[-> l { -> p { p[-> x { -> y { y } } ] }[-> p { p[-> x { -> y { y } } ] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } } ] }[-> p { p[-
> x { -> y { y } } ] }[l]] }[l]][y] }] } } } }][k][l][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }] } }[-> k { -> f
{ -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[-> x { -> y { x } } ] }[l]][x][-> y { g[f[-> l { -> p { p[-> x { ->
y { y } } ] }[-> p { p[-> x { -> y { y } } ] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } } ] }[-> p { p[-> x { -> y { y } } ] }[l]] }[l]][y] }] } } } }][k][-> x { -> y { -> f
{ f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> l { -> x { -> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x]
[l]] } }[l][f[x]] } }] } }[-> l { -> x { -> x {-> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x]
[y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[->l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x]
[l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x
{ -> y { x } }]][-> f {-> x { f[f[f[f[x]]]] } }]][-> f { -> x { f[f[f[f[x]]]] } }]][-> f { -> x { f[f[x]] } }]][-> f { -> x { f[x] } }]][-> m { -> n { n[-> n { -> f { -> x { f[n[f]
[x]] } } }][m] } }[-> m { -> n { n[-> m { -> n { n[-> n { -> f { -> x { f[n[f][x]] } } }][m] } }[m]][-> f { -> x { x } }] } }[-> f { -> x { f[f[x]] } }][-> f { -> x
{ f[f[f[f[f[x]]]]] } }]]]][-> k { -> f { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[-> x { -> y { x } } ] }[l]]
[x][-> y { g[f[-> l { -> p { p[-> x { -> y { y } } ] }[-> p { p[-> x { -> y { y } } ] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } } ] }[-> p { p[-> x { -> y { y } } ] }[l]] }
[l]][y] }] } } } }][k][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> l { -> x { -> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-
> x { -> y { -> f { f[x][y] } } }[x][l]] } }[l][f[x]] } }] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[->l { -
> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -
> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x]
[y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> f { -> x { f[f[f[f[x]]]] } }]][-> f { -> x { f[f[f[f[x]]]] } }]][-> f { -> x { f[f[f[x]]] } }]][->f { -> x { x } }]][-> m { -> n
{ n[-> n { -> f { -> x { f[n[f][x]] } } }][m] } }[-> m { -> n { n[-> m { ->n { n[-> n { -> f { -> x { f[n[f][x]] } } }][m] } }[m]][-> f { -> x { x } }] } }[-> f { -> x { f[f[x]] } }][->
f { -> x { f[f[f[f[f[x]]]]] } }]]]]][-> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -
> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }][-> y { x }][-> y
{ y }] } } }][m] } }[m][n]] } }[n][m]][-> x { f[->m { -> n { n[-> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }][-> y { x }][-> y { y }] } } }][m] } }[m][n]][n][x] }][m] } } }][n][-> f
{ -> x { f[f[f[x]]] } }]]][-> k { -> f { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[-> x { -> y { x } } ] }[l]]
[x][-> y { g[f[-> l { -> p { p[-> x { -> y { y } } ] }[-> p { p[-> x { -> y { y } } ] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } } ] }[-> p { p[-> x { -> y { y } } ] }[l]] }
[l]][y] }] } } } }][k][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> l { -> x { -> l { -> x {-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][->
x { -> y { -> f { f[x][y] } } }[x][l]] } }[l][f[x]] } }] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { ->
x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][->x { -> y
{ -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-
> x { -> y { x } }][-> x { -> y { x } }]][-> f { -> x { f[f[f[f[x]]]] } }]][-> f { -> x { f[f[f[f[x]]]] } }]][-> f { -> x { f[f[x]] } }]][-> f { -> x { f[x] } }]][-> m { -> n { n[-> n
{ -> f { -> x { f[n[f][x]] } } }][m] } }[-> m { -> n { n[-> m { -> n { n[-> n { -> f { -> x { f[n[f][x]] } } }][m] } }[m]][-> f { -> x { x } }] } }[-> f { -> x { f[f[x]] } }][-> f { -> x
{ f[f[f[f[f[x]]]]] } }]]]][-> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { ->m { -> n
{ -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }][-> y { x }][-> y { y }] } } }]
[m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }][-> y { x }][-> y { y }] } } }][m] } }[m][n]][n][x] }][m] } } }][n][-> f { -> x
{ f[f[f[f[f[x]]]]] } }]]][-> k { -> f { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[->x { -> y { x } } ] }[l]][x]
[-> y { g[f[-> l { -> p { p[-> x { -> y { y } } ] }[-> p { p[-> x { -> y { y } } ] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } } ] }[-> p { p[-> x { -> y { y } } ] }[l]] }[l]]
[y] }] } } } }][k][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> l { ->x { -> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x
{ -> y { -> f { f[x][y] } } }[x][l]] } }[l][f[x]] } }] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x
{ -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x {-> y { y } }][-> x { -> y
{ -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-
>x { -> y { x } }][-> x { -> y { x } }]][-> f { -> x { f[f[f[f[x]]]] } }]][-> f { -> x { f[f[f[f[x]]]] } }]][-> f { -> x { f[f[f[x]]] } }]][-> f { -> x { x } }]][-> m { -> n { n[-> n { -
> f { -> x { f[n[f][x]] } } }][m] } }[-> m { -> n { n[-> m { -> n { n[-> n { -> f { -> x { f[n[f][x]] } } }][m] } }[m]][-> f { -> x { x } }] } }[-> f { -> x { f[f[x]] } }][-> f { -> x
{ f[f[f[f[f[x]]]]] } }]]]][-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> n { -> l { -> x { -> k { -> l { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y
{ x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[-> x { -> y { x } } ] }[l]][x][-> y { g[f[-> l { -> p { p[-> x { -> y { y } } ] }[-> p { p[-> x { -> y { y } } ] }[l]] }
[l]][x][g]][-> l { -> p { p[-> x { -> y { x } } ] }[-> p { p[-> x { -> y { y } } ] }[l]] }[l]][y] }] } } } }][k][l][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }]
[-> x { -> y { -> f { f[x][y] } } }[x][l]] } }] } }[l][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x {-> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { ->
f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][x]] } }[-> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> f
{ -> x { n[-> g { -> h { h[g[f]] } }][-> y { x }][-> y { y }] } } }][m] } }[m][n]] } }[n][-> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }][-> y { x }][-> y { y }] } } }[-> m { -> n
{ n[-> m { -> n { n[-> n { -> f { -> x { f[n[f][x]] } } }][m] } }[m]][-> f { -> x { x } }] } }[-> f { -> x { f[f[x]] } }][-> f { -> x { f[f[f[f[f[x]]]]] } }]]]][-> x { -> y { -> f { f[x]
[y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][ -> x { f[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[->f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-
> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }][-> y { x }][-> y { y }] } } }][m] } }[m][n]] } }[n][m]][-> x { -> n
{ -> f { -> x { f[n[f][x]] } } }[f[-> m { -> n { n[-> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }][-> y { x }][-> y { y }] } } }][m] } }[m][n]][n]][x] }][-> f { -> x { x } }] } } }][n]
[-> m { -> n { n[-> m { -> n { n[-> n { -> f { -> x { f[n[f][x]] } } }][m] } }[m]][-> f { -> x { x } }] } }[-> f { -> x { f[f[x]] } }][-> f { -> x { f[f[f[f[f[x]]]]] } }]]][x] } ]][-> f
{ -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { ->x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n
{ n[-> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }][-> y { x }][-> y { y }] } } }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> f { -> x { n[-> g { -> h { h[g[f]] } }][-
> y { x }][-> y { y }] } } }][m] } }[m][n]][n][x] }][m] } } }][n][-> m { ->n { n[-> m { -> n { n[-> n { -> f { -> x { f[n[f][x]] } } }][m] } }[m]][-> f { -> x { x } }] } }[-> f { ->x
{ f[f[x]] } }][-> f { -> x { f[f[f[f[f[x]]]]] } }]]] } }][n]]]] }]

View Slide

WHY

View Slide

Within these constraints,
we can build any data structure
and implement any algorithm.

View Slide

There is no data, only code.

View Slide

No programming language
has more computational power
than -> and [].

View Slide

What differentiates languages?

View Slide

expressiveness
aesthetic appeal
safety vs. ﬂexibility
performance
ecosystem
community

View Slide

Ruby is in our sweet spot.
There are many languages like it,
but this one is ours.

View Slide

describe 'natural numbers' do
specify { ADD[representation_of 2][representation_of 3].should represent 2 + 3 }
specify { MULTIPLY[representation_of 2][representation_of 3].should represent 2 * 3 }
specify { POWER[representation_of 2][representation_of 3].should represent 2 ** 3 }
specify { SUBTRACT[representation_of 3][representation_of 2].should represent 3 - 2 }
context 'with booleans' do
(0..3).each do |n|
specify { IS_ZERO[representation_of n].should represent n.zero? }
specify { IS_EQUAL[representation_of n][representation_of 2].should represent n == 2 }
end
end
context 'with recursion' do
(0..5).zip([1, 1, 2, 6, 24, 120]) do |n, n_factorial|
specify { FACTORIAL[representation_of n].should represent n_factorial }
end
[0, 1, 11, 27].product([1, 3, 11]) do |m, n|
specify { DIV[representation_of m][representation_of n].should represent m / n }
specify { MOD[representation_of m][representation_of n].should represent m % n }
end
end
context 'with strings' do
specify { TO_STRING[representation_of 42].should represent '42' }
end
end
https://github.com/tomstuart/nothing

View Slide

Implement ADD, MULTIPLY and POWER for natural numbers
--- a/lib/nothing.rb
+++ b/lib/nothing.rb
@@ -9,9 +9,9 @@ module Nothing
TIMES = -> n { -> f { -> x { n[f][x] } } }
INCREMENT = -> n { -> f { -> x { f[n[f][x]] } } }
- # ADD =
- # MULTIPLY =
- # POWER =
+ ADD = -> m { -> n { n[INCREMENT][m] } }
+ MULTIPLY = -> m { -> n { n[ADD[m]][ZERO] } }
+ POWER = -> m { -> n { n[MULTIPLY[m]][ONE] } }
# DECREMENT =
# SUBTRACT =
--- a/spec/nothing_spec.rb
+++ b/spec/nothing_spec.rb
@@ -11,9 +11,9 @@ describe Nothing do
specify { TIMES[representation_of 3][-> s { s + 'o' }]['hell'].should == 'hellooo' }
specify { INCREMENT[representation_of 2].should represent 2 + 1 }
- specify { pending { ADD[representation_of 2][representation_of 3].should represent 2 + 3 } }
- specify { pending { MULTIPLY[representation_of 2][representation_of 3].should represent 2 * 3 } }
- specify { pending { POWER[representation_of 2][representation_of 3].should represent 2 ** 3 } }
+ specify { ADD[representation_of 2][representation_of 3].should represent 2 + 3 }
+ specify { MULTIPLY[representation_of 2][representation_of 3].should represent 2 * 3 }
+ specify { POWER[representation_of 2][representation_of 3].should represent 2 ** 3 }
specify { pending { DECREMENT[representation_of 3].should represent 3 - 1 } }
specify { pending { SUBTRACT[representation_of 3][representation_of 2].should represent 3 - 2 } }

View Slide

Extract INJECT from SUM and PRODUCT
--- a/lib/nothing.rb
+++ b/lib/nothing.rb
@@ -56,9 +56,11 @@ module Nothing
FIRST = -> l { LEFT[RIGHT[l]] }
REST = -> l { RIGHT[RIGHT[l]] }
+ INJECT = Z[-> f { -> l { -> x { -> g { IF[IS_EMPTY[l]][x][-> _ { f[REST[l]][g[x]
[FIRST[l]]][g][_] }] } } } }]
+
RANGE = Z[-> f { -> x { -> y { IF[IS_LESS_OR_EQUAL][x][y][-> _ { UNSHIFT[x]
[f[INCREMENT[x]][y]][_] }][EMPTY] } } }]
- SUM = Z[-> f { -> l { IF[IS_EMPTY[l]][ZERO][-> _ { ADD[FIRST[l]][f[REST[l]]]
[_] }] } }]
- PRODUCT = Z[-> f { -> l { IF[IS_EMPTY[l]][ONE][-> _ { MULTIPLY[FIRST[l]][f[REST[l]]]
[_] }] } }]
+ SUM = -> l { INJECT[l][ZERO][ADD] }
+ PRODUCT = -> l { INJECT[l][ONE][MULTIPLY] }
# CONCAT =
# PUSH =
# REVERSE =

View Slide

THANK
YOU
[email protected]
@tomstuart

View Slide

Programming with Nothing

Programming with Nothing

Tom Stuart

More Decks by Tom Stuart

Other Decks in Programming

Featured

Transcript