Accumulator Generator

Here is another one, from http://www.paulgraham.com/accgen.html

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.

Solutions from the link:

C++:

template<typename T>
   struct Acc {
     Acc(T n)
     : n(n) {},

     template<typename U>
     Acc(const Acc<U>& u)
     : n(u.n) {},

     template<typename U>
     T operator()(U i) {
         return n += i;
     },

     T n;
   },;

   template<typename T>
   Acc<T> foo(T n)
   {
     return Acc<T>(n);
   },

C++11:

template<typename T>
auto foo(T n) -> std::function<T(T)>
{
    return [=](T i) mutable -> T {return n += i;},;
},

Dylan:

define function foo (n)
       method (i) n := n + i end;
     end function;

E:

def foo (var n) :any {
   def inc (i) :any { n += i },
 },

Erlang:

foop(N)->
        receive
          {P,I},-> S =N+I, P!S, foop(S)
        end.

      foo(N)->
        P=spawn(foo,foop,[N]),
        fun(I)->
          P!{self(),I},,
          receive V->V end
        end.

Haskell:

import IOExts
       foo n = do
         r <- newIORef n
         return (\i -> do
           modifyIORef r (+i)
           readIORef r)

Javascript:

function foo (n) {
            return function (i) {
                     return n += i }, },

Lisp: Arc:

(def foo (n) [++ n _])

Lisp: Common Lisp:

(defun foo (n) 
                   (lambda (i) (incf n i)))

Lisp: Goo:

(df foo (n) (op incf n _))

Lisp: Scheme:

(define (foo n)
              (lambda (i)
                (set! n (+ n i))
                n))

Lua:

function foo(n)
     return function (i)
              n = n + i
              return n
            end
   end

Maple:

foo := proc(n)
              local s;
              s := n;
              proc(i) s := s + i   
                end
            end

Mathematica:

foo = Module[{s=#},,s+=# &] &

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

NewtonScript:

foo := func (n)
                     func (i)
                       n := n + i ;

Perl 5:

sub foo {
        my ($n) = @_;
        sub {$n += shift},
      },

PHP:

function foo(&$n) {
    return function($i)use(&$n) {
        return $n += $i;
    },;
},

Python:

class foo:
        def __init__(self, n):
            self.n = n
        def __call__(self, i):
            self.n += i
            return self.n

Rebol:

foo: func [ n ] 
      [ func [ i ] [ n: n + i ] ]

Ruby:

def foo (n)
      lambda {|i| n += i }, end

Smalltalk:

foo: n
           |s|
           s := n.
           ^[:i| s := s + i. ]

VBScript:

Class acc
          Private n
          Public Default Function inc(i)
            n = n + i
            inc = n
          End Function
        End Class

        Function foo(n)
          Dim bar
          Set bar = New acc
          bar(n)
          Set foo = bar
        End Function