Group generator results into array

'cConcat' combinator function concatenates the results of generators executed in sequence into one array.
For example:

   seq([gen(1), gen(2)], cConcat)() => [1,2]
 

'cConcat' can be used in combination with and {@link replicate.

'cJoin' combinator function joins the results of generators executed in sequence into one string.
For example:

   seq([gen(1), gen(2)], cJoin)() => '12'
 

'cJoin' can be used in combination with and {@link replicate.

Use 'chain' to execute generators in sequence. 'chain' executes the argument generator or generator array 'g' and passes the result to the parameter function 'f'. 'f' may evaluate the result but always has to return a new generator. 'chain' itself is a generator that can be evaluated or passed to another chain or other generator function.
For example:

   var g = chain(gen(1), function(r) { return gen(r + 1); });
   g('any input') will evaluate to 2.
 

Same as 'permutate', 'circulate' executes the argument generator 'gen' on the default object 'base' and returns the resulting object array.
In difference to 'permutate', the results of all attribute generators are combined together. If no count is provided, circulate generates object array of the length of the longest attribute generator. All other attribute values circulate, for example:

   var base = { name: 'Woody', age:2 }; 
   var gen  = { name: list('Buzz', 'Slinky'), age: range(2,5) }; 
   generate(gen, base) will return the array: 
    [{ name: 'Buzz',   age: 2 },
     { name: 'Slinky', age: 3 }, 
     { name: 'Buzz',   age: 4 }, 
     { name: 'Slinky', age: 5 }]
 

'current' provides access to current generated object. It's experimental, use with care!!! For example:

   var o = { name: 'Woody', age:2 };
   var g = { name : list('Buzz', 'Woody'), 
             description : current(function(r) { return r.name + ' is ' + r.age; }) }
   permutate(g, o) will return 
   [{ name:'Buzz', age:2, description: 'Buzz is 2' }, 
    { name:'Woody', age:2, description: 'Woody is 2' }]
 

'gen' creates a generator that returns the argument value 'v' when executed on any input object. 'gen' is basically a generator constructor that wraps any value into a generator.
For example:

   var g = gen('test');
   g('any input') will return 'test'.
 

Identity

Lazy generator evaluation wrapper used for example by random generators.
For example:

   var g1 = gen(Math.random());
   var g2 = lazy(function() { return gen(Math.random()); });
   g1 will always return the same value and g2 a different one
   when executed.
 

'mapGen' is a helper function that converts all elements of an array to generators.
magGen(as) -> [gen(as[i])]

'mutate' executes generators 'gs' on the input object o. For example:

   mutate([gen('Buzz'), gen('Woody')](o) will return 
   ['Buzz', 'Woody']
 

'mutateOnAttribute' executes generators 'gs' on an object property of name 'name'. The result is an array that contains one result object for every generator result value.
For example:

   var o = { name: 'Woody', age:2 };
   mutateOnAttribute('name', [gen('Buzz'), gen('Woody')](o) will return 
   the object array [{ name:'Buzz', age:2 }, { name:'Woody', age:2 }]
 

'permutate' is one of two supported JSON object generation functions. It executes the argument generator 'gen' on the default object 'base' and returns the resulting object array.
This generation method permutates over all results of all attribute generator, for example:

   var base = { name: 'Woody', age:2 }; 
   var gen  = { name: list('Buzz', 'Slinky'), age: range(2,4) }; 
   generate(gen, base) will return the array: 
    [{ name: 'Buzz',   age: 2 },
     { name: 'Buzz',   age: 3 }, 
     { name: 'Buzz',   age: 4 }, 
     { name: 'Slinky', age: 2 }, 
     { name: 'Slinky', age: 3 }, 
     { name: 'Slinky', age: 4 }]
 

'property' applies generator 'g' on an object property of name 'name' and returns the resulting object. 'property' acts as a property selector and is a generator itself that can be evaluated or passed to other generators.
For example:

   var o    = { name:'Woody', toy:'cowboy' };
   var name = property('name');
   name(gen('Buzz'))(o) will return the object { name:'Buzz', toy:'cowboy' }
 

Creates a linear congruential random generator object using an optional 'seed' value. If 'seed' is not defined, the default JavaScript Math.random() function is used. See Wikipedia LCR for details.

Repeats value 'v' 'n'-times and returns the resulting array. If parameter 'v' is an array, the subsequent results are concatenated. 'repeat' is commonly used with object generators, for example:

   var gen = {
     name : repeat(3, gen('abc'))
   }
   will generate three objects { name : 'abc' } when evaluated with generate.
 

See Popcorn.Core.generate for details.

'replicate' executes generator 'g' 'n'-times and combines the results using combinator function 'f'. This function is a specialization of seq.
Example:

   var overflow = replicate(gen('A'), cJoin, '');
   overflow(5) generates 'AAAAA'
 

'seq' executes the generators 'gs' and combines the result using combinator function 'f'. Combinator 'f' is called on every step with the result of previous executions ('init' value on first call) and the result of the current generator evaluation.
For example:

   var g = seq([gen('a'), gen('b'), gen('c')], cJoin, 0);
   g('any input') will return 'abc'.
 

'setVar' stores the result of one generator that can be used as input to another generator in same generation process.
For example:

   var g = {
     int   : setVar('my_rand', random().int()),
     plus1 : withVar('my_rand', function(i) { return gen(i + 1); })
   }
 

The random integer value generated for attribute 'int' is stored in the state object under the attribute name 'my_rand' and referenced using withVar function.

Wrappes a value into generator array, the default input for 'mutate'.

Executes generators 'gs' on an input object and returns the updated object.
For example:

   var o    = { name: 'Woody', toy: 'cowboy' };
   var name = property('name');
   var toy  = property('toy');
   update([name(gen('Buzz')), toy(gen('action figure'))])(o) will return the object 
   { name:'Buzz', toy:'action figure' }
 

Creates a generator that returns the value of the variable 'name' when executed. For example:

   var g = {
     att1 : setVar('my_rand', random().int()),
     att2 : varGen('my_rand')
   }
 

will generate an object with same value for both attributes.

'withState' provides access to the state object. The function 'f' takes the state object as argument and returns another generator as result. All modifications to the state object are visible to other generators. For example:

   var g = {
     int : withState(function(s) { s.init = 10; return random().int(); } ),
     add : withState(function(s) { return gen(s.init + 10); } )
   }
 

'withVar' provides access to variables stored using setVar generator. It takes the variable name and a function as argument. The value of the variable is passed to the function that has to return another generator as result. For an example see setVar generator.