fn[A] T::append(self : T[A], other : T[A]) -> T[A]
fnalias T::append

fn[A, B] T::bind(self : T[A], k : (A) -> T[B]) -> T[B]
fnalias T::bind

fn[A] T::cons(self : T[A], x : A) -> T[A]
fnalias T::cons

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

fn[A] T::dropWhile(self : T[A], f : (A) -> Bool) -> T[A]
fnalias T::dropWhile

fn[A] T::empty() -> T[A]
fnalias T::empty

fn[A] T::filter(self : T[A], f : (A) -> Bool) -> T[A]
fnalias T::filter

fn[A, B] T::filter_map(self : T[A], f : (A) -> B?) -> T[B]
fnalias T::filter_map

fn[A, B] T::foldl(self : T[A], z : B, f : (B, A) -> B) -> B
fnalias T::foldl

fn[A, B] T::foldr(self : T[A], z : B, f : (B, A) -> B) -> B
fnalias T::foldr

fn[A] T::from_iter(xs : Iter[A]) -> T[A]
fnalias T::from_iter

fn[A] T::from_list(xs : 
@moonbitlang/core/list.List
List[A]) -> T[A]
fnalias T::from_list

fn[A] T::from_rev_list(xs : 
@moonbitlang/core/list.List
List[A]) -> T[A]
fnalias T::from_rev_list

fn[A] T::head(self : T[A]) -> A?
fnalias T::head

fn[A] T::init_(self : T[A]) -> T[A]
fnalias T::init_

fn[A] T::iter(self : T[A]) -> Iter[A]
fnalias T::iter

fn[A] T::join(self : T[T[A]]) -> T[A]
fnalias T::join

fn[A] T::last(self : T[A]) -> A?
fnalias T::last

fn[A, B] T::map(self : T[A], f : (A) -> B) -> T[B]
fnalias T::map

fn[A] T::of(xs : FixedArray[A]) -> T[A]
fnalias T::of

fn[A] T::rev_iter(self : T[A]) -> Iter[A]
fnalias T::rev_iter

fn[A] T::reverse(self : T[A]) -> T[A]
fnalias T::reverse

fn[A] T::singleton(x : A) -> T[A]
fnalias T::singleton

fn[A] T::snoc(self : T[A], x : A) -> T[A]
fnalias T::snoc

fn[A] T::tail(self : T[A]) -> T[A]
fnalias T::tail

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

fn[A] T::takeWhile(self : T[A], f : (A) -> Bool) -> T[A]
fnalias T::takeWhile

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

fn[A] T::uncons(self : T[A]) -> (A, T[A])?
fnalias T::uncons

fn[A] T::unsnoc(self : T[A]) -> (A, T[A])?
fnalias T::unsnoc