Accumulator factory: Difference between revisions

:# 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.

<br><br>

 

=={{header|8th}}==

\ RossetaCode 'accumulator factory'

 

\ results 11,13,16:

( +10 . cr ) 1 3 loop

 

{{out}}

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

 

=={{header|Aime}}==

{

l[0] = l[0] + o;

 

0;

{{Out}}

<pre>8.3</pre>

The type is properly preserved over summing:

 

f(-6);

f(-6.6);

f(4.2);

{{Out}}

<pre>integer: 6

{{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)

 

 

Or, to match the task spec and output a little more closely:

 

set x to foo(1)

end |λ|

end script

{{Out}}

<pre>8.3</pre>

=={{header|Argile}}==

{{works with|Argile|1.1.1}}

 

let A = accumulator 42

Accumulator.suffix

 

 

=={{header|Astro}}==

n => sum += n

 

print f(5) # 10

print f(10) # 20

 

=={{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 sharp|C#}}==

{{works with|C sharp|4.0}}

 

class Program

Console.WriteLine(x(2.3));

}

 

=={{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>

 

=={{header|Crystal}}==

# Make types a bit easier with an alias

alias Num = Int32 | Int64 | Float32 | Float64

puts x.call(10) #=> 20

puts x.call(2.4) #=> 22.4

 

=={{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|Delphi}}==

{{libheader| System.SysUtils}}

{{libheader| System.Variants}}

program Accumulator_factory;

 

Writeln(x(2.3));

Readln;

=={{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}}==

 

accumulator(n)

console.write(x(2.3r))

{{out}}

<pre>

=={{header|Elixir}}==

Elixir provides Agents to simplify creating a process to maintain state where mutable variables aren't allowed.

def new(initial) do

{:ok, pid} = Agent.start_link(fn() -> initial end)

end

end

The passing test to exercise the Accumulator and show usage:

 

defmodule AccumulatorFactoryTest do

assert foo.(2.3) == 8.3

end

 

{{out}}

 

Randomized with seed 587000

</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>

=={{header|F Sharp|F#}}==

A statically typed version is not possible, but it is quite easy to write dynamically typed functions in F#:

let add (x: obj) (y: obj) =

match x, y with

printfn "%A" (x 5) // prints "6"

acc 3 |> ignore

 

Actually, it is possible to create a statically typed version by using an inline accumulator creation function.

let acc = ref init

fun i ->

acc 5.0 |> ignore

let _ = makeAccumulator 3 // create an unused integer accumulator

{{out}}

<pre>8.3</pre>

 

=={{header|Factor}}==

:: accumulator ( n! -- quot ) [ n + dup n! ] ;

 

[ 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

 

The idiomatic way to deal with floats is to have a float version of this code; for a mixture of integers and floats, you decide at the start to use a float accumulator, and convert integers to floats explicitly:

 

: faccumulator ( r "name" -- )

create falign f,

3 s>f faccumulator y \ unused

2.3e x f.

 

=={{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>

 

Probably the best we can do is for 'foo' to return the object and then to call the method 'g' directly on that:

 

' uses overloaded methods to deal with the integer/float aspect (long and single are both 4 bytes)

Print

Print "Press any key to quit"

 

{{out}}

=={{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|Golo}}==

----

An accumulator factory example for Rosetta Code.

println(acc(10))

println(acc(100.101))

 

=={{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>

 

'''Note''' The <code>accumulator</code> function could be written in applicative style:

 

=={{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>

 

=={{header|Io}}==

block(x, sum = sum + x) setIsActivatable(true)

)

x(5)

accumulator(3)

 

=={{header|J}}==

a=. cocreate''

n__a=: m

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

Example use:

F 11

21

33

F 11

 

=={{header|Java}}==

 

{{works with|Java|5 and up}}

//implements java.util.function.UnaryOperator<Number> // Java 8

{

}

}

{{out}}

<pre>8.3</pre>

 

{{works with|Java|8 and up}}

 

public class AccumulatorFactory {

System.out.println(x.apply(2.3));

}

 

=={{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)

=={{header|Jsish}}==

From Javascript ES5 entry.

function accumulator(sum) {

return function(n) {

x(5) ==> 17.3

=!EXPECTEND!=

 

{{out}}

{{works with|Julia|0.6}}

 

f(n) = i += n

return f

 

accumulator(3)

 

{{out}}

=={{header|Kotlin}}==

Overloads would be needed for all six primitive numeric types but, in the interests of brevity, only two overloads of 'foo' have been coded:

 

fun foo(n: Double): (d: Double) -> Double {

foo(5)

println(y(2))

 

{{out}}

=={{header|Lambdatalk}}==

Lambdatlk is a functional programming language without closures but with mutable arrays.

{def acc

-> acc

 

 

=={{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|M2000 Interpreter}}==

\\ accumulator factory

foo=lambda acc=0 (n as double=0) -> {

print ExpType$(x(0@))="Decimal"

print ExpType$(x())="Double"

 

=={{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>

2. this likely violates some hidden taste requirements of the task, as used by Paul Graham to dismiss Forth solutions. Certainly, this is not really an example of Mercury that anyone would want to use in a Mercury project.

 

:- interface.

 

!SF ^ elem(Size) := univ(M),

impure set_states(!.SF)

 

As used:

 

:- interface.

:- import_module io.

impure R2 = impure_apply(G, -50.0),

io.format("%d, %d\n", [i(N1), i(N2)], !IO),

 

{{out}}

2. This doesn't return a closure with mutable state, but the state itself, which the caller can thread through rules that apply to them.

 

:- interface.

 

 

bump(X, N, N0, N) :-

 

As used, with the same output:

 

:- interface.

:- import_module io.

),

io.format("%d, %d\n", [i(N1), i(N2)], !IO),

 

=={{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}}

 

=={{header|NGS}}==

F Acc(start:Int) {

sum = start

echo(acc(5))

echo(acc(2))

{{out}}

<pre>15

Argument to the created accumulator function must be float.

Result is always float.

proc accumulator[T: SomeNumber](x: T): auto =

var sum = float(x)

discard accumulator(3) # Create another accumulator.

echo acc(2.3) # 8.3

 

{{out}}

Argument to the accumulator function must be of the same type.

Result of the accumulator function is also of the same type.

proc accumulator[T: SomeNumber](x: T): auto =

var sum = x

echo y(2) # 5.5

echo y(3) # 8.5

{{out}}

<pre>

 

This solution fulfills the requirements.

type

 

discard accumulator(3) # Create another accumulator.

echo acc(2.3) # 8.3

 

{{out}}

Source: [https://github.com/nitlang/nit/blob/master/examples/rosettacode/accumulator_factory.nit the official Nit repository]

 

#

# Nit has no first-class function.

x.call(5)

var y = new Accumulator(3)

 

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}}==

The block returned by foo (a closure), when performed, retrieves the current value from the closure parameter, adds the top of stack, and stores the result back to the closure's parameter. The result is dup, so it is also returned.

 

 

Usage :

| x y z |

1 foo ->x

"aaa" foo ->z

"bbb" z perform dup . ", z accumulator value is a" . class .cr

 

{{out}}

=={{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}}==

=={{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|PARI/GP}}==

 

factory(b,c=0) = my(a=stack[1]++);listput(stack,c);(b)->stack[a]+=b;

 

 

Run the factory:<pre>gp > x = foo(1);

 

{{trans|Ruby}}

my $sum = shift;

sub { $sum += shift }

$x->(5);

accumulator(3);

{{out}}

<pre>8.3</pre>

accumulators being visible (??) I suppose you could always just allocate a bit of memory in

accumulator_factory() and return a pointer to that instead of an id/length.

 

 

{{out}}

<pre>

 

=={{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|Pony}}==

 

use "assert"

class Accumulator

r(F64(5.5))

env.out.print("This is okay..." + r().string())

 

=={{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|PowerShell}}==

 

The GetNewClosure method returns a ScriptBlock with captured variables.

function Get-Accumulator ([double]$Start)

{

{param([double]$Plus) return $script:Start += $Plus}.GetNewClosure()

}

$total = Get-Accumulator -Start 1

& $total -Plus 5.0 | Out-Null

& $total -Plus 2.3

{{Out}}

<pre>

{{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|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2018.03}}

 

#Example use:

 

my &b = accum 5;

 

=={{header|REBOL}}==

use [state] [

state: start-val

]

]

{{out}}

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

Retro only supports integers.

 

{{out}}

<pre> #10 'foo acc

This REXX program is partially modeled after the ooRexx example.

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

x=.accumulator(1) /*initialize accumulator with a 1 value*/

x=call(5)

return sum

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output'''

<pre>

 

=={{header|Ring}}==

 

Func main

return aN[#id#]

}

 

{{out}}

6

8.30

</pre>

 

Ruby deviates from the task because methods and Proc objects have different syntax. So, <tt>x = accumulator(1)</tt> is valid, but <tt>x(5)</tt> is an error: the syntax must be <tt>x.call(5)</tt> or <tt>x[5]</tt> (with square brackets). Ruby 1.9 also allows <tt>x.(5)</tt> (with an extra dot).

 

lambda {|n| sum += n}

end

x.call(5)

accumulator(3)

 

The output of <tt>p accumulator(3)</tt> looks like

This accumulator also works with other types that have a <tt>+</tt> method.

 

require 'complex'

y = accumulator(Rational(2, 3))

require 'matrix'

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

 

If we define x as a method of self, then the syntax <code>x(5)</code> works, but we deviate more from the task, because x might get "inadvertently modified" by other methods of self.

 

lambda {|n| sum += n}

end

x(5)

accumulator(3)

 

=={{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;

foo(3.);

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

{{out}}

<pre>

=== Over-engineered Solution ===

This solution uses a custom number type that can be either an i64 or f64. It also creates a generic struct that is callable using the unstable fn traits, which can be called to add anything that can be added to it's accumulator value.

#![feature(unboxed_closures, fn_traits)]

 

s(" ");

println!("{}", s("code"));

{{out}}

<pre>8.3

=={{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|Simula}}==

 

! ABSTRACTION FOR SIMULA'S TWO NUMERIC TYPES ;

 

END.

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

AccumulatorFactory class >> new: aNumber [

|r sum|

(x value: 2.3) displayNl.

"x inspect."

 

the above can also be done without a class to hold the block, simply by putting it into another block (i.e. an outer closure for the sum, returning an inner function which updates that sum):

 

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|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])

Note: The co-expression calling sequence used is Unicon specific.

{{out}}

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:

 

=={{header|Wren}}==

 

var x = accumulator.call(1)

x.call(5)

accumulator.call(3)

 

{{out}}

With some extra work, floating point numbers can be incorporated, but outputting would be trickier.

 

; Accumulator factory

; Returns a function that returns the sum of all numbers ever passed in

output: ; Holds the output buffer

resb 11

 

Output

=={{header|XLISP}}==

There are probably other ways of doing it, but this is one way.

(lambda (n)

(setq x (+ n x))

Test it in a REPL:

<pre>[1] (define f (accumulator 1))

 

=={{header|Yabasic}}==

local f$

foo$(3)

print execute(x$, 2.3)

 

=={{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}}