>>> def Pair(a, b):
… return lambda pick: b if pick > 0 else a
>>> def head(p): return p(0)
…
>>> def tail(p): return p(1)
…
>>> head(Pair(3, ‘b’))
3

Anyway, haven’t gotten to this lecture yet, but I’ll be sure to revisit when I do.

# js> var Pair = function(a,b) { return function(pick) { return pick(a, b); } };
# js> var head = function(p) { return p(function(a) {return a}); };
# js> var tail = function(p) { return p(function(_, b) {return b}); }
# js> head(Pair(3,’b'));

Typo in your comment on FALSE. Should be

# FALSE := λ x. λ y. y

# TRUE := λ x. λ y. x
sub TRUE {
my $x = shift;
sub { $x }
}

# FALSE := λ x. λ y. x
sub FALSE {
my $x = shift;
sub { shift }
}

# pair := λ f. λ s. λ b. b f s
sub pair {
my $f = shift;
sub {
my $s = shift;
sub {
my $b = shift;
$b->($f)->($s);
}
}
}

# head := λ p p TRUE
sub head {
my $p = shift;
$p->(\&TRUE)
}

# tail := λ p p FALSE
sub tail {
my $p = shift;
$p->(\&FALSE)
}

From here you can implement lists and so forth.

- Stevan

@Cale: Yes, there are quite a few different ways to implement this. I decided to stick with the one proposed by GJS because it’s maybe more clear to untrained functional eyes. Also its slightly hackish feeling illustrates the last point that implementation can be improved anytime without leaking. But I certainly agree the implementation you proposed is more elegant. Care to post a little snippet in your favorite language for others to see?