Replace MutableRandomGenerator by another structure

Fixes #51

README.md

@@ -318,9 +318,14 @@ const intNoShrink = fc.int().noShrink();
 
 ### Build your own
 
-You can also fully customize your arbitrary and not derived from any of the buit-in arbitraries. What you have to do is to derive from [Arbitrary](https://github.com/dubzzz/fast-check/blob/master/src/check/arbitrary/definition/Arbitrary.ts) and implement `generate(mrng: MutableRandomGenerator): Shrinkable<T>`.
-
-`generate` is responsable for the generation of one new random entity of type `T` (see signature above). In ordedr to fulfill it in a deterministic way it received a `mrng: MutableRandomGenerator`. It can then use it to generate integer values within `min` (included) and `max` (included) by using `UniformDistribution.inRange(min, max)(mrng)[0]`.
+You can also fully customize your arbitrary and by not deriving it from any of the buit-in arbitraries. What you have to do is to derive from [Arbitrary](https://github.com/dubzzz/fast-check/blob/master/src/check/arbitrary/definition/Arbitrary.ts) and implement `generate(mrng: Random): Shrinkable<T>`.
+
+`generate` is responsable for the generation of one new random entity of type `T` (see signature above). In order to fulfill it in a deterministic way it received a `mrng: Random`. It comes with multiple built-in helpers to generate values:
+- `next(n: number): number`: uniformly distributed n bits value (max value of n = 31)
+- `nextBoolean(): boolean`: uniformly distributed boolean value
+- `nextInt(): number`: uniformly distributed integer value
+- `nextInt(from: number, to: number): number`: uniformly distributed integer value between from (inclusive) and to (inclusive)
+- `nextDouble(): number`: uniformly distributed double value between 0.0 (included) and 1.0 (not included)
 
 The generated value also came with a shrink method able to derive _smaller_ values in case of failure. It can be ignored making the arbitrary not shrinkable.
 

prebuild/tuple.ts

@@ -8,7 +8,7 @@ const classFor = function(num: number): string {
                 super();
                 this.tupleArb = new GenericTupleArbitrary([${arbCommas(num)}]);
             }
-            generate(mrng: MutableRandomGenerator): Shrinkable<[${txCommas(num)}]> {
+            generate(mrng: Random): Shrinkable<[${txCommas(num)}]> {
                 return this.tupleArb.generate(mrng) as Shrinkable<[${txCommas(num)}]>;
             }
         };
@@ -34,7 +34,7 @@ const generateTuple = function(num: number): string {
             // imports
             `import Arbitrary from './definition/Arbitrary';`,
             `import Shrinkable from './definition/Shrinkable';`,
-            `import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator';`,
+            `import Random from '../../random/generator/Random';`,
             `import { GenericTupleArbitrary } from './TupleArbitrary.generic';`,
             // declare all necessary classes
             ...iota(num).map(num => classFor(num +1)),

src/check/arbitrary/ArrayArbitrary.ts

@@ -1,7 +1,7 @@
 import { Arbitrary, ArbitraryWithShrink } from './definition/Arbitrary'
 import Shrinkable from './definition/Shrinkable'
 import { integer } from './IntegerArbitrary'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 import { Stream, stream } from '../../stream/Stream'
 
 class ArrayArbitrary<T> extends Arbitrary<T[]> {
@@ -18,7 +18,7 @@ class ArrayArbitrary<T> extends Arbitrary<T[]> {
             items.map(s => s.value),
             () => this.shrinkImpl(items).map(v => this.wrapper(v)));
     }
-    generate(mrng: MutableRandomGenerator): Shrinkable<T[]> {
+    generate(mrng: Random): Shrinkable<T[]> {
         const size = this.lengthArb.generate(mrng);
         const items = [...Array(size.value)].map(() => this.arb.generate(mrng));
         return this.wrapper(items);

src/check/arbitrary/CharacterArbitrary.ts

@@ -1,7 +1,7 @@
 import Arbitrary from './definition/Arbitrary'
 import Shrinkable from './definition/Shrinkable'
 import { integer } from './IntegerArbitrary'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 import { Stream, stream } from '../../stream/Stream'
 
 function CharacterArbitrary(min: number, max: number, mapToCode: (v: number) => number = v => v) {

src/check/arbitrary/ConstantArbitrary.ts

@@ -1,6 +1,6 @@
 import Arbitrary from './definition/Arbitrary'
 import Shrinkable from './definition/Shrinkable'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 import { nat } from './IntegerArbitrary'
 import { stream, Stream } from '../../stream/Stream'
 
@@ -10,7 +10,7 @@ class ConstantArbitrary<T> extends Arbitrary<T> {
         super();
         this.idArb = nat(values.length -1);
     }
-    generate(mrng: MutableRandomGenerator): Shrinkable<T> {
+    generate(mrng: Random): Shrinkable<T> {
         if (this.values.length === 1)
             return new Shrinkable(this.values[0]);
 

src/check/arbitrary/DictionaryArbitrary.ts

@@ -1,5 +1,5 @@
 import Arbitrary from './definition/Arbitrary'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 
 import { set } from './SetArbitrary'
 import { tuple } from './TupleArbitrary'

src/check/arbitrary/FrequencyArbitrary.ts

@@ -1,6 +1,6 @@
 import Arbitrary from './definition/Arbitrary'
 import Shrinkable from './definition/Shrinkable'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 import { nat } from './IntegerArbitrary'
 
 export interface WeightedArbitrary<T> {
@@ -21,7 +21,7 @@ class FrequencyArbitrary<T> extends Arbitrary<T> {
                 .slice(1);
         this.idArb = nat(this.summedWarbs[this.summedWarbs.length -1].weight -1);
     }
-    generate(mrng: MutableRandomGenerator): Shrinkable<T> {
+    generate(mrng: Random): Shrinkable<T> {
         const selected = this.idArb.generate(mrng).value;
         return this.summedWarbs
                 .find(warb => selected < warb.weight)!.arbitrary

src/check/arbitrary/IntegerArbitrary.ts

@@ -2,7 +2,7 @@ import prand from 'pure-rand'
 
 import { ArbitraryWithShrink } from './definition/Arbitrary'
 import Shrinkable from './definition/Shrinkable'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 import { stream, Stream } from '../../stream/Stream'
 
 class IntegerArbitrary extends ArbitraryWithShrink<number> {
@@ -19,11 +19,8 @@ class IntegerArbitrary extends ArbitraryWithShrink<number> {
     private wrapper(value: number): Shrinkable<number> {
         return new Shrinkable(value, () => this.shrink(value).map(v => this.wrapper(v)));
     }
-    generate(mrng: MutableRandomGenerator): Shrinkable<number> {
-        return this.wrapper(this.generateImpl(mrng));
-    }
-    private generateImpl(mrng: MutableRandomGenerator): number {
-        return prand.uniformIntDistribution(this.min, this.max)(mrng)[0];
+    generate(mrng: Random): Shrinkable<number> {
+        return this.wrapper(mrng.nextInt(this.min, this.max));
     }
     private shrink_to(value: number, target: number): Stream<number> {
         const gap = value - target;

src/check/arbitrary/LoremArbitrary.ts

@@ -4,7 +4,7 @@ var loremIpsum: (opt: any) => string = require('lorem-ipsum')
 import Arbitrary from './definition/Arbitrary'
 import Shrinkable from './definition/Shrinkable'
 import { nat } from './IntegerArbitrary'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 
 class LoremArbitrary extends Arbitrary<string> {
     readonly arbWordsCount: Arbitrary<number>;
@@ -14,12 +14,12 @@ class LoremArbitrary extends Arbitrary<string> {
         this.arbWordsCount = nat(maxWordsCount || 5);
         this.sentencesMode = sentencesMode || false;
     }
-    generate(mrng: MutableRandomGenerator): Shrinkable<string> {
+    generate(mrng: Random): Shrinkable<string> {
         const numWords = this.arbWordsCount.generate(mrng).value;
         const lorem = loremIpsum({
             count: numWords,
             units: this.sentencesMode ? 'sentences' : 'words',
-            random: () => mrng.next()[0] / (mrng.max() - mrng.min())
+            random: () => mrng.nextDouble()
         });
         return new Shrinkable(lorem);
     }

src/check/arbitrary/ObjectArbitrary.ts

@@ -1,6 +1,6 @@
 import Arbitrary from './definition/Arbitrary'
 import Shrinkable from './definition/Shrinkable'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 
 import { array } from './ArrayArbitrary'
 import { boolean } from './BooleanArbitrary'
@@ -72,7 +72,7 @@ class ObjectArbitrary extends Arbitrary<any> {
         }
         return oneof(potentialArbValue[0], ...potentialArbValue.slice(0));
     }
-    generate(mrng: MutableRandomGenerator): Shrinkable<any> {
+    generate(mrng: Random): Shrinkable<any> {
         return dictionary(
                 this.constraints.key,
                 ObjectArbitrary.anything(this.constraints)

src/check/arbitrary/OneOfArbitrary.ts

@@ -1,6 +1,6 @@
 import Arbitrary from './definition/Arbitrary'
 import Shrinkable from './definition/Shrinkable'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 import { nat } from './IntegerArbitrary'
 
 class OneOfArbitrary<T> extends Arbitrary<T> {
@@ -9,7 +9,7 @@ class OneOfArbitrary<T> extends Arbitrary<T> {
         super();
         this.idArb = nat(arbs.length -1);
     }
-    generate(mrng: MutableRandomGenerator): Shrinkable<T> {
+    generate(mrng: Random): Shrinkable<T> {
         const id = this.idArb.generate(mrng);
         return this.arbs[id.value].generate(mrng);
     }

src/check/arbitrary/OptionArbitrary.ts

@@ -1,7 +1,7 @@
 import { Arbitrary } from './definition/Arbitrary'
 import Shrinkable from './definition/Shrinkable'
 import { nat } from './IntegerArbitrary'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 
 class OptionArbitrary<T> extends Arbitrary<T | null> {
     readonly isOptionArb: Arbitrary<number>;
@@ -17,7 +17,7 @@ class OptionArbitrary<T> extends Arbitrary<T | null> {
                 s.value,
                 () => s.shrink().map(OptionArbitrary.extendedShrinkable).join(g()));
     }
-    generate(mrng: MutableRandomGenerator): Shrinkable<T | null> {
+    generate(mrng: Random): Shrinkable<T | null> {
         return this.isOptionArb.generate(mrng).value === 0
                 ? new Shrinkable(null)
                 : OptionArbitrary.extendedShrinkable(this.arb.generate(mrng));

src/check/arbitrary/RecordArbitrary.ts

@@ -1,5 +1,5 @@
 import Arbitrary from './definition/Arbitrary'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 
 import { option } from './OptionArbitrary'
 import { generic_tuple } from './TupleArbitrary'

src/check/arbitrary/StringArbitrary.ts

@@ -4,7 +4,7 @@ import Shrinkable from './definition/Shrinkable'
 import { array } from './ArrayArbitrary'
 import { nat } from './IntegerArbitrary'
 import { char, ascii, char16bits, unicode, fullUnicode, hexa, base64 } from './CharacterArbitrary'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 
 function StringArbitrary(charArb: Arbitrary<string>, aLength?: number, bLength?: number) {
     const arrayArb = aLength != null

src/check/arbitrary/TupleArbitrary.generic.ts

@@ -1,6 +1,6 @@
 import Arbitrary from './definition/Arbitrary'
 import Shrinkable from './definition/Shrinkable'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 import { Stream, stream } from '../../stream/Stream'
 
 class GenericTupleArbitrary extends Arbitrary<any[]> {
@@ -12,7 +12,7 @@ class GenericTupleArbitrary extends Arbitrary<any[]> {
             shrinkables.map(s => s.value),
             () => GenericTupleArbitrary.shrinkImpl(shrinkables).map(GenericTupleArbitrary.wrapper));
     }
-    generate(mrng: MutableRandomGenerator): Shrinkable<any[]> {
+    generate(mrng: Random): Shrinkable<any[]> {
         return GenericTupleArbitrary.wrapper(this.arbs.map(a => a.generate(mrng)));
     }
     private static shrinkImpl(value: Shrinkable<any>[]): Stream<Shrinkable<any>[]> {

src/check/arbitrary/definition/Arbitrary.ts

@@ -1,15 +1,15 @@
-import MutableRandomGenerator from '../../../random/generator/MutableRandomGenerator'
+import Random from '../../../random/generator/Random'
 import Shrinkable from './Shrinkable'
 import Stream from '../../../stream/Stream'
 
 export default abstract class Arbitrary<T> {
-    abstract generate(mrng: MutableRandomGenerator): Shrinkable<T>;
+    abstract generate(mrng: Random): Shrinkable<T>;
     filter(predicate: (t: T) => boolean): Arbitrary<T> {
         class FilteredArbitrary<T> extends Arbitrary<T> {
             constructor(readonly arb: Arbitrary<T>, readonly predicate: (t: T) => boolean) {
                 super();
             }
-            generate(mrng: MutableRandomGenerator): Shrinkable<T> {
+            generate(mrng: Random): Shrinkable<T> {
                 let g = this.arb.generate(mrng);
                 while (! this.predicate(g.value)) {
                     g = this.arb.generate(mrng);
@@ -24,7 +24,7 @@ export default abstract class Arbitrary<T> {
             constructor(readonly arb: Arbitrary<T>, readonly mapper: (t: T) => U) {
                 super();
             }
-            generate(mrng: MutableRandomGenerator): Shrinkable<U> {
+            generate(mrng: Random): Shrinkable<U> {
                 return this.arb.generate(mrng).map(this.mapper);
             }
         }
@@ -35,7 +35,7 @@ export default abstract class Arbitrary<T> {
             constructor(readonly arb: Arbitrary<T>) {
                 super();
             }
-            generate(mrng: MutableRandomGenerator): Shrinkable<T> {
+            generate(mrng: Random): Shrinkable<T> {
                 return new Shrinkable(this.arb.generate(mrng).value);
             }
         }
@@ -44,7 +44,7 @@ export default abstract class Arbitrary<T> {
 }
 
 abstract class ArbitraryWithShrink<T> extends Arbitrary<T> {
-    abstract generate(mrng: MutableRandomGenerator): Shrinkable<T>;
+    abstract generate(mrng: Random): Shrinkable<T>;
     abstract shrink(value: T): Stream<T>;
     shrinkableFor(value: T): Shrinkable<T> {
         return new Shrinkable(value, () => this.shrink(value).map(v => this.shrinkableFor(v)));

src/check/property/AsyncProperty.generic.ts

@@ -1,12 +1,12 @@
 import Arbitrary from '../arbitrary/definition/Arbitrary';
 import Shrinkable from '../arbitrary/definition/Shrinkable';
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator';
+import Random from '../../random/generator/Random';
 import IProperty from './IProperty';
 
 export class AsyncProperty<Ts> implements IProperty<Ts> {
     constructor(readonly arb: Arbitrary<Ts>, readonly predicate: (t: Ts) => Promise<boolean | void>) { }
     isAsync = () => true;
-    generate(mrng: MutableRandomGenerator): Shrinkable<Ts> {
+    generate(mrng: Random): Shrinkable<Ts> {
         return this.arb.generate(mrng);
     }
     async run(v: Ts): Promise<string|null> {

src/check/property/IProperty.ts

@@ -1,9 +1,9 @@
 import Shrinkable from '../arbitrary/definition/Shrinkable'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 import Stream from '../../stream/Stream'
 
 export default interface IProperty<Ts> {
     isAsync(): boolean;
-    generate(mrng: MutableRandomGenerator): Shrinkable<Ts>;
+    generate(mrng: Random): Shrinkable<Ts>;
     run(v: Ts): Promise<string|null> | (string|null);
 }

src/check/property/Property.generic.ts

@@ -1,13 +1,13 @@
 import Arbitrary from '../arbitrary/definition/Arbitrary'
 import Shrinkable from '../arbitrary/definition/Shrinkable'
 import { tuple } from '../arbitrary/TupleArbitrary'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 import IProperty from './IProperty'
 
 export class Property<Ts> implements IProperty<Ts> {
     constructor(readonly arb: Arbitrary<Ts>, readonly predicate: (t: Ts) => (boolean | void)) { }
     isAsync = () => false;
-    generate(mrng: MutableRandomGenerator): Shrinkable<Ts> {
+    generate(mrng: Random): Shrinkable<Ts> {
         return this.arb.generate(mrng);
     }
     run(v: Ts): (string|null) {

src/check/property/TimeoutProperty.ts

@@ -1,6 +1,6 @@
 import Arbitrary from '../arbitrary/definition/Arbitrary';
 import Shrinkable from '../arbitrary/definition/Shrinkable';
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator';
+import Random from '../../random/generator/Random';
 import IProperty from './IProperty';
 
 const timeoutAfter = function(timeMs: number) {
@@ -11,7 +11,7 @@ const timeoutAfter = function(timeMs: number) {
 export class TimeoutProperty<Ts> implements IProperty<Ts> {
     constructor(readonly property: IProperty<Ts>, readonly timeMs: number) { }
     isAsync = () => true;
-    generate(mrng: MutableRandomGenerator): Shrinkable<Ts> {
+    generate(mrng: Random): Shrinkable<Ts> {
         return this.property.generate(mrng);
     }
     async run(v: Ts): Promise<string|null> {

src/check/runner/Tosser.ts

@@ -2,11 +2,11 @@ import prand from 'pure-rand'
 
 import Arbitrary from '../arbitrary/definition/Arbitrary'
 import Shrinkable from '../arbitrary/definition/Shrinkable'
-import MutableRandomGenerator from '../../random/generator/MutableRandomGenerator'
+import Random from '../../random/generator/Random'
 import IProperty from '../property/IProperty'
 
 function lazyGenerate<Ts>(generator: (IProperty<Ts> | Arbitrary<Ts>), rng: prand.RandomGenerator): () => Shrinkable<Ts> {
-    return () => generator.generate(new MutableRandomGenerator(rng));
+    return () => generator.generate(new Random(rng));
 }
 
 export default function* toss<Ts>(generator: (IProperty<Ts> | Arbitrary<Ts>), seed: number): IterableIterator<() => Shrinkable<Ts>> {

src/fast-check-default.ts

@@ -23,7 +23,7 @@ import { string, asciiString, string16bits, unicodeString, fullUnicodeString, he
 import { set } from './check/arbitrary/SetArbitrary'
 import { tuple, generic_tuple } from './check/arbitrary/TupleArbitrary'
 
-import { MutableRandomGenerator } from './random/generator/MutableRandomGenerator'
+import { Random } from './random/generator/Random'
 
 import { Stream, stream } from './stream/Stream'
 
@@ -46,6 +46,6 @@ export {
     Arbitrary, Shrinkable,
     // interfaces
     ObjectConstraints, Parameters, RecordConstraints, RunDetails,
-    MutableRandomGenerator,
+    Random,
     Stream, stream,
 };