This implements a function that takes an initial value and constructs a new function that returns the value before incrementing the stored value by 1.

So, given an initial value of 1, the first time the function is called, 1 is returned. The second, 2, and so on.

In traditional Forth, this would be done using a CREATE/DOES> construct. RETRO allows for something similar using the does combinator.

An example in a traditional Forth:

: acc ( n "name" -- )   create , does> dup >r @ dup 1+ r> ! ;

In RETRO, we could begin by rewriting this using the RETRO words:

:acc (ns-)   d:create , [ dup push fetch n:inc pop store ] does ;

The dup push ... pop pattern is the sip combinator, so we can simplify it:

:acc (ns-)   d:create , [ [ fetch n:inc ] sip store ] does ;

This is better, but not quite done. RETRO has a v:inc for incrementing variables, which would eliminate the n:inc and store. And a bi combinator to run two quotes against a value. So we could simplify yet again, resulting in:

~~~:acc (ns-)   d:create , [ [ fetch ] [ v:inc ] bi ] does ; ~~~

This removes the primitive stack shuffling, and leaves something that expresses the intent more clearly.

Finally, here's a little test case:

```  #10 'foo acc   foo   foo   foo ```