Programming Comparisons
: True Lambda
scheme
((
lambda
(
n
)
((
lambda
(
fact
)
(
fact fact n
))
(
lambda
(
ft k
)
(
if
(
=
k
1
)
1
(
*
k
(
ft ft
(
-
k
1
)))))))
10
)
ruby
lambda
{|
n
|
lambda
{|
fact
| fact[fact, n] }[
lambda
{|
ft
,
k
|
if
k ==
1
then
1
else
k * ft[ft, k-
1
]
end
}]}[
10
]
perl
sub
{
my
(
$n
)=
@_
;
sub
{
my
(
$fact
)=
@_
;
$fact
->(
$fact
,
$n
);}->(
sub
{
my
(
$ft
,
$k
)=
@_
;
if
(
$k
==
1
) {
1
; }
else
{
$k
*
$ft
->(
$ft
,
$k
-
1
); }})}->(
10
);
ocaml
(fun
n
->
(fun
fact
->
fact
(
Obj
.magic fact
)
n
)
(fun
ft k
->
if
k
=
1
then
1
else
k
*
(
ft
(
Obj
.magic ft
)
(
k -
1
))))
10
lisp
(
funcall
#
'(
lambda
(
n
)
(
funcall
#'
(
lambda
(
fact
)
(
funcall
fact fact n
))
#'
(
lambda
(
ft k
)
(
if
(
=
k 1
)
1
(
*
k
(
funcall
ft ft
(
-
k 1
)))))))
10
)
python
(
lambda
n: (
lambda
fact: fact(fact, n))(
lambda
ft, k: k == 1
and
1
or
k * ft(ft, k-1) ) )(10)
false
10 [ [ $1=$ [ @% ]? ~[ $@$@1-@!* ]? ] [ $@\! ]! ]!
javascript
(
function
(n)
{
return
(
function
(fact)
{
return
fact(fact, n);
}
)(
function
(ft, k)
{
if
(k == 1)
return
1;
else
return
k * ft(ft, k-1);
}
);
}
)(10)
smalltalk
[
:n|
[
:fact|
fact value: fact value: n] value: [
:ft :k|
(k =
1
)
ifTrue:
[
1
]
ifFalse:
[ k * (ft value: ft value: (k -
1
)) ]]] value:
10
java
/*
class Lambda {
public int intToInt(final int n) { return 0; };
public int objToInt(Lambda fact) { return 0; };
public int objIntToInt(Lambda ft, final int k) { return 0; };
}
*/
(
new
Lambda() {
public
int
intToInt(
final
int
n) {
return
(
new
Lambda() {
public
int
objToInt(Lambda fact) {
return
fact.objIntToInt(fact, n); }}).objToInt(
new
Lambda() {
public
int
objIntToInt(Lambda ft,
final
int
k) {
if
(k ==
1
)
return
1
;
else
return
k * ft.objIntToInt(ft, k-
1
); }}); }}).intToInt(
10
);
haskell
-- newtype Mu a = Roll { unroll :: Mu a -> a }
(
\
n
->
(
\
fact
->
fact (Roll fact) n) (
\
ft k
->
if
k
==
1
then
1
else
k
*
(unroll ft ft (k
-
1
))))
10