`Abstract`

`Abstract`

can- can
Shrink (value): value is TWithout Context Check if a given value could be pass to

`shrink`

without providing any context.In general,

`canShrinkWithoutContext`

is not designed to be called for each`shrink`

but rather on very special cases. Its usage must be restricted to`canShrinkWithoutContext`

or in the rare* contexts of a`shrink`

method being called without any context. In this ill-formed case of`shrink`

,`canShrinkWithoutContext`

could be used or called if needed.*we fall in that case when fast-check is asked to shrink a value that has been provided manually by the user, in other words: a value not coming from a call to

`generate`

or a normal`shrink`

with context.#### Parameters

- value: unknown
Value to be assessed

#### Returns value is T

`true`

if and only if the value could have been generated by this instance#### Remarks

Since 3.0.0

- value: unknown

- chain<U>(chainer): Arbitrary<U>
Create another arbitrary by mapping a value from a base Arbirary using the provided

`fmapper`

Values produced by the new arbitrary are the result of the arbitrary generated by applying`fmapper`

to a value#### Type Parameters

#### Parameters

#### Returns Arbitrary<U>

New arbitrary of new type

#### Example

`const arrayAndLimitArbitrary = fc.nat().chain((c: number) => fc.tuple( fc.array(fc.nat(c)), fc.constant(c)));`

#### Remarks

Since 1.2.0

- filter<U>(refinement): Arbitrary<U>
Create another arbitrary by filtering values against

`predicate`

All the values produced by the resulting arbitrary satisfy

`predicate(value) == true`

Be aware that using filter may highly impact the time required to generate a valid entry

#### Type Parameters

#### Parameters

#### Returns Arbitrary<U>

New arbitrary filtered using predicate

#### Example

`const integerGenerator: Arbitrary<number> = ...;`

const evenIntegerGenerator: Arbitrary<number> = integerGenerator.filter(e => e % 2 === 0);

// new Arbitrary only keeps even values#### Remarks

Since 1.23.0

- filter(predicate): Arbitrary<T>
Create another arbitrary by filtering values against

`predicate`

All the values produced by the resulting arbitrary satisfy

`predicate(value) == true`

Be aware that using filter may highly impact the time required to generate a valid entry

#### Parameters

- predicate: ((t) => boolean)
Predicate, to test each produced element. Return true to keep the element, false otherwise

- (t): boolean
#### Parameters

- t: T

#### Returns boolean

#### Returns Arbitrary<T>

New arbitrary filtered using predicate

#### Example

`const integerGenerator: Arbitrary<number> = ...;`

const evenIntegerGenerator: Arbitrary<number> = integerGenerator.filter(e => e % 2 === 0);

// new Arbitrary only keeps even values#### Remarks

Since 0.0.1

- predicate: ((t) => boolean)

`Abstract`

generate- generate(mrng, biasFactor): Value<T>
Generate a value of type

`T`

along with its context (if any) based on the provided random number generator#### Parameters

- mrng: Random
Random number generator

- biasFactor: undefined | number
If taken into account 1 value over biasFactor must be biased. Either integer value greater or equal to 2 (bias) or undefined (no bias)

#### Returns Value<T>

Random value of type

`T`

and its context#### Remarks

Since 0.0.1 (return type changed in 3.0.0)

- mrng: Random

- map<U>(mapper, unmapper?): Arbitrary<U>
Create another arbitrary by mapping all produced values using the provided

`mapper`

Values produced by the new arbitrary are the result of applying`mapper`

value by value#### Type Parameters

#### Parameters

#### Returns Arbitrary<U>

New arbitrary with mapped elements

#### Example

`const rgbChannels: Arbitrary<{r:number,g:number,b:number}> = ...;`

const color: Arbitrary<string> = rgbChannels.map(ch => `#${(ch.r*65536 + ch.g*256 + ch.b).toString(16).padStart(6, '0')}`);

// transform an Arbitrary producing {r,g,b} integers into an Arbitrary of '#rrggbb'#### Remarks

Since 0.0.1

- no
Shrink (): Arbitrary<T> Create another Arbitrary with no shrink values

#### Returns Arbitrary<T>

Create another arbitrary with no shrink values

#### Example

`const dataGenerator: Arbitrary<string> = ...;`

const unshrinkableDataGenerator: Arbitrary<string> = dataGenerator.noShrink();

// same values no shrink#### Remarks

Since 0.0.9

`Abstract`

shrink- shrink(value, context): Stream<Value<T>>
Shrink a value of type

`T`

, may rely on the context previously provided to shrink efficientlyMust never be called with possibly invalid values and no context without ensuring that such call is legal by calling

`canShrinkWithoutContext`

first on the value.#### Parameters

- value: T
The value to shrink

- context: unknown
Its associated context (the one returned by generate) or

`undefined`

if no context but`canShrinkWithoutContext(value) === true`

#### Returns Stream<Value<T>>

Stream of shrinks for value based on context (if provided)

#### Remarks

Since 3.0.0

- value: T

Abstract class able to generate values on type

`T`

The values generated by an instance of Arbitrary can be previewed - with sample - or classified - with statistics.

## Remarks

Since 0.0.7