All files / src/arbitrary types.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
import {Equivalence as EQ} from 'effect'
import type {Kind, TypeLambda} from 'effect/HKT'
import fc from 'fast-check'
 
/**
 * The type of a function that given any arbitrary of type `A`, returns an
 * arbitrary for `F<A>`.
 * @category lifting
 */
export interface LiftArbitrary<
  F extends TypeLambda,
  R = never,
  O = unknown,
  E = unknown,
> {
  <A>(a: fc.Arbitrary<A>): fc.Arbitrary<Kind<F, R, O, E, A>>
}
 
/**
 * Convert an equivalence of `A` to an arbitrary of `A`.
 * @category lifting
 */
export type EquivalenceToArbitrary<Eq extends EQ.Equivalence<never>> = (
  eq: Eq,
) => Eq extends EQ.Equivalence<infer A> ? fc.Arbitrary<A> : never
 
/**
 * Convert an arbitrary of `A` to an equivalence of `A`.
 * @category lifting
 */
export type ArbitraryToEquivalence<Arb extends fc.Arbitrary<never>> = (
  arb: Arb,
) => Arb extends fc.Arbitrary<infer A> ? fc.Arbitrary<A> : never
 
/**
 * Extract the underlying type of the given arbitrary.
 * @category types
 */
export type UnderlyingArbitrary<Fa extends fc.Arbitrary<unknown>> =
  Fa extends fc.Arbitrary<infer A> ? A : never
 
/**
 * Extract the HKT type and its main underlying _covariant_ type from a type
 * that was built from an HKT.
 * @category types
 */
export type UnderlyingHkt<
  Fa extends Kind<TypeLambda, never, unknown, unknown, any>,
> = {
  Child: Fa extends Kind<TypeLambda, never, unknown, unknown, infer A>
    ? A
    : never
  Parent: Fa extends Kind<infer F, never, unknown, unknown, any> ? F : never
}
 
/**
 * Extract the underlying type of the given equivalence.
 * @category types
 */
export type UnderlyingEquivalence<Fa extends EQ.Equivalence<never>> =
  Fa extends EQ.Equivalence<infer A> ? A : never