README
U
Indexable
U
Predicate
U
RandomRNG
U
Refinement
Tr
Alt
Tr
ConcatToString
Tr
Debug
Tr
FromInt
Tr
FromString
Tr
GetChar
Tr
GetUtf16CodePoint
Tr
JoinToString
Tr
Length
Tr
Monoid
Tr
NumType
Tr
Order
Tr
Ring
Tr
Semigroup
Tr
Semiring
Tr
Slice
Tr
ToByte
Tr
ToChar
Tr
ToInt
Tr
ToString
Tr
UnsignedNum
Tr
WriteToBuffer
Tr
WriteToStringBuilder
Tr
Zero
- ::apApply::ap
- ::innerCursor::inner
- ::op_addCursor::op_add
- ::innerDebugFn::inner
- ::from_optionEither::from_option
- ::is_leftEither::is_left
- ::is_rightEither::is_right
- ::unwrap_leftEither::unwrap_left
- ::unwrap_rightEither::unwrap_right
T
Endianness
- ::arrayFoldable::array
- ::fixed_arrayFoldable::fixed_array
- ::innerFoldable::inner
- ::manyFoldable::many
- ::arrayFoldableWithIndex::array
- ::fixed_arrayFoldableWithIndex::fixed_array
- ::innerFoldableWithIndex::inner
- ::manyFoldableWithIndex::many
T
GetUtf16CharError
- ::chainIReader::chain
- ::mapIReader::map
- ::apIdentity::ap
- ::ap_exnIdentity::ap_exn
- ::mapIdentity::map
- ::tapIdentity::tap
- ::apLazy::ap
- ::ap1Lazy::ap1
- ::chainLazy::chain
- ::getLazy::get
- ::if_memoLazy::if_memo
- ::innerLazy::inner
- ::mapLazy::map
- ::memoLazy::memo
- ::ofLazy::of
- ::sequence_arrayLazy::sequence_array
- ::sequence_manyLazy::sequence_many
- ::string_builderLazy::string_builder
- ::to_readerLazy::to_reader
- ::containsMany::contains
- ::contains_refMany::contains_ref
- ::foldMany::fold
- ::foldiMany::foldi
- ::from_arrayMany::from_array
- ::innerMany::inner
- ::iterMany::iter
- ::makeMany::make
- ::not_containsMany::not_contains
- ::not_contains_refMany::not_contains_ref
- ::op_as_viewMany::op_as_view
- ::op_getMany::op_get
- ::op_setMany::op_set
- ::to_arrayMany::to_array
- ::to_fixed_arrayMany::to_fixed_array
- ::to_showMany::to_show
- ::to_show_arrayMany::to_show_array
- ::innerMonoidPattern::inner
- ::innerNonEmptyString::inner
- ::ofNonEmptyString::of
- ::int_to_orderingOrdering::int_to_ordering
- ::innerPrediate::inner
- ::landPrediate::land
- ::op_getPrediate::op_get
- ::op_negPrediate::op_neg
- ::to_stringPrediate::to_string
- ::_traverse_arrayiReader::_traverse_arrayi
- ::apReader::ap
- ::ap_firstReader::ap_first
- ::ap_secondReader::ap_second
- ::ap_tupleReader::ap_tuple
- ::ap_tuple_revReader::ap_tuple_rev
- ::askReader::ask
- ::ask_readerReader::ask_reader
- ::asksReader::asks
- ::bind_jsonReader::bind_json
- ::bind_mapReader::bind_map
- ::bind_to_jsonReader::bind_to_json
- ::bind_to_mapReader::bind_to_map
- ::chainReader::chain
- ::chain_firstReader::chain_first
- ::composeReader::compose
- ::flattenReader::flatten
- ::from_lazyReader::from_lazy
- ::innerReader::inner
- ::locallyReader::locally
- ::mapReader::map
- ::map_traceReader::map_trace
- ::memoReader::memo
- ::memo_ignore_argReader::memo_ignore_arg
- ::notReader::not
- ::ofReader::of
- ::promapReader::promap
- ::readReader::read
- ::read_curryReader::read_curry
- ::sequence_arrayReader::sequence_array
- ::sequence_fixed_arrayReader::sequence_fixed_array
- ::sequence_manyReader::sequence_many
- ::sequence_mapReader::sequence_map
- ::tapReader::tap
- ::to_refinementReader::to_refinement
- ::to_refinement_revReader::to_refinement_rev
- ::traverse_arrayReader::traverse_array
- ::traverse_arrayiReader::traverse_arrayi
- ::traverse_non_empty_arrayiReader::traverse_non_empty_arrayi
- ::unwrapReader::unwrap
T
ReaderT
- ::arraySequence::array
- ::defaultSequence::default
- ::fixed_arraySequence::fixed_array
- ::getSequence::get
- ::makeSequence::make
- ::manySequence::many
- ::separatedSequence::separated
- ::sequence_transformSequence::sequence_transform
- ::setSequence::set
- ::evaluateState::evaluate
- ::innerState::inner
- ::mapState::map
T
T_Monoid
T
T_Semigroup
- ::to_charUtf16CodePoint::to_char
- ::to_lenUtf16CodePoint::to_len
- ::to_tupleUtf16CodePoint::to_tuple
- ::concatMonoid::concat
- ::emptyMonoid::empty
V
DEBUGGER
V
VERSION
V
__unsafe_cast
V
__unsafe_cast_arrow
V
abort
V
abort_with
V
alt_all
V
alt_all_array
V
alts
V
alts_or
V
arg_loc
V
check_is
V
combine_surrogate_pair_int
V
compose
V
compose_2
V
concat3
V
concat_all
V
concat_all_array
V
concat_all_iter
V
const_empty_array
V
const_empty_string
V
const_false
V
const_identity
V
const_one
V
const_true
V
const_unit
V
const_unit_0
V
const_zero
V
constant
V
constant_0
V
constant_0_from_lazy
V
constant_2
V
constant_as_show
V
constant_exn
V
constant_exn_0
V
constant_from_lazy
V
constant_none
V
curried_2
V
curried_add
V
curried_add_pre
V
curried_apply
V
curried_apply_exn
V
curried_apply_rev
V
curried_concat
V
curried_eq
V
curried_eq_not
V
curried_first
V
curried_is
V
curried_is_not
V
curried_maximum
V
curried_minimum
V
curried_not
V
curried_one_of
V
curried_one_of_not
V
curried_second
V
curried_tuple_fst
V
curried_tuple_map_fst
V
curried_tuple_map_snd
V
curried_tuple_snd
V
curry_1
V
curry_2
V
curry_2_first
V
curry_3
V
curry_4
V
dev_println
V
digit_char_2_int
V
eq
V
get_utf16_char_at
V
hex_2_int
V
hex_2_int_compose
V
hex_2_int_compose_int
V
hex_char_2_int
V
identity
V
ignore2
V
int_be_from_bytes
V
int_from_bytes
V
int_into_bytes
V
int_into_bytes_be
V
int_into_bytes_le
V
int_le_from_bytes
V
int_to_bytes
V
int_to_bytes_be
V
int_to_bytes_le
V
is_empty
V
is_identity
V
is_not
V
is_not_empty
V
iter_append
V
join
V
join3
V
join_all
V
join_array
V
join_fixed_array
V
join_iter
V
join_many
V
lazy_invoke
V
lift_arg
V
lift_arg_0_2
V
lift_arg_2
V
lift_exn
V
lift_exn_0
V
map_fst
V
map_snd
V
memorized
V
memorized_0
V
memorized_ignore_arg
V
not_eq
V
or
V
or_opt
V
or_opt_lazy
V
panic_with
V
raise_exn
V
randomRng
V
random_double
V
random_int
V
random_with
V
safe_string_each
V
safe_string_eachi
V
slice
V
slice_start
V
source_loc
V
to_debug_string
V
to_hex_string
V
to_string
V
unsafe_is
V
write_to_buffer
V
write_to_stringbuilder

shared-lib

[WIP] Personal Utils

utility

Download zip

Author

yuyi919

Version

0.1.7

License

MIT

Last updated

last year

Downloads

#[WIP] Personal Utils

Indexable

source

typealias Sequence[R, Int, A] as Indexable[R, A]

Predicate

source

typealias Reader[A, Bool] as Predicate[A]

RandomRNG

source

typealias State[UInt64, A] as RandomRNG[A]

Refinement

source

typealias Reader[A, B?] as Refinement[A, B]

Alt

source

pub(open) trait Alt {
  lor(Self, Self) -> Self
  alt(Self, Self) -> Self = _
  alt_with(Self, Lazy[Self]) -> Self = _
  alt_many(Self, Many[Self]) -> Self = _
  alt_array(Self, Array[Self]) -> Self = _
}

impl Alt for Option[A]

ConcatToString

source

pub(open) trait ConcatToString : ToString {
  concat_to_string(Self, Self) -> String
}

impl ConcatToString for Char

impl ConcatToString for String

Debug

source

pub(open) trait Debug : Show {
  to_debug_string(Self) -> String = _
}

impl Debug for String

FromInt

source

pub(open) trait FromInt {
  from_int(Int) -> Self
}

impl FromInt for Int

FromString

source

pub(open) trait FromString {
  from_string(String) -> Self
}

GetChar

source

pub(open) trait GetChar {
  op_get(Self, Int) -> Char
}

impl GetChar for String

GetUtf16CodePoint

source

pub(open) trait GetUtf16CodePoint : GetChar + Length {
  get_utf16(Self, Int) -> Utf16CodePoint = _
  get_utf16_exn(Self, Int) -> Utf16CodePoint raise GetUtf16CharError = _
}

JoinToString

source

pub(open) trait JoinToString {
  join_all(Self) -> String
}

impl JoinToString for FixedArray[T]

impl JoinToString for Array[T]

impl JoinToString for Iter[T]

Length

source

pub(open) trait Length {
  length(Self) -> Int
  is_empty(Self) -> Bool = _
}

impl Length for String

impl Length for Option[V]

impl Length for FixedArray[A]

impl Length for Bytes

impl Length for Array[A]

impl Length for Map[K, V]

Monoid

source

pub(open) trait Monoid : Default + Semigroup {
}

NumType

source

pub(open) trait NumType : UnsignedNum + Sub + Neg {
}

Order

source

pub(open) trait Order : Compare {
  order(Self, Self) -> Ordering = _
}

Ring

source

pub(open) trait Ring : Semiring {
  op_sub(Self, Self) -> Self
  op_neg(Self) -> Self
}

impl Ring for Int

Semigroup

source

pub(open) trait Semigroup {
  op_add(Self, Self) -> Self
  concat(Self, Self) -> Self = _
  concat_option(Self, Self?) -> Self = _
  concat_to_option(Self?, Self) -> Self? = _
  concat_many(Self, Many[Self]) -> Self = _
  concat_array(Self, Array[Self]) -> Self = _
  concat_iter(Self, Iter[Self]) -> Self = _
}

impl Semigroup for Unit

impl Semigroup for Int

impl Semigroup for UInt

impl Semigroup for String

impl Semigroup for Option[A]

impl Semigroup for Array[A]

impl Semigroup for WriteToStringBuilder

Semiring

source

pub(open) trait Semiring {
  zero() -> Self
  one() -> Self
  op_add(Self, Self) -> Self
  op_mul(Self, Self) -> Self
}

impl Semiring for Bool

impl Semiring for Byte

impl Semiring for Int

Slice

source

pub(open) trait Slice : Length {
  op_as_view(Self, start~ : Int, end~ : Int) -> Self
}

impl Slice for String

impl Slice for FixedArray[Z]

impl Slice for Array[Z]

ToByte

source

pub(open) trait ToByte {
  to_byte(Self) -> Byte
}

impl ToByte for Int

ToChar

source

pub(open) trait ToChar {
  to_char(Self) -> Char
}

impl ToChar for Char

impl ToChar for Int

ToInt

source

pub(open) trait ToInt {
  to_int(Self) -> Int
}

impl ToInt for Int

ToString

source

pub(open) trait ToString {
  to_string(Self) -> String
}

impl ToString for Char

impl ToString for String

impl ToString for StringBuilder

UnsignedNum

source

pub(open) trait UnsignedNum : FromInt + ToInt + ToByte + Add + Mul + Zero {
  one() -> Self = _
}

WriteToBuffer

source

pub(open) trait WriteToBuffer : Show {
  write_to(Self, @moonbitlang/core/buffer.T
T) -> Unit
}

impl WriteToBuffer for Byte

impl WriteToBuffer for Char

impl WriteToBuffer for String

impl WriteToBuffer for Bytes

WriteToStringBuilder

source

pub(open) trait WriteToStringBuilder : Show {
  write_to(Self, StringBuilder) -> Unit
}

impl WriteToStringBuilder for Char

impl WriteToStringBuilder for String

impl WriteToStringBuilder for Option[T]

impl WriteToStringBuilder for StringBuilder

Zero

source

pub(open) trait Zero {
  zero() -> Self
}

impl Zero for Int

impl Zero for Int16

impl Zero for Int64

impl Zero for UInt

impl Zero for UInt16

impl Zero for UInt64

impl Zero for Float

impl Zero for Double

Apply

source

#external
pub(all) type Apply

Apply::ap

source

fn[A, B] Apply::ap(self : Reader[A, B], a : A) -> B

Cursor

source

pub(all) type Cursor Int

impl Compare for Cursor

impl Default for Cursor

impl Eq for Cursor

impl Hash for Cursor

impl Show for Cursor

impl ToJson for Cursor

impl ToInt for Cursor

Cursor::inner

source

fn Cursor::inner(self : Cursor) -> Int

Convert newtype to its underlying type, automatically derived.

Cursor::op_add

source

fn Cursor::op_add(a : Cursor, b : Cursor) -> Cursor

DebugFn

source

pub(all) type DebugFn[A] () -> A

impl Show for DebugFn[A]

DebugFn::inner

source

fn[A] DebugFn::inner(self : DebugFn[A]) -> (() -> A)

Convert newtype to its underlying type, automatically derived.

Either

source

pub(all) enum Either[L, R] {
  Left(L)
  Right(R)
}

impl Show for Either[L, R]

Either::from_option

source

fn[A, B] Either::from_option(option : A?, or : B) -> Either[B, A]

Either::is_left

source

fn[A, B] Either::is_left(self : Either[A, B]) -> Bool

Either::is_right

source

fn[A, B] Either::is_right(self : Either[A, B]) -> Bool

Either::unwrap_left

source

fn[A, B] Either::unwrap_left(self : Either[A, B]) -> A

Either::unwrap_right

source

fn[A, B] Either::unwrap_right(self : Either[A, B]) -> B

Endianness

source

pub(all) enum Endianness {
  LittleEndian
  BigEndian
  NetworkEndian
}

Byte order, aka "endianness".

LittleEndian: Little-endian.
BigEndian: Big-endian.
NetworkEndian: Network byte order defined by IETF RFC 1700.

note:

Little-endian is the de-facto standard practice for current computer architectures, and the standardized byte order of WASM.
NativeEndian (system native-endian) may be introduced in the future.

impl Eq for Endianness

impl Show for Endianness

Foldable

source

pub(all) type Foldable[R, A, B] (R, B, (B, A) -> B) -> B

Foldable::array

source

fn[A, B] Foldable::array() -> Foldable[Array[A], A, B]

Foldable::fixed_array

source

fn[A, B] Foldable::fixed_array() -> Foldable[FixedArray[A], A, B]

Foldable::inner

source

fn[R, A, B] Foldable::inner(self : Foldable[R, A, B]) -> ((R, B, (B, A) -> B) -> B)

Convert newtype to its underlying type, automatically derived.

Foldable::many

source

fn[A, B] Foldable::many() -> Foldable[Many[A], A, B]

FoldableWithIndex

source

pub(all) type FoldableWithIndex[R, A, B] (R, B, (Int, B, A) -> B) -> B

FoldableWithIndex::array

source

fn[A, B] FoldableWithIndex::array() -> FoldableWithIndex[Array[A], A, B]

FoldableWithIndex::fixed_array

source

fn[A, B] FoldableWithIndex::fixed_array() -> FoldableWithIndex[FixedArray[A], A, B]

FoldableWithIndex::inner

source

fn[R, A, B] FoldableWithIndex::inner(self : FoldableWithIndex[R, A, B]) -> ((R, B, (Int, B, A) -> B) -> B)

Convert newtype to its underlying type, automatically derived.

FoldableWithIndex::many

source

fn[A, B] FoldableWithIndex::many() -> FoldableWithIndex[Many[A], A, B]

GetUtf16CharError

source

pub(all) enum GetUtf16CharError {
  OutOfRange(Int, Int)
  InvalidStringHighSurrogate
  InvalidStringLowSurrogate
  UnreachableCode(Int)
}

impl Show for GetUtf16CharError

IReader

source

#external
pub(all) type IReader

IReader::chain

source

fn[R, A, B] IReader::chain(ab : (R) -> A, bc : (A) -> ((R) -> B)) -> ((R) -> B)

IReader::map

source

fn[R, A, B] IReader::map(ab : (R) -> A, bc : (A) -> B) -> ((R) -> B)

Identity

source

#external
pub type Identity

Identity::ap

source

fn[A, B] Identity::ap(ab : (A) -> B, a : A) -> B

Identity::ap_exn

source

fn[A, B, E : Error] Identity::ap_exn(ab : (A) -> B raise E, a : A) -> B raise E

Identity::map

source

fn[A, B] Identity::map(a : A, f : (A) -> B) -> B

Identity::tap

source

fn[A, B] Identity::tap(a : A, f : (A) -> B) -> A

Lazy

source

pub(all) type Lazy[A] () -> A

impl Default for Lazy[A]

impl Semigroup for Lazy[A]

Lazy::ap

source

fn[A, B] Lazy::ap(lazy_ab : Lazy[(A) -> B], lazy_a : Lazy[A]) -> Lazy[B]

Lazy::ap1

source

fn[A, A1, B] Lazy::ap1(lazy_ab : Lazy[(A, A1) -> B], lazy_a : Lazy[A], lazy_a1 : Lazy[A1]) -> Lazy[B]

Lazy::chain

source

fn[A, T2] Lazy::chain(lazy_ : Lazy[A], f : (A) -> Lazy[T2]) -> Lazy[T2]

Lazy::get

source

fn[A] Lazy::get(lazy_ : Lazy[A]) -> A

Lazy::if_memo

source

fn[A] Lazy::if_memo(lazy_ : Lazy[A], cond : Bool) -> Lazy[A]

Lazy::inner

source

fn[A] Lazy::inner(self : Lazy[A]) -> (() -> A)

Convert newtype to its underlying type, automatically derived.

Lazy::map

source

fn[A, T2] Lazy::map(lazy_ : Lazy[A], f : (A) -> T2) -> Lazy[T2]

Lazy::memo

source

fn[A] Lazy::memo(lazy_ : Lazy[A]) -> Lazy[A]

Lazy::of

source

fn[A] Lazy::of(lazy_ : A) -> Lazy[A]

Lazy::sequence_array

source

fn[A] Lazy::sequence_array(lazy_ : Array[Lazy[A]]) -> Lazy[Array[A]]

Lazy::sequence_many

source

fn[A] Lazy::sequence_many(lazy_ : Many[Lazy[A]]) -> Lazy[Many[A]]

Lazy::string_builder

source

fn Lazy::string_builder() -> StringBuilder

Lazy::to_reader

source

fn[R, A] Lazy::to_reader(lazy_ : Lazy[A]) -> Reader[R, A]

Many

source

pub(all) type Many[A] FixedArray[A]

impl Default for Many[A]

impl Show for Many[A]

impl JoinToString for Many[T]

impl Length for Many[A]

impl Slice for Many[A]

Many::contains

source

fn[A : Eq] Many::contains(self : Many[A], val : A) -> Bool

Many::contains_ref

source

fn[A] Many::contains_ref(self : Many[A], val : A) -> Bool

Many::fold

source

fn[A, B] Many::fold(self : Many[A], init~ : B, f : (B, A) -> B) -> B

Many::foldi

source

fn[A, B] Many::foldi(self : Many[A], init~ : B, f : (Int, B, A) -> B) -> B

Many::from_array

source

fn[A] Many::from_array(array : Array[A]) -> Many[A]

Many::inner

source

fn[A] Many::inner(self : Many[A]) -> FixedArray[A]

Convert newtype to its underlying type, automatically derived.

Many::iter

source

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

Many::make

source

fn[A] Many::make(len : Int, init : A) -> Many[A]

Many::not_contains

source

fn[A : Eq] Many::not_contains(self : Many[A], val : A) -> Bool

Many::not_contains_ref

source

fn[A] Many::not_contains_ref(self : Many[A], val : A) -> Bool

Many::op_as_view

source

fn[A] Many::op_as_view(self : Many[A], start~ : Int, end? : Int) -> Many[A]

Many::op_get

source

fn[A] Many::op_get(self : Many[A], i : Int) -> A

Many::op_set

source

fn[A] Many::op_set(self : Many[A], i : Int, v : A) -> Unit

Many::to_array

source

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

Many::to_fixed_array

source

fn[A] Many::to_fixed_array(self : Many[A]) -> FixedArray[A]

Many::to_show

source

fn[I : Show] Many::to_show(self : Many[I]) -> Many[Show]

Many::to_show_array

source

fn[I : Show] Many::to_show_array(self : Many[I]) -> Array[Show]

MonoidPattern

source

pub(all) type MonoidPattern[A] (T_Monoid[A], A)

MonoidPattern::inner

source

fn[A] MonoidPattern::inner(self : MonoidPattern[A]) -> (T_Monoid[A], A)

Convert newtype to its underlying type, automatically derived.

NonEmptyString

source

pub type NonEmptyString String

impl Compare for NonEmptyString

impl Eq for NonEmptyString

impl Show for NonEmptyString

impl FromString for NonEmptyString

impl GetChar for NonEmptyString

impl Length for NonEmptyString

impl Semigroup for NonEmptyString

NonEmptyString::inner

source

fn NonEmptyString::inner(self : NonEmptyString) -> String

Convert newtype to its underlying type, automatically derived.

NonEmptyString::of

source

fn NonEmptyString::of(str : String) -> NonEmptyString

Ordering

source

pub(all) enum Ordering {
  Less
  Greater
  Eq
}

impl Eq for Ordering

impl Show for Ordering

Ordering::int_to_ordering

source

fn Ordering::int_to_ordering(i : Int) -> Ordering

Prediate

source

pub(all) type Prediate[A] ((A) -> Bool, Show)

impl Show for Prediate[A]

impl Alt for Prediate[A]

Prediate::inner

source

fn[A] Prediate::inner(self : Prediate[A]) -> ((A) -> Bool, Show)

Convert newtype to its underlying type, automatically derived.

Prediate::land

source

fn[A] Prediate::land(self : Prediate[A], orw : Prediate[A]) -> Prediate[A]

Prediate::op_get

source

fn[A] Prediate::op_get(self : Prediate[A], arg : A) -> Bool

Prediate::op_neg

source

fn[A] Prediate::op_neg(self : Prediate[A]) -> Prediate[A]

Prediate::to_string

source

fn[A] Prediate::to_string(self : Prediate[A]) -> String

Reader

source

pub(all) type Reader[R, A] (R) -> A

impl Default for Reader[R, A]

impl Semigroup for Reader[R, A]

Reader::_traverse_arrayi

source

fn[R, A, B] Reader::_traverse_arrayi(arr : Array[A], f : (Int, A) -> Reader[R, B]) -> Reader[R, Array[B]]

Reader::ap

source

fn[R, A, B] Reader::ap(fab : Reader[R, (A) -> B], fa : Reader[R, A]) -> Reader[R, B]

Reader::ap_first

source

fn[R, A, B] Reader::ap_first(fa : Reader[R, A], fb : Reader[R, B]) -> Reader[R, A]

Reader::ap_second

source

fn[R, A, B] Reader::ap_second(fa : Reader[R, A], fb : Reader[R, B]) -> Reader[R, B]

Reader::ap_tuple

source

fn[R, A, B] Reader::ap_tuple(fa : Reader[R, A], fb : Reader[R, B]) -> Reader[R, (A, B)]

Reader::ap_tuple_rev

source

fn[R, A, B] Reader::ap_tuple_rev(fa : Reader[R, A], fb : Reader[R, B]) -> Reader[R, (B, A)]

Reader::ask

source

fn[R] Reader::ask() -> Reader[R, R]

Reader::ask_reader

source

fn[R, A] Reader::ask_reader(f : (R) -> Reader[R, A]) -> Reader[R, A]

Reader::asks

source

fn[R, A] Reader::asks(f : (R) -> A) -> Reader[R, A]

Reader::bind_json

source

fn[R, A : ToJson] Reader::bind_json(self : Reader[R, Json], key : String, fa : Reader[R, A]) -> Reader[R, Json]

Reader::bind_map

source

fn[R, K : Hash + Eq, A] Reader::bind_map(self : Reader[R, Map[K, A]], key : K, fa : Reader[R, A]) -> Reader[R, Map[K, A]]

Reader::bind_to_json

source

fn[R, A : ToJson] Reader::bind_to_json(self : Reader[R, A], key : String) -> Reader[R, Json]

Reader::bind_to_map

source

fn[R, K : Hash + Eq, A] Reader::bind_to_map(self : Reader[R, A], key : K) -> Reader[R, Map[K, A]]

Reader::chain

source

fn[R, A, B] Reader::chain(self : Reader[R, A], f : (A) -> Reader[R, B]) -> Reader[R, B]

Reader::chain_first

source

fn[R, A, B] Reader::chain_first(self : Reader[R, A], f : (A) -> Reader[R, B]) -> Reader[R, A]

Reader::compose

source

fn[A, B, C] Reader::compose(ab : Reader[A, B], bc : Reader[B, C]) -> Reader[A, C]

Reader::flatten

source

fn[R, A] Reader::flatten(self : Reader[R, Reader[R, A]]) -> Reader[R, A]

Reader::from_lazy

source

fn[R, A] Reader::from_lazy(lazy_ : Lazy[A]) -> Reader[R, A]

Reader::inner

source

fn[R, A] Reader::inner(self : Reader[R, A]) -> ((R) -> A)

Convert newtype to its underlying type, automatically derived.

Reader::locally

source

fn[R, A, R2] Reader::locally(self : Reader[R, A], f : (R2) -> R) -> Reader[R2, A]

Reader::map

source

fn[R, A, B] Reader::map(self : Reader[R, A], f : (A) -> B) -> Reader[R, B]

Reader::map_trace

source

fn[R, A, B] Reader::map_trace(self : Reader[R, A], f : (A, R) -> B) -> Reader[R, B]

Reader::memo

source

fn[K : Hash + Eq, V] Reader::memo(f : Reader[K, V]) -> Reader[K, V]

Reader::memo_ignore_arg

source

fn[K, V] Reader::memo_ignore_arg(f : Reader[K, V]) -> Reader[K, V]

Creates a memoized version of a reader that caches the first result and returns it for all subsequent calls, regardless of the input value.

Parameters:

reader : A reader function of type Reader[K, V] that takes an input of type K and produces an output of type V.

Returns a new reader that will compute the value only once on its first call and return the cached value for all subsequent calls.

Example:

test "Reader::memo_ignore_arg" {
  let counter = StringBuilder::new()
  let reader = Reader(fn(x : Int) {
    counter.write_string("computed\n")
    42
  })
  let memoized = Reader::memo_ignore_arg(reader)
  inspect!(memoized.read(1), content="42")
  inspect!(memoized.read(2), content="42")
  inspect!(counter.to_string(), content="computed\n")
}

Reader::not

source

fn[A] Reader::not(pred : Reader[A, Bool]) -> Reader[A, Bool]

Reader::of

source

fn[R, A] Reader::of(a : A) -> Reader[R, A]

Reader::promap

source

fn[E, A, B, D] Reader::promap(fea : Reader[E, A], f : (D) -> E, g : (A) -> B) -> Reader[D, B]

Reader::read

source

fn[R, A] Reader::read(reader : Reader[R, A], arg : R) -> A

Reader::read_curry

source

fn[R, A] Reader::read_curry(arg : R) -> ((Reader[R, A]) -> A)

Reader::sequence_array

source

fn[R, A] Reader::sequence_array(arr : Array[Reader[R, A]]) -> Reader[R, Array[A]]

Reader::sequence_fixed_array

source

fn[R, A] Reader::sequence_fixed_array(arr : FixedArray[Reader[R, A]]) -> Reader[R, FixedArray[A]]

Reader::sequence_many

source

fn[R, A] Reader::sequence_many(arr : Many[Reader[R, A]]) -> Reader[R, Many[A]]

Reader::sequence_map

source

fn[R, K : Hash + Eq, A] Reader::sequence_map(map : Map[K, Reader[R, A]]) -> Reader[R, Map[K, A]]

Reader::tap

source

fn[R, A, B] Reader::tap(fa : Reader[R, A], f : (A) -> B) -> Reader[R, A]

Reader::to_refinement

source

fn[A] Reader::to_refinement(pred : Reader[A, Bool]) -> Reader[A, A?]

Reader::to_refinement_rev

source

fn[A] Reader::to_refinement_rev(pred : Reader[A, Bool]) -> Reader[A, A?]

Reader::traverse_array

source

fn[R, A, B] Reader::traverse_array(f : (A) -> Reader[R, B]) -> ((Array[A]) -> Reader[R, Array[B]])

Reader::traverse_arrayi

source

fn[R, A, B] Reader::traverse_arrayi(f : (Int, A) -> Reader[R, B]) -> ((Array[A]) -> Reader[R, Array[B]])

Reader::traverse_non_empty_arrayi

source

fn[R, A, B] Reader::traverse_non_empty_arrayi(f : (Int, A) -> Reader[R, B]) -> ((Array[A]) -> Reader[R, Array[B]])

Reader::unwrap

source

fn[A, B] Reader::unwrap(self : Reader[A, B]) -> ((A) -> B)

ReaderT

source

#external
pub type ReaderT

Sequence

source

pub(all) struct Sequence[R, I, A] {
  make : (Int, A) -> R
  op_get : (R, I) -> A
  op_set : (R, I, A) -> Unit
}

Sequence::array

source

fn[A] Sequence::array() -> Sequence[Array[A], Int, A]

Sequence::default

source

fn[R : Default, I, A] Sequence::default(_self : Sequence[R, I, A]) -> R

Sequence::fixed_array

source

fn[A] Sequence::fixed_array() -> Sequence[FixedArray[A], Int, A]

Sequence::get

source

fn[R, I, A] Sequence::get(self : Sequence[R, I, A], r : R, i : I) -> A

Sequence::make

source

fn[R, I, A] Sequence::make(self : Sequence[R, I, A], len : Int, init~ : A) -> R

Sequence::many

source

fn[A] Sequence::many() -> Sequence[Many[A], Int, A]

Sequence::separated

source

fn[RA : Length, RB : Default, RC : Default, A, B, C] Sequence::separated(self : Sequence[RA, Int, A], fb~ : Sequence[RB, Int, B], fc~ : Sequence[RC, Int, C], input : RA, f : (A) -> (B, C)) -> (RB, RC)

Sequence::sequence_transform

source

fn[T1 : Length, A, B, T2 : Default] Sequence::sequence_transform(self : Sequence[T1, Int, A], input : T1, f : (A) -> B, target~ : Sequence[T2, Int, B]) -> T2

Sequence::set

source

fn[R, I, A] Sequence::set(self : Sequence[R, I, A], r : R, i : I, a : A) -> Unit

State

source

pub(all) type State[S, A] (S) -> (A, S)

State::evaluate

source

fn[S, A] State::evaluate(self : State[S, A], state : S) -> A

State::inner

source

fn[S, A] State::inner(self : State[S, A]) -> ((S) -> (A, S))

Convert newtype to its underlying type, automatically derived.

State::map

source

fn[S, A, B] State::map(state : State[S, A], f : (A) -> B) -> State[S, B]

T_Monoid

source

pub(all) struct T_Monoid[A] {
  empty : () -> A
  concat : (A, A) -> A
}

T_Semigroup

source

pub(all) struct T_Semigroup[A] {
  concat : (A, A) -> A
}

Utf16CodePoint

source

pub(all) enum Utf16CodePoint {
  BMP(Char)
  HighSurrogate(Char)
  LowSurrogate(Char)
}

The type of a word (16-bit) appears in a UTF-16 sequence:

BMP: Basic Multilingual Plane. (including 0x0000–0xD7FF and 0xE000–0xFFFF)
HighSurrogate: The first word of a surrogate pair. (including 0xD800–0xDBFF)
LowSurrogate: The second word of a surrogate pair. (including 0xDC00–0xDFFF)

impl Eq for Utf16CodePoint

impl Show for Utf16CodePoint

Utf16CodePoint::to_char

source

fn Utf16CodePoint::to_char(self : Utf16CodePoint) -> Char

Utf16CodePoint::to_len

source

fn Utf16CodePoint::to_len(self : Utf16CodePoint) -> Int

Utf16CodePoint::to_tuple

source

fn Utf16CodePoint::to_tuple(self : Utf16CodePoint) -> (Char, Int)

Monoid

Monoid::concat

source

fn[A : Monoid + Default + Semigroup] Monoid::concat(x : A, y : A) -> A

Monoid::empty

source

fn[A : Monoid + Default + Semigroup] Monoid::empty() -> A

DEBUGGER

source

let DEBUGGER : Bool

VERSION

source

let VERSION : String

__unsafe_cast

source

fn[A, B] __unsafe_cast(a : A) -> B

__unsafe_cast_arrow

source

fn[A, B, C, D] __unsafe_cast_arrow(a : (A) -> C) -> ((B) -> D)

abort

source

fn[T, A : Debug + Show] abort(msg : A, loc~ : SourceLoc = _) -> T

abort_with

source

fn[T, A : Debug + Show] abort_with(f : () -> A, loc~ : SourceLoc = _) -> T

alt_all

source

fn[A : Alt + Zero] alt_all(x : Many[A]) -> A

alt_all_array

source

fn[A : Alt + Zero] alt_all_array(x : Array[A]) -> A

alts

source

fn[A : Alt] alts(x : Many[A]) -> A

alts_or

source

fn[A : Alt] alts_or(x : Many[A], or_else : Lazy[A]) -> A

arg_loc

source

fn arg_loc(loc~ : ArgsLoc = _) -> ArgsLoc

check_is

source

fn[A] check_is(a : A, b : A) -> Bool

combine_surrogate_pair_int

source

fn combine_surrogate_pair_int(high : Int, low : Int) -> Char

compose

source

fn[A, B, C] compose(fa : (A) -> B, fb : (B) -> C) -> ((A) -> C)

compose_2

source

fn[A, B, C, D] compose_2(fa : (A) -> B, fb : (B) -> C, fc : (C) -> D) -> ((A) -> D)

concat3

source

fn[A : Semigroup] concat3(a : A, b : A, c : A) -> A

concat_all

source

fn[A : Monoid + Default + Semigroup] concat_all(x : Many[A]) -> A

concat_all_array

source

fn[A : Monoid + Default + Semigroup] concat_all_array(x : Array[A]) -> A

concat_all_iter

source

fn[A : Monoid + Default + Semigroup] concat_all_iter(x : Iter[A]) -> A

const_empty_array

source

fn[A, B] const_empty_array(_a : A) -> Array[B]

const_empty_string

source

fn[A] const_empty_string(_arg : A) -> String

const_false

source

fn[A] const_false(_a : A) -> Bool

const_identity

source

fn[N, A] const_identity(_n : N) -> ((A) -> A)

const_one

source

fn[A] const_one(_arg : A) -> Int

const_true

source

fn[A] const_true(_arg : A) -> Bool

const_unit

source

fn[A] const_unit(_ : A) -> Unit

const_unit_0

source

fn const_unit_0() -> Unit

const_zero

source

fn[A] const_zero(_arg : A) -> Int

constant

source

fn[N, A] constant(a : A) -> ((N) -> A)

constant_0

source

fn[A] constant_0(a : A) -> (() -> A)

constant_0_from_lazy

source

fn[A] constant_0_from_lazy(a : Lazy[A]) -> (() -> A)

constant_2

source

fn[N, N2, A] constant_2(a : A) -> ((N, N2) -> A)

constant_as_show

source

fn[I : Show] constant_as_show(a : I) -> Show

constant_exn

source

fn[R, A, E : Error] constant_exn(a : E) -> ((R) -> A raise E)

constant_exn_0

source

fn[A, E : Error] constant_exn_0(a : E) -> (() -> A raise E)

constant_from_lazy

source

fn[R, A] constant_from_lazy(a : Lazy[A]) -> ((R) -> A)

constant_none

source

fn[A] constant_none() -> A?

curried_2

source

fn[T, U, V, W] curried_2(f : (T, U, W) -> V, y : U, z : W) -> ((T) -> V)

Curry a function.

curried_add

source

fn[A : Semigroup] curried_add(a : A) -> ((A) -> A)

curried_add_pre

source

fn[A : Semigroup] curried_add_pre(a : A) -> ((A) -> A)

curried_apply

source

fn[A, B] curried_apply(a : A) -> (((A) -> B) -> B)

curried_apply_exn

source

fn[A, B, E : Error] curried_apply_exn(a : A) -> (((A) -> B raise E) -> B raise E)

curried_apply_rev

source

fn[A, B] curried_apply_rev(a : (A) -> B) -> ((A) -> B)

curried_concat

source

fn[A : Semigroup] curried_concat(x : A, y : A) -> A

curried_eq

source

fn[A : Eq] curried_eq(a : A) -> ((A) -> Bool)

curried_eq_not

source

fn[A : Eq] curried_eq_not(a : A) -> ((A) -> Bool)

curried_first

source

fn[T, U, V] curried_first(f : (T, U) -> V, y : U) -> ((T) -> V)

Curry a function.

Example

let add = fn(x : Int, y : String) -> String { x.to_string() + y }
let curried_add = @lib.curried_first(add, "str")
assert_eq!(curried_add(1), "1str")

curried_is

source

fn[A] curried_is(a : A) -> ((A) -> Bool)

curried_is_not

source

fn[A] curried_is_not(a : A) -> ((A) -> Bool)

curried_maximum

source

fn[A : Compare + Eq] curried_maximum(a : A) -> ((A) -> A)

curried_minimum

source

fn[A : Compare + Eq] curried_minimum(a : A) -> ((A) -> A)

curried_not

source

fn[T, U] curried_not(f : (T, U) -> Bool, x : T) -> ((U) -> Bool)

curried_one_of

source

fn[A : Eq] curried_one_of(a : Many[A]) -> ((A) -> Bool)

curried_one_of_not

source

fn[A : Eq] curried_one_of_not(a : Many[A]) -> ((A) -> Bool)

curried_second

source

fn[T, U, V] curried_second(f : (T, U) -> V, x : T) -> ((U) -> V)

Curry a function.

Example

let add = fn(x : Int, y : String) -> String { x.to_string() + y }
let curried_add = @lib.curried_second(add, 1)
assert_eq!(curried_add("str"), "1str")

curried_tuple_fst

source

fn[A, B] curried_tuple_fst(a : A) -> ((B) -> (A, B))

curried_tuple_map_fst

source

fn[T, U, V] curried_tuple_map_fst(f : (T) -> U) -> (((T, V)) -> (U, V))

curried_tuple_map_snd

source

fn[T, U, V] curried_tuple_map_snd(f : (T) -> U) -> (((V, T)) -> (V, U))

curried_tuple_snd

source

fn[A, B] curried_tuple_snd(a : A) -> ((B) -> (B, A))

curry_1

source

fn[A, B, C] curry_1(f : (A, B) -> C) -> ((A) -> ((B) -> C))

curry_2

source

fn[A, B, C, D] curry_2(f : (A, B, C) -> D) -> ((A) -> ((B) -> ((C) -> D)))

curry_2_first

source

fn[A, B, C, D] curry_2_first(f : (A, B, C) -> D) -> ((A) -> ((B, C) -> D))

curry_3

source

fn[A, B, C, D, E] curry_3(f : (A, B, C, D) -> E) -> ((A) -> ((B) -> ((C) -> ((D) -> E))))

curry_4

source

fn[A, B, C, D, E, F] curry_4(f : (A, B, C, D, E) -> F) -> ((A) -> ((B) -> ((C) -> ((D) -> ((E) -> F)))))

dev_println

source

fn[T : Show] dev_println(input : T) -> Unit

digit_char_2_int

source

fn digit_char_2_int(char : Char) -> Int

Converts a character representing a digit to its corresponding integer value.

Parameters:

char : A character in the range '0' to '9'.

Returns the integer value of the digit.

Throws a panic error if the input character is not a valid digit.

Example:

test "digit_2_int" {
  inspect!(digit_2_int('5'), content="5")
  inspect!(digit_2_int('0'), content="0")
}

test "panic digit_2_int/invalid_char" {
  let _ = digit_2_int('a')

}

eq

source

fn[A : Eq] eq(x : A, y : A) -> Bool

get_utf16_char_at

source

fn[T : GetUtf16CodePoint + GetChar + Length] get_utf16_char_at(input : T, idx_word : Int) -> Utf16CodePoint

Get the char appeared at n-th word (16-bit) of input string.

Examples

Iterate a string including U+10000 by valid chars (unicode code point) using a while loop:

let str = "\u{6708}\u{1f430}\u{5154}" // 月🐰兔
let mut i = 0
while i < str.length() {
  let (ch, ty) = get_utf16_char_at(str, i)
  println(ch)

  // advance by 2 words on a surrogate pair
  i += if ty != Utf16WordType::BMP { 1 } else { 2 }
}

Panics

Panics if index out of range, or any invalid value (code point or surrogate pair) appears at specified position.

hex_2_int

source

fn hex_2_int(str : String) -> Int

hex_2_int_compose

source

fn hex_2_int_compose(int : Int, i : Int, char : Char) -> Int

hex_2_int_compose_int

source

fn hex_2_int_compose_int(int : Int, i : Int, int2 : Int) -> Int

hex_char_2_int

source

fn hex_char_2_int(char : Char) -> Int

identity

source

fn[A] identity(a : A) -> A

ignore2

source

fn[A, B] ignore2(_a : A, _b : B) -> Unit

int_be_from_bytes

source

fn int_be_from_bytes(bytes : FixedArray[Byte], offset : Int) -> Int

Extract an Int from certain position of FixedArray[Byte] by big-endian.

Panics

4 bytes of data are required from offset position. Panics when insufficient.

int_from_bytes

source

fn int_from_bytes(bytes : FixedArray[Byte], offset : Int, endian : Endianness, source~ : SourceLoc = _) -> Int

Extract an Int from certain position of FixedArray[Byte] by specified endianness.

Panics

4 bytes of data are required from offset position. Panics when insufficient.

int_into_bytes

source

fn int_into_bytes(v : Int, endian : Endianness, target : FixedArray[Byte], offset : Int) -> Unit

Write bytes representation of an Int by specified endianness into target FixedArray[Byte] at certain offset.

Panics

4 bytes of data are required from offset position. Panics when insufficient.

int_into_bytes_be

source

fn int_into_bytes_be(v : Int, target : FixedArray[Byte], offset : Int) -> Unit

Write bytes representation of an Int by big-endian into target FixedArray[Byte] at certain offset.

Panics

4 bytes of data are required from offset position. Panics when insufficient.

int_into_bytes_le

source

fn int_into_bytes_le(v : Int, target : FixedArray[Byte], offset : Int) -> Unit

Write bytes representation of an Int by little-endian into target FixedArray[Byte] at certain offset.

Panics

4 bytes of data are required from offset position. Panics when insufficient.

int_le_from_bytes

source

fn int_le_from_bytes(bytes : FixedArray[Byte], offset : Int) -> Int

Extract an Int from certain position of FixedArray[Byte] by little-endian.

Panics

4 bytes of data are required from offset position. Panics when insufficient.

int_to_bytes

source

fn int_to_bytes(v : Int, endian : Endianness) -> FixedArray[Byte]

Get bytes representation of an Int by specified endianness.

int_to_bytes_be

source

fn int_to_bytes_be(v : Int) -> FixedArray[Byte]

Get bytes representation of an Int by big-endian.

int_to_bytes_le

source

fn int_to_bytes_le(v : Int) -> FixedArray[Byte]

Get bytes representation of an Int by little-endian.

is_empty

source

fn[T : Length] is_empty(target : T) -> Bool

is_identity

source

fn[A, B] is_identity(a : (A) -> B) -> Bool

is_not

source

fn[A] is_not(a : A, b : A) -> Bool

is_not_empty

source

fn[T : Length] is_not_empty(target : T) -> Bool

iter_append

source

fn[T] iter_append(iter : Iter[T], a : T) -> Iter[T]

join

source

fn[A : WriteToStringBuilder + Show, B : WriteToStringBuilder + Show] join(a : A, b : B) -> String

join3

source

fn[A : WriteToStringBuilder + Show, B : WriteToStringBuilder + Show, C : WriteToStringBuilder + Show] join3(a : A, b : B, c : C) -> String

join_all

source

fn[T : JoinToString] join_all(all : T) -> String

join_array

source

fn join_array(all : Array[WriteToStringBuilder]) -> String

join_fixed_array

source

fn join_fixed_array(all : FixedArray[WriteToStringBuilder]) -> String

join_iter

source

fn join_iter(all : Iter[WriteToStringBuilder]) -> String

join_many

source

fn join_many(all : Many[WriteToStringBuilder]) -> String

lazy_invoke

source

fn[A, B] lazy_invoke(f : (A) -> B, arg : A) -> Lazy[B]

lift_arg

source

fn[R, A] lift_arg(f : () -> A) -> ((R) -> A)

lift_arg_0_2

source

fn[R, R2, A] lift_arg_0_2(f : () -> A) -> ((R, R2) -> A)

lift_arg_2

source

fn[R, R2, A] lift_arg_2(f : (R) -> A) -> ((R, R2) -> A)

lift_exn

source

fn[R, A, E : Error] lift_exn(f : (R) -> A) -> ((R) -> A raise E)

lift_exn_0

source

fn[A, E : Error] lift_exn_0(f : () -> A) -> (() -> A raise E)

map_fst

source

fn[T, U, V] map_fst(f : (T) -> U, tuple : (T, V)) -> (U, V)

Map a function over the first element of a tuple.

Example

test "Tuple::map_fst" {
  let tuple = (1, 2)
  let mapped = @tuple.map_fst(fn(x : Int) -> Int { x + 1 }, tuple)
  assert_eq(mapped, (2, 2))
}

map_snd

source

fn[T, U, V] map_snd(f : (T) -> U, tuple : (V, T)) -> (V, U)

Map a function over the second element of a tuple.

Example

test "Tuple::map_snd" {
  let tuple = (1, 2)
  let mapped = @tuple.map_snd(fn(x : Int) -> Int { x + 1 }, tuple)
  assert_eq(mapped, (1, 3))
}

memorized

source

fn[K : Hash + Eq, V] memorized(f : (K) -> V) -> ((K) -> V)

memorized_0

source

fn[V] memorized_0(f : () -> V) -> (() -> V)

memorized_ignore_arg

source

fn[K, V] memorized_ignore_arg(f : (K) -> V) -> ((K) -> V)

not_eq

source

fn[A : Eq] not_eq(x : A, y : A) -> Bool

or

source

fn[A : Alt] or(x : A, y : A) -> A

Alternative operator that combines two values of the same type implementing the Alt trait. This is equivalent to using the infix operator |.

Parameters:

x : First value of type A that implements the Alt trait.
y : Second value of type A that implements the Alt trait.

Returns the combined result after applying the alternative operation.

Example:

test "alt" {
  let a : Int? = Some(1)
  let b : Int? = Some(2)
  inspect!(@lib.or(a, b), content="Some(1)")
  let c : Int? = None
  inspect!(@lib.or(c, b), content="Some(2)")
}

or_opt

source

fn[A] or_opt(a : A?, b : A?) -> A?

or_opt_lazy

source

fn[A] or_opt_lazy(a : A?, b : () -> A?) -> A?

panic_with

source

fn[N, A] panic_with(_n : N) -> A

raise_exn

source

fn[A, E : Error] raise_exn(a : E) -> A raise E

randomRng

source

fn randomRng() -> State[UInt64, UInt64]

random_double

source

fn random_double(min~ : Double = .., max~ : Double = ..) -> State[UInt64, Double]

random_int

source

fn random_int(min : Int, max : Int) -> State[UInt64, Int]

random_with

source

fn[A] random_with(gen : (UInt64) -> A) -> State[UInt64, A]

safe_string_each

source

fn safe_string_each(str : String, f : (Char) -> Unit) -> Unit

safe_string_eachi

source

fn safe_string_eachi(str : String, f : (Int, Char) -> Unit) -> Unit

slice

source

fn[Z : Slice + Length] slice(a : Z, start : Int, end : Int) -> Z

slice_start

source

fn[Z : Slice + Length] slice_start(a : Z, start : Int) -> Z

source_loc

source

fn source_loc(loc~ : SourceLoc = _) -> SourceLoc

to_debug_string

source

fn[T : Show] to_debug_string(val : T) -> String

to_hex_string

source

fn to_hex_string(num : Int, upper_case~ : Bool = ..) -> String

Converts a non-negative integer to its hexadecimal string representation.

Parameters:

num : The non-negative integer to convert.
upper_case : If true, uses uppercase letters (A-F) for hexadecimal digits; if false, uses lowercase letters (a-f). Defaults to false.

Returns the hexadecimal string representation of the input number.

Throws an error if the input number is negative.

Example:

test "to_hex_string" {
  // Basic conversion
  inspect!(to_hex_string(255), content="ff")
  inspect!(to_hex_string(255, upper_case=true), content="FF")

  // Zero case
  inspect!(to_hex_string(0), content="0")

  // Larger numbers
  inspect!(to_hex_string(0x1234), content="1234")
}

test "panic to_hex_string/negative" {
  let _ = to_hex_string(-1)

}

to_string

source

fn[A : ToString] to_string(target : A) -> String

unsafe_is

source

fn[A, B] unsafe_is(a : A, b : B) -> Bool

write_to_buffer

source

fn[E : WriteToBuffer + Show] write_to_buffer(acc : @moonbitlang/core/buffer.T
T, e : E) -> Unit

write_to_stringbuilder

source

fn[E : WriteToStringBuilder + Show] write_to_stringbuilder(acc : StringBuilder, e : E) -> Unit

Site source Report issue Packages Build queue Skills Statistics

shared-lib

#[WIP] Personal Utils

#Indexable

#Predicate

#RandomRNG

#Refinement

#Alt

#ConcatToString

#Debug

#FromInt

#FromString

#GetChar

#GetUtf16CodePoint

#JoinToString

#Length

#Monoid

#NumType

#Order

#Ring

#Semigroup

#Semiring

#Slice

#ToByte

#ToChar

#ToInt

#ToString

#UnsignedNum

#WriteToBuffer

#WriteToStringBuilder

#Zero

#Apply

#Apply::ap

#Cursor

#Cursor::inner

#Cursor::op_add

#DebugFn

#DebugFn::inner

#Either

#Either::from_option

#Either::is_left

#Either::is_right

#Either::unwrap_left

#Either::unwrap_right

#Endianness

#Foldable

#Foldable::array

#Foldable::fixed_array

#Foldable::inner

#Foldable::many

#FoldableWithIndex

#FoldableWithIndex::array

#FoldableWithIndex::fixed_array

#FoldableWithIndex::inner

#FoldableWithIndex::many

#GetUtf16CharError

#IReader

#IReader::chain

#IReader::map

#Identity

#Identity::ap

#Identity::ap_exn

#Identity::map

#Identity::tap

#Lazy

#Lazy::ap

#Lazy::ap1

#Lazy::chain

#Lazy::get

#Lazy::if_memo

#Lazy::inner

#Lazy::map

#Lazy::memo

#Lazy::of

#Lazy::sequence_array

#Lazy::sequence_many

#Lazy::string_builder

#Lazy::to_reader

#Many

#Many::contains

#Many::contains_ref

Indexable

Predicate

RandomRNG

Refinement

Alt

ConcatToString

Debug

FromInt

FromString

GetChar

GetUtf16CodePoint

JoinToString

Length

Monoid

NumType

Order

Ring

Semigroup

Semiring

Slice

ToByte

ToChar

ToInt

ToString

UnsignedNum

WriteToBuffer

WriteToStringBuilder

Zero

Apply

Apply::ap

Cursor

Cursor::inner

Cursor::op_add

DebugFn

DebugFn::inner

Either

Either::from_option

Either::is_left

Either::is_right

Either::unwrap_left

Either::unwrap_right

Endianness

Foldable

Foldable::array

Foldable::fixed_array

Foldable::inner

Foldable::many

FoldableWithIndex

FoldableWithIndex::array

FoldableWithIndex::fixed_array

FoldableWithIndex::inner

FoldableWithIndex::many

GetUtf16CharError

IReader

IReader::chain

IReader::map

Identity

Identity::ap

Identity::ap_exn

Identity::map

Identity::tap

Lazy

Lazy::ap

Lazy::ap1

Lazy::chain

Lazy::get

Lazy::if_memo

Lazy::inner

Lazy::map

Lazy::memo

Lazy::of

Lazy::sequence_array

Lazy::sequence_many

Lazy::string_builder

Lazy::to_reader

Many

Many::contains

Many::contains_ref

Many::fold

Many::foldi