 |  | 
Revenge of the Nerds yielded a
collection of canonical solutions to the same problem in
a number of languages.
The problem: Write a function foo that takes a number n and returns a
function that takes a number i, and returns n incremented by i.
Note: (a) that's number, not integer, (b) that's incremented by, not
plus.
<![CDATA[
C++ template<typename T>
struct Acc {
Acc(T n)
: n(n) {}
]]>
<![CDATA[
template<typename U>
Acc(const Acc<U>& u)
: n(u.n) {}
]]>
<![CDATA[
template<typename U>
T operator()(U i) {
return n += i;
}
]]>
<![CDATA[
T n;
};
]]>
<![CDATA[
template<typename T>
Acc<T> foo(T n)
{
return Acc<T>(n);
}
]]>
<![CDATA[
Dylan define function foo (n)
method (i) n := n + i end;
end function;
]]>
<![CDATA[
E def foo (var n) :any {
def inc (i) :any { n += i }
}
]]>
<![CDATA[
Erlang foop(N)->
receive
{P,I}-> S =N+I, P!S, foop(S)
end.
]]><![CDATA[
foo(N)->
P=spawn(foo,foop,[N]),
fun(I)->
P!{self(),I},
receive V->V end
end.
]]>
<![CDATA[
Haskell import IOExts
foo n = do
r <- newIORef n
return (\i -> do
modifyIORef r (+i)
readIORef r)
]]>
<![CDATA[
Javascript function foo (n) {
return function (i) {
return n += i } }
]]>
<![CDATA[
Lisp: Arc (def foo (n) [++ n _])
]]>
<![CDATA[
Lisp: Common Lisp (defun foo (n)
(lambda (i) (incf n i)))
]]>
<![CDATA[
Lisp: Goo (df foo (n) (op incf n _))
]]>
<![CDATA[
Lisp: Scheme (define (foo n)
(lambda (i)
(set! n (+ n i))
n))
]]>
<![CDATA[
Lua function foo(n)
return function (i)
n = n + i
return n
end
end
]]>
<![CDATA[
Maple foo := proc(n)
local s;
s := n;
proc(i) s := s + i
end
end
]]>
<![CDATA[
Mathematica foo = Module[{s=#},s+=# &] &
]]>
<![CDATA[
Mozart fun {Foo N}
A = {NewCell N}
in
fun {$ B} C D in
{Exchange A C D}
if {IsInt C}
andthen {IsFloat B}
then
D = {IntToFloat C}+B
elseif {IsFloat C}
andthen {IsInt B}
then
D = C+{IntToFloat B}
else D = C+B end
{Access A}
end
end
]]>
<![CDATA[
NewtonScript foo := func (n)
func (i)
n := n + i ;
]]>
<![CDATA[
Perl 5 sub foo {
my ($n) = @_;
sub {$n += shift}
}
]]>
<![CDATA[
Python class foo:
def __init__(self, n):
self.n = n
def __call__(self, i):
self.n += i
return self.n
]]>
<![CDATA[
Rebol foo: func [ n ]
[ func [ i ] [ n: n + i ] ]
]]>
<![CDATA[
Ruby def foo (n)
lambda {|i| n += i } end
]]>
<![CDATA[
Smalltalk foo: n
|s|
s := n.
^[:i| s := s + i. ]
]]>
<![CDATA[
VBScript Class acc
Private n
Public Default Function inc(i)
n = n + i
inc = n
End Function
End Class
]]><![CDATA[
Function foo(n)
Dim bar
Set bar = New acc
bar(n)
Set foo = bar
End Function
]]>
Some languages are not represented here, either because you
can't write this program in them (short of Greenspun's Tenth Rule)
or because no one has yet sent me the code for that language.
Please don't send may any new submissions for the time being; I
don't have time to look at them.
Credits: C++, Brendan Corfman and Daniel Cowgill;
Dylan, Neel Krishnaswami; E, Darius Bacon;
Erlang, Heinz Eriksson; Goo, Jonathan Bachrach; Haskell, Malcolm Wallace
and Tom Pledger;
Javascript, Anton van Straaten; Lua, Chris Laurel; Maple, Stefan Vorkoetter;
Mathematica, Kovas Boguta;
Mozart, Kari Pahula; NewtonScript, Sean Luke;
Perl, Dan Giffin and Trevor Blackwell; Python, Jeremy Hylton;
Rebol, Andreas Bolka;
Ruby, Stephan Schmidt;
Smalltalk, Trevor Blackwell; VBScript, Stefan Holm.
|
|