typealias 
@moonbitlang/quickcheck/lazy.LazyList
LazyList as LazyList

pub(open) trait Enumerable {
  enumerate() -> Enumerate[Self]
}

pub(all) struct Enumerate[T] {
  parts : 
@moonbitlang/quickcheck/lazy.LazyList
LazyList[Finite[T]]
}

pub(all) struct Finite[T] {
  fCard : 
@moonbitlang/core/bigint.BigInt
BigInt
  fIndex : (
@moonbitlang/core/bigint.BigInt
BigInt) -> T
}

fn[T, U] app(f : Enumerate[(T) -> U], e : Enumerate[T]) -> Enumerate[U]

fn[T] consts(ls : 
@moonbitlang/core/list.T
T[Enumerate[T]]) -> Enumerate[T]

fn[T] default() -> Enumerate[T]

fn[T] empty() -> Enumerate[T]

fn[M, N] fin_app(f : Finite[(M) -> N], e : Finite[M]) -> Finite[N]

fn[M, N] fin_bind(m : Finite[M], f : (M) -> Finite[N]) -> Finite[N]

fn[T, U] fin_cart(f1 : Finite[T], f2 : Finite[U]) -> Finite[(T, U)]

fn[M] fin_concat(m : Array[Finite[M]]) -> Finite[M]

fn[T] fin_empty() -> Finite[T]

fn fin_finite(i : 
@moonbitlang/core/bigint.BigInt
BigInt) -> Finite[
@moonbitlang/core/bigint.BigInt
BigInt]

fn[T, U] fin_fmap(f : (T) -> U, f1 : Finite[T]) -> Finite[U]

fn[M] fin_mconcat(val : 
@moonbitlang/quickcheck/lazy.LazyList
LazyList[Finite[M]]) -> Finite[M]

fn[T] fin_pure(x : T) -> Finite[T]

fn[T] fin_union(f1 : Finite[T], f2 : Finite[T]) -> Finite[T]

fn[T] pay(f : () -> Enumerate[T]) -> Enumerate[T]

fn[T, U] product(e1 : Enumerate[T], e2 : Enumerate[U]) -> Enumerate[(T, U)]

fn[T] singleton(val : T) -> Enumerate[T]

fn[T : Enumerable, U] unary(f : (T) -> U) -> Enumerate[U]

fn[T] union(e1 : Enumerate[T], e2 : Enumerate[T]) -> Enumerate[T]