README
T
LazyList
- ::concatLazyList::concat
- ::dropLazyList::drop
- ::drop_whileLazyList::drop_while
- ::eachLazyList::each
- ::eachiLazyList::eachi
- ::filterLazyList::filter
- ::flat_mapLazyList::flat_map
- ::flattenLazyList::flatten
- ::fold_leftLazyList::fold_left
- ::fold_rightLazyList::fold_right
- ::from_arrayLazyList::from_array
- ::from_listLazyList::from_list
- ::headLazyList::head
- ::indexLazyList::index
- ::lengthLazyList::length
- ::mapLazyList::map
- ::split_atLazyList::split_at
- ::tailLazyList::tail
- ::tailsLazyList::tails
- ::takeLazyList::take
- ::take_whileLazyList::take_while
- ::to_arrayLazyList::to_array
- ::unfoldLazyList::unfold
- ::unzipLazyList::unzip
- ::zip_lazy_normalLazyList::zip_lazy_normal
- ::zip_withLazyList::zip_with
V
default
V
infinite_stream
V
nats
V
repeat
V
sum
V
zip_plus

lazy-list

Lazy list in MoonBit

lazy

lazy-list

moon add CAIMEOX/lazy-list@0.1.2

Download zip

Author

CAIMEOX

Version

0.1.2

License

MIT

Repository

github.com/CAIMEOX/lazy-list

Last updated

10 months ago

Downloads

Dependencies

CAIMEOX/lazy0.1.0

README

#LazyList

MoonBit lazy list library providing efficient, on-demand evaluation of list operations. The library supports common list operations like map, filter, fold, etc like @immut/list, but evaluates them lazily, only computing elements when needed.

#
LazyList

source

pub(all) enum LazyList[T] {
  Nil
  Cons(T, @CAIMEOX/lazy.Lazy
Lazy[LazyList[T]])
}

A lazy list type that can be either empty (Nil) or a head element with a lazily evaluated tail (Cons).

impl Add for LazyList[T]

impl Eq for LazyList[T]

impl Show for LazyList[T]

#
LazyList::concat

source

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

Concatenates two lazy lists together.

#
LazyList::drop

source

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

Drops the first n elements from a lazy list.

#
LazyList::drop_while

source

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

Drops elements from a lazy list while they satisfy a predicate.

#
LazyList::each

source

fn[T] LazyList::each(self : LazyList[T], f : (T) -> Unit) -> Unit

Applies a function to each element of a lazy list for side effects.

#
LazyList::eachi

source

fn[T] LazyList::eachi(self : LazyList[T], f : (Int, T) -> Unit) -> Unit

Applies a function to each element with its index for side effects.

#
LazyList::filter

source

fn[T] LazyList::filter(self : LazyList[T], pred : (T) -> Bool) -> LazyList[T]

Filters a lazy list using a predicate.

#
LazyList::flat_map

source

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

Flat maps a function over a lazy list.

#
LazyList::flatten

source

fn[T] LazyList::flatten(self : LazyList[LazyList[T]]) -> LazyList[T]

Flattens a lazy list of lazy lists into a single lazy list.

#
LazyList::fold_left

source

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

Left fold over a lazy list.

#
LazyList::fold_right

source

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

Right fold over a lazy list.

#
LazyList::from_array

source

fn[T] LazyList::from_array(ar : Array[T]) -> LazyList[T]

Converts an Array to a LazyList in reverse order.

#
LazyList::from_list

source

fn[T] LazyList::from_list(ls : @moonbitlang/core/list.List
List[T]) -> LazyList[T]

Converts an immutable List to a LazyList.

#
LazyList::head

source

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

Gets the first element of a lazy list.

#
LazyList::index

source

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

Gets the element at a specific index in the lazy list.

#
LazyList::length

source

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

Computes the length of a lazy list.

#
LazyList::map

source

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

Maps a function over a lazy list.

#
LazyList::split_at

source

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

Splits a lazy list at the given index.

#
LazyList::tail

source

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

Gets the tail of a lazy list.

#
LazyList::tails

source

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

Returns a lazy list of all final segments of the original list.

#
LazyList::take

source

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

Takes the first n elements from a lazy list.

#
LazyList::take_while

source

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

Takes elements from a lazy list while they satisfy a predicate.

#
LazyList::to_array

source

fn[T] LazyList::to_array(self : LazyList[T]) -> Array[T]

Converts a lazy list to an array.

#
LazyList::unfold

source

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

Unfolds a lazy list using a generator function.

#
LazyList::unzip

source

fn[T, W] LazyList::unzip(self : LazyList[(T, W)]) -> (LazyList[T], LazyList[W])

Unzips a lazy list of pairs into a pair of lazy lists.

#
LazyList::zip_lazy_normal

source

fn[A, B, C] LazyList::zip_lazy_normal(self : LazyList[A], f : (A, B) -> C, ys : @moonbitlang/core/list.List
List[B]) -> @moonbitlang/core/list.List
List[C]

Zips a lazy list with a normal list using a combining function.

#
LazyList::zip_with

source

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

Zips two lazy lists with a combining function.

#
default

source

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

Creates a default empty lazy list for types that implement Default.

#
infinite_stream

source

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

Creates an infinite lazy list with arithmetic progression.

#
nats

source

fn nats() -> LazyList[Int]

Creates an infinite lazy list of natural numbers starting from 0.

#
repeat

source

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

Creates an infinite lazy list repeating the same value.

#
sum

source

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

Sums the elements of a lazy list with an initial value.

#
zip_plus

source

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

Zips two lazy lists with a combining function, concatenating remaining elements.

Source Files

lazy_list.mbt

Site source Report issue Packages Build queue Skills Statistics

lazy-list

#LazyList

#LazyList

#LazyList::concat

#LazyList::drop

#LazyList::drop_while

#LazyList::each

#LazyList::eachi

#LazyList::filter

#LazyList::flat_map

#LazyList::flatten

#LazyList::fold_left

#LazyList::fold_right

#LazyList::from_array

#LazyList::from_list

#LazyList::head

#LazyList::index

#LazyList::length

#LazyList::map

#LazyList::split_at

#LazyList::tail

#LazyList::tails

#LazyList::take

#LazyList::take_while

#LazyList::to_array

#LazyList::unfold

#LazyList::unzip

#LazyList::zip_lazy_normal

#LazyList::zip_with

#default

#infinite_stream

#nats

#repeat

#sum

#zip_plus

Source Files

#
LazyList

#
LazyList::concat

#
LazyList::drop

#
LazyList::drop_while

#
LazyList::each

#
LazyList::eachi

#
LazyList::filter

#
LazyList::flat_map

#
LazyList::flatten

#
LazyList::fold_left

#
LazyList::fold_right

#
LazyList::from_array

#
LazyList::from_list

#
LazyList::head

#
LazyList::index

#
LazyList::length

#
LazyList::map

#
LazyList::split_at

#
LazyList::tail

#
LazyList::tails

#
LazyList::take

#
LazyList::take_while

#
LazyList::to_array

#
LazyList::unfold

#
LazyList::unzip

#
LazyList::zip_lazy_normal

#
LazyList::zip_with

#
default

#
infinite_stream

#
nats

#
repeat

#
sum

#
zip_plus