Accumulator factory: Difference between revisions

A problem posed by [[wp:Paul Graham|Paul Graham]] is that of creating a function that takes a single (numeric) argument and which returns another function that is an accumulator. The returned accumulator function in turn also takes a single numeric argument, and returns the sum of all the numeric values passed in so far to that accumulator (including the initial value passed when the accumulator was created).

 

The detailed rules are at http://paulgraham.com/accgensub.html and are reproduced here for simplicity (with additions in <small>''small italic text''</small>).

:Before you submit an example, make sure the function

:# Doesn't store the accumulated value or the returned functions in a way that could cause them to be inadvertently modified by other code. <small>''(No global variables or other such things.)''</small>

: E.g. if after the example, you added the following code (in a made-up language) <small>''where the factory function is called foo''</small>:

x(5);

foo(3);

: It should print <tt>8.3</tt>. <small>''(There is no need to print the form of the accumulator function returned by <tt>foo(3)</tt>; it's not part of the task at all.)''</small>

 

Where it is not possible to hold exactly to the constraints above, describe the deviations.

 

=={{header|ABAP}}==

Another possible solution would be to use the languages in-built JavaScript processing capabilities to dynamically construct a JS source at run-time, which implements the JS Accumulator factory.

=== Object Oriented Solution ===

class acc definition.

public section.

cl_acc->call( exporting iv_i = '2.3' importing ev_r = lv_ret2 ).

cl_acc->call( exporting iv_i = 2 importing ev_r = lv_ret1 ).

{{out}}

<pre>

</pre>

=== JavaScript Solution ===

cl_processor type ref to cl_java_script,

lv_ret type string.

write lv_ret.

write / 'Done'.

 

<pre>#function (n) {# return sum += n;#}#8.3</pre>

Closures work the same in ActionScript as in JavaScript. ActionScript will transparently convert integers to reals if the function is given a real argument, but the typeof operator must be used to ensure the function isn't sent invalid arguments, such as strings (which would silently convert the accumulated number to a string without throwing an error).

{{trans|Javascript}}

// "number" for both integers and reals)

function checkType(obj:Object):void {

trace(acc(10));

trace(acc(4));

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

 

Put_Line (Integer'Image (B.The_Function (3)));

Put_Line (Float'Image (A.The_Function (2.3)));

 

 

-- This Ada generic package represents an accumulator factory.

function The_Function (X : Integer) return Float;

function The_Function (X : Float) return Float;

 

 

-- The accumulator lives through three states. It is in Virgin_State

end;

 

 

=={{header|Aikido}}==

{{trans|Javascript}}

return function(n:real) { return sum += n }

}

x(5)

println (accumulator)

{{out}}

accumulator

8.3

 

=={{header|ALGOL 68}}==

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

Note: Standard ALGOL 68's scoping rules forbids exporting a '''procedure''' (or '''format''') out of it's scope (closure). Hence this specimen will run on [[ELLA ALGOL 68]], but is non-standard. For a discussion of first-class functions in ALGOL 68 consult [http://www.cs.ru.nl/~kees/home/papers/psi96.pdf "The Making of Algol 68"] - [[wp:Cornelis_H.A._Koster|C.H.A. Koster]] (1993). <!-- Retrieved April 28, 2007 -->

 

PROC plus = (NUMBER in a, in b)NUMBER: (

print(("x:",x(0), new line))

 

{{out}}

<pre>

This has one deviation. AppleScript needs a script object for the closure on the sum <code>n</code>. So this factory returns a script object, not a handler by itself. One must call the handler through its script object, as in <code>x's call(1)</code>.

 

-- Returns a new script object

-- containing a handler.

log y's call(2)

log x's call(3.5)

 

=={{header|Argile}}==

{{works with|Argile|1.1.1}}

 

let A = accumulator 42

Accumulator.suffix

 

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

This code works by copying the function FNdummy() onto the heap and returning a pointer to it.

dummy = FN(x)(5)

dummy = FNaccumulator(3)

PRIVATE sum

sum += n

 

=={{header|Bracmat}}==

=

.

& accumulator$3

& out$(x$23/10)

Output:

<pre>83/10</pre>

=={{header|Brat}}==

{ n | sum = sum + n }

}

x 5

accumulator 3 #Does not affect x

 

=={{header|C}}==

Deviation: Not in standard C, but several compilers include the typeof operator as an extension which can be used like a typedef. Functions must be defined outside of the main program body and they retain the same type throughout their life. C11 is supposed to give us some Type-generic macro expressions.

 

//~ Take a number n and return a function that takes a number i

#define ACCUMULATOR(name,n) __typeof__(n) name (__typeof__(n) i) { \

printf ("%c\n", z(5)); /* f */

return 0;

 

=={{header|C++}}==

First solution has a deviation: The return type is wrong when the accumulator is called with an integer argument after is has been called with a float argument. Later it is explained how to correct this.

 

 

class Acc

std::cout << a(2.3f);

return 0;

{{works with|C++11}}

The following is similar to the above, using lambda functions from C++11. Note that we declared the lambda <code>mutable</code>, which allows us to modify variables that were captured by value. This feature allows us to maintain mutable state, which is essential for an accumulator.

 

It suffers from the same deviation as the former, where the return type is wrong when the accumulator is called with a float argument after is has been called with an integer argument.

#include <functional>

 

std::cout << acc(2.3) << std::endl;

return 0;

 

The deviation stems from two sources. First, a C++ object (such as the accumulator) has an immutable type. To correct this, we must separate the accumulator from the cumulant value it holds. For example:

{

virtual ~CumulantBase_();

template<class T_> Accumulator_(const T_& val) { Set(val); }

template<class T_> void Set(const T_& val) { val_.reset(new Cumulant_<T_>(val)); }

(This is Coplien's "State" pattern.)

 

The second issue is that the built-in operator + is a multimethod, implementing a compile-time dispatch and promotion which we must manually reproduce.

// various operator() implementations provide a de facto multimethod

Accumulator_& operator()(int more)

}

};

 

These rely on coercion functions which switch on the so-far-accumulated type:

boost::optional<int> CoerceInt(const CumulantBase_& c)

{

return boost::optional<String_>();

}

 

All that remains is to write to the stream:

{

return acc.val_->Write(dst);

}

 

=={{header|Ceylon}}==

Integer|Float accumulator

(variable Integer|Float n)

print(accumulator(3));

print(x(2.3));

 

{{out}}

=={{header|Clay}}==

To my knowledge Clay does not admit of an elegant solution to this problem, although it should be stated that I am still exploring the language. But a clean solution mirroring that for other static languages is quite simple (one in which the operative numeric type is constrained by the original call to acc):

return (m) => {

n = n + m;

acc(3);

println(x(2.3)); // Prints “8.300000000000001”.

Although statically typed, due to Clay’s everywhere-genericity this has the advantage of working out of the box for any type that defines addition:

But you could constrain the function to numeric types were you so inclined:

return (m) => {

n = n + m;

return n;

};

One could go crazy with tagged unions and runtime dispatching to rig something up that adhered more closely to the problem’s specification. But I know of no easier way to “change types” in the fashion necessary.

 

=={{header|Clojure}}==

The ''atom'' function creates an atomically updatable identity holding a value. The ''swap!'' function atomically updates the atom's value, returning the new value. The function returned from an ''accum'' call satisfies all the requirements.

(let [acc (atom n)]

Similarly, a ''ref'' could be used.

(let [acc (ref n)]

 

=={{header|CoffeeScript}}==

(n) -> sum += n

f = accumulator(1)

console.log f(5)

 

=={{header|Common Lisp}}==

{{trans|TXR}}

(lambda (n)

Example usage:

(funcall x 5)

(accumulator 3)

{{out}}

<pre>

8.3

</pre>

 

=={{header|D}}==

 

 

void main() {

auto accum = cast(U)initvalue ;

return (U n) { return accum += n ; } ;

 

=={{header|Dart}}==

 

 

 

 

 

 

{{out}}

 

=={{header|Déjà Vu}}==

labda i:

set :n + n i

drop x 5

drop accum 3

 

=={{header|E}}==

return fn y { x += y }

 

=={{header|EchoLisp}}==

(define-syntax-rule (inc x v) (set! x (+ x v)))

(define (accumulator (sum 0)) (lambda(x) (inc sum x) sum))

 

(x 2.3) → 8.3

 

=={{header|Elena}}==

 

 

{

{{out}}

<pre>

8.3

</pre>

 

=={{header|Erlang}}==

Erlang doesn't allow for mutable variables, but does have variable capture in closures. By spawning a process which loops endlessly, incrementing the sum and returning it to the caller, this mutable state can be imitated.

-module(acc_factory).

-export([loop/1,new/1]).

end

end.

 

=={{header|ERRE}}==

 

PROCEDURE ACCUMULATOR(SUM,N,A->SUM)

ACCUMULATOR(Z,2.3,TRUE->Z)

PRINT(X,Z)

{{out}}

<pre>

-11.7 10.3

</pre>

 

=={{header|Factor}}==

 

1 accumulator

[ 5 swap call drop ]

[ drop 3 accumulator drop ]

 

=={{header|Fantom}}==

The accumulator function is a little unwieldy using multiple ifs to maintain the type of 'sum' until forced to change. Again, a result of the three concrete Num types, Int, Float and Decimal, all being separated in the API.

{

static |Num -> Num| accumulator (Num sum)

echo (x(2.3)) // the Int sum is now a Decimal

}

 

=={{header|Forth}}==

Forth is untyped; this works on integers.

create ( n -- ) ,

does> ( n -- acc+n ) tuck +! @ ;

1 foo . \ 1

2 foo . \ 3

 

 

 

 

=={{header|Fortran}}==

in Fortran77 but was accepted by virtually all compilers.

 

typex function g(i);\

typex i,s,n;\

print *, y(2)

stop

{{out}}

<pre>

Fortran2003 and later supports objects and overloading. The overloaded functions are encapsulated in an object.

 

module modAcc

implicit none

itemp = y%fun(5)

print *, y%fun(2)

{{out}}

<pre>

8.3000000000000007

10

</pre>

 

=={{header|Go}}==

Small deviation on condition 2. The task specifies to handle all numeric types, and only int and float64 are shown here. The technique would extend to all types just as easily, but Go has lots of numeric types and the program would be big.

 

import "fmt"

accumulator(3)

fmt.Println(x(2.3))

{{out}}

<pre>8.3</pre>

 

=={{header|Groovy}}==

Solution:

def value = n;

{ it = 0 -> value += it}

Test:

 

println x()

 

println y(2.25D)

{{out}}

<pre>1

=={{header|Haskell}}==

{{trans|Ruby}}

import Data.STRef

 

x 5

accumulator 3

{{out}}

<pre>8.3</pre>

 

=={{header|Icon}} and {{header|Unicon}}==

 

Strictly speaking, <tt>genAcc(n)</tt> returns a <i>co-expression</i>, not a function. However, the invocation syntax here is indistinguishable from calling a function.

a := genAcc(3)

b := genAcc(5)

procedure makeProc(A) # A Programmer-Defined Control Operation

return (@A[1],A[1])

This example produces the output:

<pre>

</pre>

To adapt the above for use in Icon, the function-syntax for activating co-expressions (e.g. <tt>a(4)</tt>) available in Unicon would have to be replaced with the <i>activation</i> operator (e.g. <tt>[4]@a</tt>). The use of a list as the value passed through activation is to retain compatibility with the Unicon approach.

 

=={{header|J}}==

a=. cocreate''

n__a=: m

a&(4 : 'n__x=: n__x + y')

Example use:

F 11

21

33

F 11

 

=={{header|Java}}==

}

 

}

}

 

public static void main(String[] args) {

}

 

 

public class AccumulatorFactory {

 

 

 

}

public static void main(String[] args) {

}

 

=={{header|JavaScript}}==

===ES5===

return function(n) {

return sum += n;

x(5);

console.log(accumulator(3).toString() + '<br>');

{{out}}

<pre>function (n) { return sum += n; }

 

===ES6===

let x = accumulator(1);

console.log(x(5));

accumulator(3);

{{out}}

<pre>6

 

===JavaScript 1.8 (SpiderMonkey Only)===

var x = accumulator(1);

x(5);

console.log(accumulator(3).toSource());

{{out}}

<pre>(function (n) sum += n)

8.3</pre>

 

=={{header|Julia}}==

f(n) = i += n

end

x = accumulator(1)

accumulator(3)

 

 

 

 

 

=={{header|LFE}}==

=== Traditional closure ===

 

(defun accum (m)

(lambda (n)

`(#(func ,(accum sum))

#(sum ,sum)))))

 

Since we want to use both the returned function as well as the data for the call, we return a tuple containing both. Using standard LFE pattern matching, we can extract these.

We can creating a looping process which provides the same functionality as the self-calling function in the "traditional closure" approach:

 

(defun loop (m)

(receive

(receive

(sum sum)))))

 

Usage (in the REPL):

=={{header|Lua}}==

A simple implementation:

init = init or 0

return function(delta)

return init

end

An expanded example of similar but more complex functionality:

{{works with|Lua|5.1}}

local accSum = 0; -- accumulator factory 'upvalue'

function acc(v) -- the accumulator factory

end--acc

Usage example:

x(5) -- add 5 to x's sum

acc(3) -- add 3 to factory's sum

print (x(2.3)) --> 8.3 -- add 2.3 to x's sum then print the result

y = acc() -- create new function with factory's sum as initial value

 

=={{header|Maple}}==

This creates a procedure closed over the local variable total in the factory procedure. The initial value, if not passed to the factory procedure, is taken to be 0 and, if the generated accumulator is given no value, it increments the total by 1.

local total := initial;

proc( val := 1 ) total := total + val end

Running this, we get:

> acc( 5 );

6

 

> acc( I ); # add the imaginary unit

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Module[{total = initial},

Function[x, total += x]

x[5.0];

accFactory[3];

{{out}}

<pre>8.3</pre>

 

=={{header|Nemerle}}==

Nemerle doesn't have a <tt>dynamic</tt> type, but we can use matching to bind types to <tt>object</tt>s.

mutable value : object = n;

fun (i : object) {

x(5);

System.Console.WriteLine(x(2.3));

Output:

<pre>8.3

 

=={{header|NewLisp}}==

 

{{out}}

>

</pre>

 

=={{header|Nim}}==

 

 

 

Output:

 

=={{header|Objeck}}==

Uses objects instead of first class functions.

class Accumulator {

@sum : Float;

}

}

 

=={{header|Objective-C}}==

{{works with|Mac OS X|10.6+}}

 

typedef double (^Accumulator)(double);

}

return 0;

{{out}}

<pre>8.300000</pre>

{{trans|Ruby}}

Deviations: An accumulator instance can take ''either'' integers ''or'' floats, but not both mixed (due to lack of runtime polymorphism).

let sum = ref sum0 in

fun n ->

let _ = accumulator 3.0 in

Printf.printf "%g\n" (x 2.3)

{{out}}

<pre>8.3</pre>

=={{header|Octave}}==

 

1;

function fun = foo(init)

x(5);

foo(3);

 

=={{header|Oforth}}==

Oforth can only returns blocks, not functions, but a block can be used wherever a function is used.

 

 

 

Usage :

| x y z |

5 x perform .

 

{{out}}

<pre>

>testfoo

ok</pre>

 

=={{header|ooRexx}}==

ooRexx does not have functions that can maintain state between calls. The standard work around is to use an object instance and a defined method name.

x = .accumulator~new(1) -- new accumulator with initial value of "1"

x~call(5)

return sum

 

 

=={{header|OxygenBasic}}==

del af : del a : del b : del c

</pre>

 

=={{header|Oz}}==

A bit unwieldy because the '+' operator does not allow mixed type operands. The implementation is thread-safe (atomic Exchange operation).

fun {Acc Init}

State = {NewCell Init}

{X 5 _}

{Acc 3 _}

 

=={{header|Perl}}==

{{trans|Ruby}}

my $sum = shift;

sub { $sum += shift }

my $x = accumulator(1);

$x->(5);

{{out}}

 

 

=={{header|PHP}}==

function accumulator($start){

return create_function('$x','static $v='.$start.';return $v+=$x;');

echo $acc(5), "\n"; //prints 10

echo $acc(10), "\n"; //prints 20

{{works with|PHP|5.3+}}

function accumulator($sum){

return function ($x) use (&$sum) { return $sum += $x; };

echo $acc(5), "\n"; //prints 10

echo $acc(10), "\n"; //prints 20

 

=={{header|PicoLisp}}==

(curry (Sum) (N)

(inc 'Sum N) ) )

(a 1) # Output: -> 8

(a 2) # Output: -> 10

 

=={{header|PostScript}}==

{0 add 0 0 2 index put}

7 array copy

dup 100 exch exec = % add 100 to 13.14, print it

12 a = % add 12 to 8.71, print it

 

=={{header|Prolog}}==

{{works with|SWI Prolog}}

Uses the module '''lambda''' written by '''Ulrich Neumerkel'''.

 

define_g(N, G) :-

writeln(S),

call(G, 2.3, R1),

{{out}}

<pre>8 ?- accumulator.

=={{header|Python}}==

{{works with|Python|2.x/3.x}}

def f(n):

f.sum += n

8.3000000000000007

>>> x2(0)

 

{{trans|Ruby}}

{{works with|Python|3.x}}

def f(n):

nonlocal sum

x(5)

print(accumulator(3))

{{out}}

<pre><function f at 0xb7c2d0ac>

 

{{works with|Python|2.5+}}

while True:

sum += yield sum

x.send(5)

print(accumulator(3))

{{out}}

<pre><generator object accumulator at 0x106555e60>

8.3</pre>

 

=={{header|R}}==

currentSum <- init

function(add) {

currentSum

}

{{out}}

<pre>

 

=={{header|Racket}}==

(define ((accumulator n) i)

(set! n (+ n i))

n)

 

=={{header|REBOL}}==

use [state] [

state: start-val

]

]

{{out}}

<pre>>> x: make-acc-gen 1

=={{header|Retro}}==

Retro only supports integers.

 

 

 

 

=={{header|REXX}}==

<br><br>This example will handle any kind of number: integer, floating point.

x=call(5)

x=call(2.3)

return sum

'''output'''

<pre>

 

=={{header|Ring}}==

 

Func main

return aN[#id#]

}

 

{{out}}

6

8.30

</pre>

 

=={{header|Ruby}}==

lambda {|n| sum += n}

end

x = accumulator(1)

x.call(5)

 

require 'complex'

y = accumulator(Rational(2, 3))

 

t = accumulator(Time.utc(1999, 8, 7, 6, 5))

 

require 'matrix'

m = accumulator(Matrix[[1, 2], [3, 4]])

 

=={{header|Rust}}==

Changing "x = foo(1.)" to "x = foo(1)" in the code below should not change the output (it does).

 

 

use std::ops::Add;

 

where Num: Add<Output=Num> + Copy + 'static {

let mut acc = n;

acc = acc + i;

acc

}

 

foo(3.);

println!("{}", x(2.3));

{{out}}

<pre>

8.3

</pre>

 

=={{header|Scala}}==

The type of a function can't change in Scala, and there is no "numeric" type that is a supertype of all such types. So, if the accumulator is declared as integer, it can only receive and return integers, and so on.

import num._

var acc = n

acc

}

{{out|Sample}}

<pre>

=={{header|Scheme}}==

{{trans|Ruby}}

(lambda (n)

(set! sum (+ sum n))

(x 5)

(display (accumulator 3)) (newline)

{{out}}

<pre>#<procedure>

 

=={{header|Sidef}}==

method add(num) {

sum += num;

x.add(5);

Accumulator(3);

 

The same thing can be achieved by returning a closure from the '''Accumulator''' function.

 

func(num) { sum += num };

}

x(5);

Accumulator(3);

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

AccumulatorFactory class >> new: aNumber [

|r sum|

(x value: 2.3) displayNl.

"x inspect."

 

 

factory := [:initial |

].

 

 

=={{header|Standard ML}}==

{{trans|OCaml}}

Deviations: An accumulator instance can take ''either'' integers ''or'' reals, but not both mixed (due to lack of runtime polymorphism).

val sum = ref sum0

in

in

print (Real.toString (x 2.3) ^ "\n")

{{out}}

<pre>8.3</pre>

 

=={{header|Swift}}==

return {

sum += $0

x(5)

let _ = makeAccumulator(3)

{{out}}

<pre>8.3</pre>

{{works with|Tcl|8.6}}

This uses nested [[wp:coroutine|coroutine]]s to manage the state, which for the outer coroutine is a counter used to generate unique instances of the inner coroutine, and for the inner coroutine it is the actual accumulator variable. Note that Tcl commands (including coroutines) are ''never'' nameless, but it is trivial to synthesize a name for them. It's possible to guarantee uniqueness of names, but just using a simple sequence generator gets 90% of the effect for 10% of the effort.

 

# make the creation of coroutines without procedures simpler

} $n

}

Sample usage (extra characters over Paul's example to show more clearly what is going on):

::accumulator.1

% $x 5

::accumulator.2

% puts ">>[$x 2.3]<<"

 

=={{header|TXR}}==

===Verbose===

 

(lambda (n)

(inc sum n)))

((set num (iread : : nil)))

((format t "~s -> ~s\n" num [f num])))

 

{{out|Run}}

===Sugared===

 

{{out}}

<pre>$ echo "1 2 3 4.5" | txr accumulator-factory2.tl

Using the <code>obtain</code>/<code>yield</code> interface to delimited continuations, we can turn an imperative for loop into an accumulation function:

 

(for ((sum (yield-from accum)))

()

 

(let ((f (obtain (accum))))

{{out}}

<pre>$ echo "1 2 3 4.5" | txr accumulator-factory2.tl

OOP languages can use objects to simulate closures. In particular, function-objects which can be called as if they were functions, without any visible method being referenced. TXR Lisp supports functors as an expression of irony in language design. A structure object for which a method named <code>lambda</code> is defined can be used as function. Arguments applied to the objects are applied to lambda, preceded by the object itself as the leftmost argument:

 

(count 0))

 

;; the construction of the function object bound to variable f.

(let ((f (new (accum 0))))

 

=={{header|UNIX Shell}}==

The shell is a bad choice for this task. This example plays tricks with <tt>eval</tt>. The difficulty with <tt>eval</tt> is to put the quotation marks " and dollar signs <tt>$</tt> in the correct place, and escape them with the correct number of backslashes \. One missing (or one extra) backslash can ruin the entire program.

{{works with|pdksh}}

accumulator() {

# Define a global function named $1

echo $r

y r -3000

{{out}}

<pre>$ sh accumulator.sh

==={{header|es}}===

A better shell for this task is ''es'', because it has lexical variables and closures. <code>@ i {code}</code> is a lambda with parameter ''i'', and <code>fn accumulator n {code}</code> is sugar for <code>fn-accumulator = @ n {code}</code>.

result @ i {

n = `{echo $n + $i | bc}

fn-y = <={accumulator 3}

echo <={x 2.3}

 

=={{header|VBScript}}==

I'm not entirely convinced that this is actually doing what is asked. A VBScript guru I'm not. The answer's right, though.

;Implementation

dim A

public default function acc(x)

accum = A

end property

;Invocation

set a = new accumulator

x = a( 1 )

set b = new accumulator

b 3

{{out}}

<pre>

 

=={{header|Wart}}==

 

Example usage:

(a)

=> 6</pre>

 

=={{header|Yorick}}==

Yorick cannot dynamically create new functions. Instead, the accum function can be called in two ways: directly, in which case its first argument is numerical; or through a closure, where its first argument is implicitly an object and the second is the user-provided argument. This example uses closures and group objects, which require Yorick 2.2 or later.

if(!is_obj(data))

return closure(accum, save(total=data));

save, data, total=data.total + n;

return data.total;

Example of use (interactive session):

<pre>> x = accum(1)

 

=={{header|zkl}}==

A strong reference (Ref) is used as the accumulator, a Ref acts like a one element list. The Ref is bound to the new functions second parameter with the .fp1 method.

<pre>

The output switches between int and float based on the most recent input: With addition, the first operand casts the second: int + int|float --> int and float + int|float --> float. If the desire is to make the behavior "once float, always float", a 0 or 0.0 can be used to start the sum and stashed in a another bit of state.

 

{{omit from|C}} <!-- C's type system imcompatible with task spec -->

{{omit from|ML/I}}