Erster Docker-Stand
This commit is contained in:
809
_node_modules/effect/src/Utils.ts
generated
Normal file
809
_node_modules/effect/src/Utils.ts
generated
Normal file
@@ -0,0 +1,809 @@
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
import { identity } from "./Function.js"
|
||||
import { globalValue } from "./GlobalValue.js"
|
||||
import type { Kind, TypeLambda } from "./HKT.js"
|
||||
import { getBugErrorMessage } from "./internal/errors.js"
|
||||
import { isNullable, isObject } from "./Predicate.js"
|
||||
import type * as Types from "./Types.js"
|
||||
|
||||
/*
|
||||
* Copyright 2014 Thom Chiovoloni, released under the MIT license.
|
||||
*
|
||||
* A random number generator based on the basic implementation of the PCG algorithm,
|
||||
* as described here: http://www.pcg-random.org/
|
||||
*
|
||||
* Adapted for TypeScript from Thom's original code at https://github.com/thomcc/pcg-random
|
||||
*
|
||||
* forked from https://github.com/frptools
|
||||
*
|
||||
* @since 2.0.0
|
||||
*/
|
||||
|
||||
/**
|
||||
* @category symbols
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export const GenKindTypeId: unique symbol = Symbol.for("effect/Gen/GenKind")
|
||||
|
||||
/**
|
||||
* @category symbols
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export type GenKindTypeId = typeof GenKindTypeId
|
||||
|
||||
/**
|
||||
* @category models
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export interface GenKind<F extends TypeLambda, R, O, E, A> extends Variance<F, R, O, E> {
|
||||
readonly value: Kind<F, R, O, E, A>
|
||||
|
||||
[Symbol.iterator](): IterableIterator<GenKind<F, R, O, E, A>, A>
|
||||
}
|
||||
|
||||
/**
|
||||
* @category predicates
|
||||
* @since 3.0.6
|
||||
*/
|
||||
export const isGenKind = (u: unknown): u is GenKind<any, any, any, any, any> => isObject(u) && GenKindTypeId in u
|
||||
|
||||
/**
|
||||
* @category constructors
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export class GenKindImpl<F extends TypeLambda, R, O, E, A> implements GenKind<F, R, O, E, A> {
|
||||
constructor(
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
readonly value: Kind<F, R, O, E, A>
|
||||
) {}
|
||||
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
get _F() {
|
||||
return identity
|
||||
}
|
||||
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
get _R() {
|
||||
return (_: R) => _
|
||||
}
|
||||
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
get _O() {
|
||||
return (_: never): O => _
|
||||
}
|
||||
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
get _E() {
|
||||
return (_: never): E => _
|
||||
}
|
||||
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
readonly [GenKindTypeId]: typeof GenKindTypeId = GenKindTypeId;
|
||||
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
[Symbol.iterator](): IterableIterator<GenKind<F, R, O, E, A>, A> {
|
||||
return new SingleShotGen<GenKind<F, R, O, E, A>, A>(this as any)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @category constructors
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export class SingleShotGen<T, A> implements IterableIterator<T, A> {
|
||||
private called = false
|
||||
|
||||
constructor(readonly self: T) {}
|
||||
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
next(a: A): IteratorResult<T, A> {
|
||||
return this.called ?
|
||||
({
|
||||
value: a,
|
||||
done: true
|
||||
}) :
|
||||
(this.called = true,
|
||||
({
|
||||
value: this.self,
|
||||
done: false
|
||||
}))
|
||||
}
|
||||
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
return(a: A): IteratorResult<T, A> {
|
||||
return ({
|
||||
value: a,
|
||||
done: true
|
||||
})
|
||||
}
|
||||
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
throw(e: unknown): IteratorResult<T, A> {
|
||||
throw e
|
||||
}
|
||||
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
[Symbol.iterator](): IterableIterator<T, A> {
|
||||
return new SingleShotGen<T, A>(this.self)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @category constructors
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export const makeGenKind = <F extends TypeLambda, R, O, E, A>(
|
||||
kind: Kind<F, R, O, E, A>
|
||||
): GenKind<F, R, O, E, A> => new GenKindImpl(kind)
|
||||
|
||||
/**
|
||||
* @category models
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export interface Variance<in out F extends TypeLambda, in R, out O, out E> {
|
||||
readonly [GenKindTypeId]: GenKindTypeId
|
||||
readonly _F: Types.Invariant<F>
|
||||
readonly _R: Types.Contravariant<R>
|
||||
readonly _O: Types.Covariant<O>
|
||||
readonly _E: Types.Covariant<E>
|
||||
}
|
||||
|
||||
/**
|
||||
* @category models
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export interface Gen<F extends TypeLambda, Z> {
|
||||
<Self, K extends Variance<F, any, any, any> | YieldWrap<Kind<F, any, any, any, any>>, A>(
|
||||
...args:
|
||||
| [
|
||||
self: Self,
|
||||
body: (this: Self, resume: Z) => Generator<K, A, never>
|
||||
]
|
||||
| [
|
||||
body: (resume: Z) => Generator<K, A, never>
|
||||
]
|
||||
): Kind<
|
||||
F,
|
||||
[K] extends [Variance<F, infer R, any, any>] ? R
|
||||
: [K] extends [YieldWrap<Kind<F, infer R, any, any, any>>] ? R
|
||||
: never,
|
||||
[K] extends [Variance<F, any, infer O, any>] ? O
|
||||
: [K] extends [YieldWrap<Kind<F, any, infer O, any, any>>] ? O
|
||||
: never,
|
||||
[K] extends [Variance<F, any, any, infer E>] ? E
|
||||
: [K] extends [YieldWrap<Kind<F, any, any, infer E, any>>] ? E
|
||||
: never,
|
||||
A
|
||||
>
|
||||
}
|
||||
|
||||
/**
|
||||
* @category models
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export interface Adapter<Z extends TypeLambda> {
|
||||
<_R, _O, _E, _A>(
|
||||
self: Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, _R, _O, _E, _A>(a: A, ab: (a: A) => Kind<Z, _R, _O, _E, _A>): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, _R, _O, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => Kind<Z, _R, _O, _E, _A>): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: F) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (g: H) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, I, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (h: H) => I,
|
||||
ij: (i: I) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, I, J, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (h: H) => I,
|
||||
ij: (i: I) => J,
|
||||
jk: (j: J) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, I, J, K, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (h: H) => I,
|
||||
ij: (i: I) => J,
|
||||
jk: (j: J) => K,
|
||||
kl: (k: K) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, I, J, K, L, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (h: H) => I,
|
||||
ij: (i: I) => J,
|
||||
jk: (j: J) => K,
|
||||
kl: (k: K) => L,
|
||||
lm: (l: L) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, I, J, K, L, M, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (h: H) => I,
|
||||
ij: (i: I) => J,
|
||||
jk: (j: J) => K,
|
||||
kl: (k: K) => L,
|
||||
lm: (l: L) => M,
|
||||
mn: (m: M) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, I, J, K, L, M, N, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (h: H) => I,
|
||||
ij: (i: I) => J,
|
||||
jk: (j: J) => K,
|
||||
kl: (k: K) => L,
|
||||
lm: (l: L) => M,
|
||||
mn: (m: M) => N,
|
||||
no: (n: N) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (h: H) => I,
|
||||
ij: (i: I) => J,
|
||||
jk: (j: J) => K,
|
||||
kl: (k: K) => L,
|
||||
lm: (l: L) => M,
|
||||
mn: (m: M) => N,
|
||||
no: (n: N) => O,
|
||||
op: (o: O) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (h: H) => I,
|
||||
ij: (i: I) => J,
|
||||
jk: (j: J) => K,
|
||||
kl: (k: K) => L,
|
||||
lm: (l: L) => M,
|
||||
mn: (m: M) => N,
|
||||
no: (n: N) => O,
|
||||
op: (o: O) => P,
|
||||
pq: (p: P) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (h: H) => I,
|
||||
ij: (i: I) => J,
|
||||
jk: (j: J) => K,
|
||||
kl: (k: K) => L,
|
||||
lm: (l: L) => M,
|
||||
mn: (m: M) => N,
|
||||
no: (n: N) => O,
|
||||
op: (o: O) => P,
|
||||
pq: (p: P) => Q,
|
||||
qr: (q: Q) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (h: H) => I,
|
||||
ij: (i: I) => J,
|
||||
jk: (j: J) => K,
|
||||
kl: (k: K) => L,
|
||||
lm: (l: L) => M,
|
||||
mn: (m: M) => N,
|
||||
no: (n: N) => O,
|
||||
op: (o: O) => P,
|
||||
pq: (p: P) => Q,
|
||||
qr: (q: Q) => R,
|
||||
rs: (r: R) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (h: H) => I,
|
||||
ij: (i: I) => J,
|
||||
jk: (j: J) => K,
|
||||
kl: (k: K) => L,
|
||||
lm: (l: L) => M,
|
||||
mn: (m: M) => N,
|
||||
no: (n: N) => O,
|
||||
op: (o: O) => P,
|
||||
pq: (p: P) => Q,
|
||||
qr: (q: Q) => R,
|
||||
rs: (r: R) => S,
|
||||
st: (s: S) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, _R, _O, _E, _A>(
|
||||
a: A,
|
||||
ab: (a: A) => B,
|
||||
bc: (b: B) => C,
|
||||
cd: (c: C) => D,
|
||||
de: (d: D) => E,
|
||||
ef: (e: E) => F,
|
||||
fg: (f: F) => G,
|
||||
gh: (g: G) => H,
|
||||
hi: (h: H) => I,
|
||||
ij: (i: I) => J,
|
||||
jk: (j: J) => K,
|
||||
kl: (k: K) => L,
|
||||
lm: (l: L) => M,
|
||||
mn: (m: M) => N,
|
||||
no: (n: N) => O,
|
||||
op: (o: O) => P,
|
||||
pq: (p: P) => Q,
|
||||
qr: (q: Q) => R,
|
||||
rs: (r: R) => S,
|
||||
st: (s: S) => T,
|
||||
tu: (s: T) => Kind<Z, _R, _O, _E, _A>
|
||||
): GenKind<Z, _R, _O, _E, _A>
|
||||
}
|
||||
|
||||
/**
|
||||
* @category adapters
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export const adapter: <F extends TypeLambda>() => Adapter<F> = () => (function() {
|
||||
let x = arguments[0]
|
||||
for (let i = 1; i < arguments.length; i++) {
|
||||
x = arguments[i](x)
|
||||
}
|
||||
return new GenKindImpl(x) as any
|
||||
})
|
||||
|
||||
const defaultIncHi = 0x14057b7e
|
||||
const defaultIncLo = 0xf767814f
|
||||
const MUL_HI = 0x5851f42d >>> 0
|
||||
const MUL_LO = 0x4c957f2d >>> 0
|
||||
const BIT_53 = 9007199254740992.0
|
||||
const BIT_27 = 134217728.0
|
||||
|
||||
/**
|
||||
* @category model
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export type PCGRandomState = [number, number, number, number]
|
||||
|
||||
/**
|
||||
* @category model
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export type OptionalNumber = number | null | undefined
|
||||
|
||||
/**
|
||||
* PCG is a family of simple fast space-efficient statistically good algorithms
|
||||
* for random number generation. Unlike many general-purpose RNGs, they are also
|
||||
* hard to predict.
|
||||
*
|
||||
* @category model
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export class PCGRandom {
|
||||
private _state!: Int32Array
|
||||
|
||||
/**
|
||||
* Creates an instance of PCGRandom.
|
||||
*
|
||||
* - `seed` - The low 32 bits of the seed (0 is used for high 32 bits).
|
||||
*
|
||||
* @memberOf PCGRandom
|
||||
*/
|
||||
constructor(seed?: OptionalNumber)
|
||||
/**
|
||||
* Creates an instance of PCGRandom.
|
||||
*
|
||||
* - `seedHi` - The high 32 bits of the seed.
|
||||
* - `seedLo` - The low 32 bits of the seed.
|
||||
* - `inc` - The low 32 bits of the incrementer (0 is used for high 32 bits).
|
||||
*
|
||||
* @memberOf PCGRandom
|
||||
*/
|
||||
constructor(seedHi: OptionalNumber, seedLo: OptionalNumber, inc?: OptionalNumber)
|
||||
/**
|
||||
* Creates an instance of PCGRandom.
|
||||
*
|
||||
* - `seedHi` - The high 32 bits of the seed.
|
||||
* - `seedLo` - The low 32 bits of the seed.
|
||||
* - `incHi` - The high 32 bits of the incrementer.
|
||||
* - `incLo` - The low 32 bits of the incrementer.
|
||||
*
|
||||
* @memberOf PCGRandom
|
||||
*/
|
||||
constructor(
|
||||
seedHi: OptionalNumber,
|
||||
seedLo: OptionalNumber,
|
||||
incHi: OptionalNumber,
|
||||
incLo: OptionalNumber
|
||||
)
|
||||
constructor(
|
||||
seedHi?: OptionalNumber,
|
||||
seedLo?: OptionalNumber,
|
||||
incHi?: OptionalNumber,
|
||||
incLo?: OptionalNumber
|
||||
) {
|
||||
if (isNullable(seedLo) && isNullable(seedHi)) {
|
||||
seedLo = (Math.random() * 0xffffffff) >>> 0
|
||||
seedHi = 0
|
||||
} else if (isNullable(seedLo)) {
|
||||
seedLo = seedHi
|
||||
seedHi = 0
|
||||
}
|
||||
if (isNullable(incLo) && isNullable(incHi)) {
|
||||
incLo = this._state ? this._state[3] : defaultIncLo
|
||||
incHi = this._state ? this._state[2] : defaultIncHi
|
||||
} else if (isNullable(incLo)) {
|
||||
incLo = <number> incHi
|
||||
incHi = 0
|
||||
}
|
||||
|
||||
this._state = new Int32Array([0, 0, (<number> incHi) >>> 0, ((incLo || 0) | 1) >>> 0])
|
||||
this._next()
|
||||
add64(
|
||||
this._state,
|
||||
this._state[0]!,
|
||||
this._state[1]!,
|
||||
(<number> seedHi) >>> 0,
|
||||
(<number> seedLo) >>> 0
|
||||
)
|
||||
this._next()
|
||||
return this
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a copy of the internal state of this random number generator as a
|
||||
* JavaScript Array.
|
||||
*
|
||||
* @category getters
|
||||
* @since 2.0.0
|
||||
*/
|
||||
getState(): PCGRandomState {
|
||||
return [this._state[0]!, this._state[1]!, this._state[2]!, this._state[3]!]
|
||||
}
|
||||
|
||||
/**
|
||||
* Restore state previously retrieved using `getState()`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
*/
|
||||
setState(state: PCGRandomState) {
|
||||
this._state[0] = state[0]
|
||||
this._state[1] = state[1]
|
||||
this._state[2] = state[2]
|
||||
this._state[3] = state[3] | 1
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a uniformly distributed 32 bit integer between [0, max).
|
||||
*
|
||||
* @category getter
|
||||
* @since 2.0.0
|
||||
*/
|
||||
integer(max: number) {
|
||||
return Math.round(this.number() * Number.MAX_SAFE_INTEGER) % max
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a uniformly distributed IEEE-754 double between 0.0 and 1.0, with
|
||||
* 53 bits of precision (every bit of the mantissa is randomized).
|
||||
*
|
||||
* @category getters
|
||||
* @since 2.0.0
|
||||
*/
|
||||
number() {
|
||||
const hi = (this._next() & 0x03ffffff) * 1.0
|
||||
const lo = (this._next() & 0x07ffffff) * 1.0
|
||||
return (hi * BIT_27 + lo) / BIT_53
|
||||
}
|
||||
|
||||
/** @internal */
|
||||
private _next() {
|
||||
// save current state (what we'll use for this number)
|
||||
const oldHi = this._state[0]! >>> 0
|
||||
const oldLo = this._state[1]! >>> 0
|
||||
|
||||
// churn LCG.
|
||||
mul64(this._state, oldHi, oldLo, MUL_HI, MUL_LO)
|
||||
add64(this._state, this._state[0]!, this._state[1]!, this._state[2]!, this._state[3]!)
|
||||
|
||||
// get least sig. 32 bits of ((oldstate >> 18) ^ oldstate) >> 27
|
||||
let xsHi = oldHi >>> 18
|
||||
let xsLo = ((oldLo >>> 18) | (oldHi << 14)) >>> 0
|
||||
xsHi = (xsHi ^ oldHi) >>> 0
|
||||
xsLo = (xsLo ^ oldLo) >>> 0
|
||||
const xorshifted = ((xsLo >>> 27) | (xsHi << 5)) >>> 0
|
||||
// rotate xorshifted right a random amount, based on the most sig. 5 bits
|
||||
// bits of the old state.
|
||||
const rot = oldHi >>> 27
|
||||
const rot2 = ((-rot >>> 0) & 31) >>> 0
|
||||
return ((xorshifted >>> rot) | (xorshifted << rot2)) >>> 0
|
||||
}
|
||||
}
|
||||
|
||||
function mul64(
|
||||
out: Int32Array,
|
||||
aHi: number,
|
||||
aLo: number,
|
||||
bHi: number,
|
||||
bLo: number
|
||||
): void {
|
||||
let c1 = ((aLo >>> 16) * (bLo & 0xffff)) >>> 0
|
||||
let c0 = ((aLo & 0xffff) * (bLo >>> 16)) >>> 0
|
||||
|
||||
let lo = ((aLo & 0xffff) * (bLo & 0xffff)) >>> 0
|
||||
let hi = ((aLo >>> 16) * (bLo >>> 16) + ((c0 >>> 16) + (c1 >>> 16))) >>> 0
|
||||
|
||||
c0 = (c0 << 16) >>> 0
|
||||
lo = (lo + c0) >>> 0
|
||||
if ((lo >>> 0) < (c0 >>> 0)) {
|
||||
hi = (hi + 1) >>> 0
|
||||
}
|
||||
|
||||
c1 = (c1 << 16) >>> 0
|
||||
lo = (lo + c1) >>> 0
|
||||
if ((lo >>> 0) < (c1 >>> 0)) {
|
||||
hi = (hi + 1) >>> 0
|
||||
}
|
||||
|
||||
hi = (hi + Math.imul(aLo, bHi)) >>> 0
|
||||
hi = (hi + Math.imul(aHi, bLo)) >>> 0
|
||||
|
||||
out[0] = hi
|
||||
out[1] = lo
|
||||
}
|
||||
|
||||
// add two 64 bit numbers (given in parts), and store the result in `out`.
|
||||
function add64(
|
||||
out: Int32Array,
|
||||
aHi: number,
|
||||
aLo: number,
|
||||
bHi: number,
|
||||
bLo: number
|
||||
): void {
|
||||
let hi = (aHi + bHi) >>> 0
|
||||
const lo = (aLo + bLo) >>> 0
|
||||
if ((lo >>> 0) < (aLo >>> 0)) {
|
||||
hi = (hi + 1) | 0
|
||||
}
|
||||
out[0] = hi
|
||||
out[1] = lo
|
||||
}
|
||||
|
||||
/**
|
||||
* @since 3.0.6
|
||||
*/
|
||||
export const YieldWrapTypeId: unique symbol = Symbol.for("effect/Utils/YieldWrap")
|
||||
|
||||
/**
|
||||
* @since 3.0.6
|
||||
*/
|
||||
export class YieldWrap<T> {
|
||||
/**
|
||||
* @since 3.0.6
|
||||
*/
|
||||
readonly #value: T
|
||||
constructor(value: T) {
|
||||
this.#value = value
|
||||
}
|
||||
/**
|
||||
* @since 3.0.6
|
||||
*/
|
||||
[YieldWrapTypeId](): T {
|
||||
return this.#value
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @since 3.0.6
|
||||
*/
|
||||
export function yieldWrapGet<T>(self: YieldWrap<T>): T {
|
||||
if (typeof self === "object" && self !== null && YieldWrapTypeId in self) {
|
||||
return self[YieldWrapTypeId]()
|
||||
}
|
||||
throw new Error(getBugErrorMessage("yieldWrapGet"))
|
||||
}
|
||||
|
||||
/**
|
||||
* Note: this is an experimental feature made available to allow custom matchers in tests, not to be directly used yet in user code
|
||||
*
|
||||
* @since 3.1.1
|
||||
* @status experimental
|
||||
* @category modifiers
|
||||
*/
|
||||
export const structuralRegionState = globalValue(
|
||||
"effect/Utils/isStructuralRegion",
|
||||
(): { enabled: boolean; tester: ((a: unknown, b: unknown) => boolean) | undefined } => ({
|
||||
enabled: false,
|
||||
tester: undefined
|
||||
})
|
||||
)
|
||||
|
||||
/**
|
||||
* Note: this is an experimental feature made available to allow custom matchers in tests, not to be directly used yet in user code
|
||||
*
|
||||
* @since 3.1.1
|
||||
* @status experimental
|
||||
* @category modifiers
|
||||
*/
|
||||
export const structuralRegion = <A>(body: () => A, tester?: (a: unknown, b: unknown) => boolean): A => {
|
||||
const current = structuralRegionState.enabled
|
||||
const currentTester = structuralRegionState.tester
|
||||
structuralRegionState.enabled = true
|
||||
if (tester) {
|
||||
structuralRegionState.tester = tester
|
||||
}
|
||||
try {
|
||||
return body()
|
||||
} finally {
|
||||
structuralRegionState.enabled = current
|
||||
structuralRegionState.tester = currentTester
|
||||
}
|
||||
}
|
||||
|
||||
const standard = {
|
||||
effect_internal_function: <A>(body: () => A) => {
|
||||
return body()
|
||||
}
|
||||
}
|
||||
|
||||
const forced = {
|
||||
effect_internal_function: <A>(body: () => A) => {
|
||||
try {
|
||||
return body()
|
||||
} finally {
|
||||
//
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const isNotOptimizedAway =
|
||||
standard.effect_internal_function(() => new Error().stack)?.includes("effect_internal_function") === true
|
||||
|
||||
/**
|
||||
* @since 3.2.2
|
||||
* @status experimental
|
||||
* @category tracing
|
||||
*/
|
||||
export const internalCall = isNotOptimizedAway ? standard.effect_internal_function : forced.effect_internal_function
|
||||
|
||||
const genConstructor = (function*() {}).constructor
|
||||
|
||||
/**
|
||||
* @since 3.11.0
|
||||
*/
|
||||
export const isGeneratorFunction = (u: unknown): u is (...args: Array<any>) => Generator<any, any, any> =>
|
||||
isObject(u) && u.constructor === genConstructor
|
||||
Reference in New Issue
Block a user