🥮 mooncakes.io

    moonbitlang/quickcheck/lazy does not have a README file

    LazyList

    source
    pub(all) enum LazyList[T] {
      Nil
      Cons(T, LazyRef[LazyList[T]])
    }

    impl Add for LazyList[T]
    impl Show for LazyList[T]

    LazyList::concat

    source
    fn[T] LazyList::concat(self : LazyList[T], other : LazyList[T]) -> LazyList[T]

    LazyList::drop

    source
    fn[T] LazyList::drop(self : LazyList[T], n : Int) -> LazyList[T]

    LazyList::drop_while

    source
    fn[T] LazyList::drop_while(self : LazyList[T], p : (T) -> Bool) -> LazyList[T]

    LazyList::fold_left

    source
    fn[T, U] LazyList::fold_left(self : LazyList[T], f : (U, T) -> U, init~ : U) -> U

    LazyList::fold_right

    source
    fn[T, U] LazyList::fold_right(self : LazyList[T], f : (T, U) -> U, init~ : U) -> U

    LazyList::head

    source
    fn[T] LazyList::head(self : LazyList[T]) -> T

    LazyList::index

    source
    fn[T] LazyList::index(self : LazyList[T], i : Int) -> T

    LazyList::length

    source
    fn[T] LazyList::length(self : LazyList[T]) -> Int

    LazyList::map

    source
    fn[T, U] LazyList::map(self : LazyList[T], f : (T) -> U) -> LazyList[U]

    LazyList::split_at

    source
    fn[T] LazyList::split_at(self : LazyList[T], i : Int) -> (LazyList[T], LazyList[T])

    LazyList::tail

    source
    fn[T] LazyList::tail(self : LazyList[T]) -> LazyList[T]

    LazyList::tails

    source
    fn[T] LazyList::tails(self : LazyList[T]) -> LazyList[LazyList[T]]

    LazyList::take

    source
    fn[T] LazyList::take(self : LazyList[T], n : Int) -> LazyList[T]

    LazyList::take_while

    source
    fn[T] LazyList::take_while(self : LazyList[T], p : (T) -> Bool) -> LazyList[T]

    LazyList::unfold

    source
    fn[T] LazyList::unfold(self : LazyList[T], f : (LazyList[T]) -> (T, LazyList[T])?) -> LazyList[T]

    LazyRef

    source
    type LazyRef[T]

    LazyRef::force

    source
    fn[T] LazyRef::force(self : LazyRef[T]) -> T

    LazyRef::from_thunk

    source
    fn[T] LazyRef::from_thunk(f : () -> T) -> LazyRef[T]

    LazyRef::from_value

    source
    fn[T] LazyRef::from_value(val : T) -> LazyRef[T]

    default

    source
    fn[X] default() -> LazyList[X]

    from_list

    source
    fn[T] from_list(ls : 
    T    [T]) -> LazyList[T]

    infinite_stream

    source
    fn[X : Add] infinite_stream(start : X, step : X) -> LazyList[X]

    repeat

    source
    fn[T] repeat(val : T) -> LazyList[T]

    sum

    source
    fn[X : Add] sum(l : LazyList[X], init~ : X) -> X

    to_lazy

    source
    fn[T] to_lazy(ls : 
    T    [T]) -> LazyList[T]

    zip_lazy_normal

    source
    fn[A, B, C] zip_lazy_normal(f : (A, B) -> C, xs : LazyList[A], ys : 
    T    [B]) -> 
    T    [C]

    zip_plus

    source
    fn[T] zip_plus(f : (T, T) -> T, ls1 : LazyList[T], ls2 : LazyList[T]) -> LazyList[T]

    zip_with

    source
    fn[A, B, C] zip_with(f : (A, B) -> C, xs : LazyList[A], ys : LazyList[B]) -> LazyList[C]

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io