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

=={{header|11l}}==

T Accumulator

Float s

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

\ RossetaCode 'accumulator factory'

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.

</pre>

=== JavaScript Solution ===

cl_processor type ref to cl_java_script,

lv_ret type string.

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 {

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

end;</syntaxhighlight>

-- This Ada generic package represents an accumulator factory.

end;</syntaxhighlight>

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

=={{header|Aikido}}==

{{trans|Javascript}}

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

}

=={{header|Aime}}==

{

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

<pre>8.3</pre>

The type is properly preserved over summing:

f(-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: (

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.

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

set x to foo(1)

=={{header|Argile}}==

{{works with|Argile|1.1.1}}

let A = accumulator 42

autocast accumulator<->Accumulator</syntaxhighlight>

=={{header|Astro}}==

n => sum += n

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

=={{header|Bracmat}}==

Notice that Bracmat has no floating point numbers, only rational numbers.

=

.

=={{header|Brat}}==

{ n | sum = sum + n }

}

Ported from [[Ruby]].

𝕊 sum:

{sum+↩𝕩}

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

=={{header|C sharp|C#}}==

{{works with|C sharp|4.0}}

class Program

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

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>

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_();

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)

{

All that remains is to write to the stream:

{

return acc.val_->Write(dst);

=={{header|Ceylon}}==

Integer|Float accumulator

(variable Integer|Float n)

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

}</syntaxhighlight>

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:

println(y(" World!")); // Prints "Hello World!”.</syntaxhighlight>

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

return (m) => {

n = n + m;

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

(fn [m] (swap! acc + m))))</syntaxhighlight>

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

(let [acc (ref n)]

#(dosync (alter acc + %))))</syntaxhighlight>

=={{header|CoffeeScript}}==

(n) -> sum += n

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

{{trans|TXR}}

(lambda (n)

(incf sum n)))</syntaxhighlight>

Example usage:

(funcall x 5)

(accumulator 3)

=={{header|Crystal}}==

# Make types a bit easier with an alias

alias Num = Int32 | Int64 | Float32 | Float64

=={{header|D}}==

void main() {

Implementation with dynamic typing:

Implementation with static typing (preferred in Dart 2):

Accumulator makeAccumulator(num s) => (num n) => s += n;</syntaxhighlight>

Verbose version:

Accumulator makeAccumulator(num initial) {

Usage example for any of above:

var x = makeAccumulator(1);

x(5);

Type checking:

var x = makeAccumulator(1);

print(x(5).runtimeType); // int

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

labda i:

set :n + n i

{{libheader| System.SysUtils}}

{{libheader| System.Variants}}

program Accumulator_factory;

end.</syntaxhighlight>

=={{header|E}}==

return fn y { x += y }

}</syntaxhighlight>

=={{header|EchoLisp}}==

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

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

=={{header|Elena}}==

ELENA 4.x :

= (n => acc.append:n);

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

The passing test to exercise the Accumulator and show usage:

defmodule AccumulatorFactoryTest do

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

=={{header|ERRE}}==

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

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

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

let acc = ref init

fun i ->

=={{header|Factor}}==

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

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

=={{header|Forth}}==

Forth is untyped; this works on integers.

create ( n -- ) ,

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

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,

in Fortran77 but was accepted by virtually all compilers.

typex function g(i);\

typex i,s,n;\

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

module modAcc

implicit none

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)

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

=={{header|Golo}}==

----

An accumulator factory example for Rosetta Code.

=={{header|Groovy}}==

Solution:

def value = n;

{ it = 0 -> value += it}

}</syntaxhighlight>

Test:

println x()

=={{header|Haskell}}==

{{trans|Ruby}}

import Data.STRef

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

where factory s n = modifySTRef s (+ n) >> readSTRef s</syntaxhighlight>

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)

=={{header|Io}}==

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

)

=={{header|J}}==

See http://www.jsoftware.com/jwiki/Guides/Lexical_Closure, including the [[j:Guides/Lexical%20Closure#dissent|dissent]] section.

a=. cocreate''

n__a=: m

)</syntaxhighlight>

Example use:

F 11

21

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

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

{

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

public class AccumulatorFactory {

=={{header|JavaScript}}==

===ES5===

return function(n) {

return sum += n;

===ES6===

let x = accumulator(1);

console.log(x(5));

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

var x = accumulator(1);

x(5);

=={{header|Jsish}}==

From Javascript ES5 entry.

function accumulator(sum) {

return function(n) {

{{works with|Julia|0.6}}

f(n) = i += n

return f

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

=={{header|Lambdatalk}}==

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

{def acc

{lambda {:a :n}

=== Traditional closure ===

(defun accum (m)

(lambda (n)

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

=={{header|Lua}}==

A simple implementation:

init = init or 0

return function(delta)

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--end of factory closure</syntaxhighlight>

Usage example:

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

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

=={{header|M2000 Interpreter}}==

\\ accumulator factory

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

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

end proc:</syntaxhighlight>

Running this, we get:

> acc( 5 );

6

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

Module[{total = initial},

Function[x, total += x]

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.

As used:

:- interface.

:- import_module io.

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.

As used, with the same output:

:- interface.

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

=={{header|NewLisp}}==

</syntaxhighlight>

=={{header|NGS}}==

F Acc(start:Int) {

sum = start

Argument to the created accumulator function must be float.

Result is always float.

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

var sum = float(x)

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

This solution fulfills the requirements.

type

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

#

# Nit has no first-class function.

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

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

=={{header|Octave}}==

1;

function fun = foo(init)

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.

#[ n swap + dup ->n ] ;</syntaxhighlight>

Usage :

| x y z |

1 foo ->x

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

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

=={{header|PARI/GP}}==

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

{{trans|Ruby}}

my $sum = shift;

sub { $sum += shift }

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

<span style="color: #004080;">sequence</span> <span style="color: #000000;">accumulators</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>

=={{header|PHP}}==

function accumulator($start){

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

?></syntaxhighlight>

{{works with|PHP|5.3+}}

function accumulator($sum){

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

=={{header|PicoLisp}}==

(curry (Sum) (N)

(inc 'Sum N) ) )

=={{header|Pony}}==

use "assert"

class Accumulator

=={{header|PostScript}}==

{0 add 0 0 2 index put}

7 array copy

The GetNewClosure method returns a ScriptBlock with captured variables.

function Get-Accumulator ([double]$Start)

{

}

</syntaxhighlight>

$total = Get-Accumulator -Start 1

& $total -Plus 5.0 | Out-Null

{{works with|SWI Prolog}}

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

define_g(N, G) :-

=={{header|Python}}==

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

def f(n):

f.sum += n

{{trans|Ruby}}

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

def f(n):

nonlocal sum

{{works with|Python|2.5+}}

while True:

sum += yield sum

Quackery is untyped. This solution works with bignums. <code>factory</code> returns a lambda function. (In Quackery terminology, it leaves a nest on the stack.) Nests on the stack are performed (i.e. executed or evaluated) with <code>do</code>.

[ [ stack ] copy tuck put nested

In accordance with The Building Regulations, it starts with some sanity checks to enable the compiler to fail gracefully. For details see [https://github.com/GordonCharlton/Quackery/blob/main/The%20Book%20of%20Quackery.pdf The Book of Quackery.]

[ -1 split dup [] = if

[ $ "accumulator needs a starting value."

=={{header|R}}==

currentSum <- init

function(add) {

=={{header|Racket}}==

(define ((accumulator n) i)

(set! n (+ n i))

(formerly Perl 6)

{{works with|Rakudo|2018.03}}

#Example use:

=={{header|REBOL}}==

use [state] [

state: start-val

Retro only supports integers.

d:create , [ [ fetch ] [ v:inc ] bi ] does ;</syntaxhighlight>

{{out}}

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)

=={{header|Ring}}==

Func main

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

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

require 'complex'

y = accumulator(Rational(2, 3))

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

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

use std::ops::Add;

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

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

=={{header|Scheme}}==

{{trans|Ruby}}

(lambda (n)

(set! sum (+ sum n))

=={{header|Sidef}}==

method add(num) {

sum += num;

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

func(num) { sum += num };

}

=={{header|Simula}}==

! ABSTRACTION FOR SIMULA'S TWO NUMERIC TYPES ;

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

AccumulatorFactory class >> new: aNumber [

|r sum|

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

{{works with|Smalltalk}}

factory := [:initial |

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

=={{header|Swift}}==

return {

sum += $0

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

}</syntaxhighlight>

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

::accumulator.1

% $x 5

===Verbose===

(lambda (n)

(inc sum n)))

===Sugared===

(mapdo (do put-line `@1 -> @[f @1]`) (gun (iread : : nil))))</syntaxhighlight>

{{out}}

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

()

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

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

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

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

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)

end class</syntaxhighlight>

;Invocation

set a = new accumulator

x = a( 1 )

=={{header|Wart}}==

(fn() ++n)</syntaxhighlight>

=={{header|Wren}}==

var x = accumulator.call(1)

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

=={{header|XLISP}}==

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

(lambda (n)

(setq x (+ n x))

=={{header|Yabasic}}==

local f$

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

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