Documentation

Utf8ByteProblem

[ InvalidStartByte, UnexpectedEndOfSequence, ExpectedContinuation, OverlongEncoding, CodepointTooLarge, EncodesSurrogateHalf ]

Str > Utf8ByteProblem

Utf8Problem

Str > Utf8Problem

isEmpty

Str -> Bool

Str > isEmpty

concat

Str, Str -> Str

Str > concat

withCapacity

U64 -> Str

Str > withCapacity

reserve

Str, U64 -> Str

Str > reserve

joinWith

List Str, Str -> Str

Str > joinWith

splitOn

Str, Str -> List Str

Str > splitOn

repeat

Str, U64 -> Str

Str > repeat

toUtf8

Str -> List U8

Str > toUtf8

fromUtf8

List U8 -> Result Str [BadUtf8 Utf8ByteProblem U64]

Str > fromUtf8

startsWith

Str, Str -> Bool

Str > startsWith

endsWith

Str, Str -> Bool

Str > endsWith

trim

Str -> Str

Str > trim

trimStart

Str -> Str

Str > trimStart

trimEnd

Str -> Str

Str > trimEnd

toDec

Str -> Result Dec [InvalidNumStr]

Str > toDec

toF64

Str -> Result F64 [InvalidNumStr]

Str > toF64

toF32

Str -> Result F32 [InvalidNumStr]

Str > toF32

toU128

Str -> Result U128 [InvalidNumStr]

Str > toU128

toI128

Str -> Result I128 [InvalidNumStr]

Str > toI128

toU64

Str -> Result U64 [InvalidNumStr]

Str > toU64

toI64

Str -> Result I64 [InvalidNumStr]

Str > toI64

toU32

Str -> Result U32 [InvalidNumStr]

Str > toU32

toI32

Str -> Result I32 [InvalidNumStr]

Str > toI32

toU16

Str -> Result U16 [InvalidNumStr]

Str > toU16

toI16

Str -> Result I16 [InvalidNumStr]

Str > toI16

toU8

Str -> Result U8 [InvalidNumStr]

Str > toU8

toI8

Str -> Result I8 [InvalidNumStr]

Str > toI8

countUtf8Bytes

Str -> U64

Str > countUtf8Bytes

replaceEach

Str, Str, Str -> Str

Str > replaceEach

replaceFirst

Str, Str, Str -> Str

Str > replaceFirst

replaceLast

Str, Str, Str -> Str

Str > replaceLast

splitFirst

Str, Str -> Result { before : Str, after : Str } [NotFound]

Str > splitFirst

splitLast

Str, Str -> Result { before : Str, after : Str } [NotFound]

Str > splitLast

walkUtf8WithIndex

Str, state, (state, U8, U64 -> state) -> state

Str > walkUtf8WithIndex

walkUtf8

Str, state, (state, U8 -> state) -> state

Str > walkUtf8

releaseExcessCapacity

Str -> Str

Str > releaseExcessCapacity

withPrefix

Str, Str -> Str

Str > withPrefix

contains

Str, Str -> Bool

Str > contains

dropPrefix

Str, Str -> Str

Str > dropPrefix

dropSuffix

Str, Str -> Str

Str > dropSuffix

Num

Num > Num

Int

Num > Int

Frac

Num > Frac

Signed128

Num > Signed128

Signed64

Num > Signed64

Signed32

Num > Signed32

Signed16

Num > Signed16

Signed8

Num > Signed8

Unsigned128

Num > Unsigned128

Unsigned64

Num > Unsigned64

Unsigned32

Num > Unsigned32

Unsigned16

Num > Unsigned16

Unsigned8

Num > Unsigned8

Integer

Num > Integer

I128

Num > I128

I64

Num > I64

I32

Num > I32

I16

Num > I16

I8

Num > I8

U128

Num > U128

U64

Num > U64

U32

Num > U32

U16

Num > U16

U8

Num > U8

Decimal

Num > Decimal

Binary64

Num > Binary64

Binary32

Num > Binary32

FloatingPoint

Num > FloatingPoint

F64

Num > F64

F32

Num > F32

Dec

Num > Dec

e

Frac *

Num > e

pi

Frac *

Num > pi

tau

Frac *

Num > tau

toStr

Num * -> Str

Num > toStr

intCast

Int a -> Int b

Num > intCast

compare

Num a, Num a -> [ LT, EQ, GT ]

Num > compare

isLt

Num a, Num a -> Bool

Num > isLt

isGt

Num a, Num a -> Bool

Num > isGt

isLte

Num a, Num a -> Bool

Num > isLte

isGte

Num a, Num a -> Bool

Num > isGte

isApproxEq

Frac a, Frac a, { rtol ? Frac a, atol ? Frac a } -> Bool

Num > isApproxEq

isZero

Num a -> Bool

Num > isZero

isEven

Int a -> Bool

Num > isEven

isOdd

Int a -> Bool

Num > isOdd

isPositive

Num a -> Bool

Num > isPositive

isNegative

Num a -> Bool

Num > isNegative

toFrac

Num * -> Frac *

Num > toFrac

isNaN

Frac * -> Bool

Num > isNaN

isInfinite

Frac * -> Bool

Num > isInfinite

isFinite

Frac * -> Bool

Num > isFinite

abs

Num a -> Num a

Num > abs

absDiff

Num a, Num a -> Num a

Num > absDiff

neg

Num a -> Num a

Num > neg

add

Num a, Num a -> Num a

Num > add

sub

Num a, Num a -> Num a

Num > sub

mul

Num a, Num a -> Num a

Num > mul

min

Num a, Num a -> Num a

Num > min

max

Num a, Num a -> Num a

Num > max

sin

Frac a -> Frac a

Num > sin

cos

Frac a -> Frac a

Num > cos

tan

Frac a -> Frac a

Num > tan

asin

Frac a -> Frac a

Num > asin

acos

Frac a -> Frac a

Num > acos

atan

Frac a -> Frac a

Num > atan

sqrt

Frac a -> Frac a

Num > sqrt

sqrtChecked

Frac a -> Result (Frac a) [SqrtOfNegative]

Num > sqrtChecked

log

Frac a -> Frac a

Num > log

logChecked

Frac a -> Result (Frac a) [LogNeedsPositive]

Num > logChecked

div

Frac a, Frac a -> Frac a

Num > div

divChecked

Frac a, Frac a -> Result (Frac a) [DivByZero]

Num > divChecked

divCeil

Int a, Int a -> Int a

Num > divCeil

divCeilChecked

Int a, Int a -> Result (Int a) [DivByZero]

Num > divCeilChecked

divTrunc

Int a, Int a -> Int a

Num > divTrunc

divTruncChecked

Int a, Int a -> Result (Int a) [DivByZero]

Num > divTruncChecked

rem

Int a, Int a -> Int a

Num > rem

remChecked

Int a, Int a -> Result (Int a) [DivByZero]

Num > remChecked

isMultipleOf

Int a, Int a -> Bool

Num > isMultipleOf

bitwiseAnd

Int a, Int a -> Int a

Num > bitwiseAnd

bitwiseXor

Int a, Int a -> Int a

Num > bitwiseXor

bitwiseOr

Int a, Int a -> Int a

Num > bitwiseOr

bitwiseNot

Int a -> Int a

Num > bitwiseNot

shiftLeftBy

Int a, U8 -> Int a

Num > shiftLeftBy

shiftRightBy

Int a, U8 -> Int a

Num > shiftRightBy

shiftRightZfBy

Int a, U8 -> Int a

Num > shiftRightZfBy

round

Frac * -> Int *

Num > round

floor

Frac * -> Int *

Num > floor

ceiling

Frac * -> Int *

Num > ceiling

pow

Frac a, Frac a -> Frac a

Num > pow

powInt

Int a, Int a -> Int a

Num > powInt

countLeadingZeroBits

Int a -> U8

Num > countLeadingZeroBits

countTrailingZeroBits

Int a -> U8

Num > countTrailingZeroBits

countOneBits

Int a -> U8

Num > countOneBits

addWrap

Int range, Int range -> Int range

Num > addWrap

addSaturated

Num a, Num a -> Num a

Num > addSaturated

addChecked

Num a, Num a -> Result (Num a) [Overflow]

Num > addChecked

subWrap

Int range, Int range -> Int range

Num > subWrap

subSaturated

Num a, Num a -> Num a

Num > subSaturated

subChecked

Num a, Num a -> Result (Num a) [Overflow]

Num > subChecked

mulWrap

Int range, Int range -> Int range

Num > mulWrap

mulSaturated

Num a, Num a -> Num a

Num > mulSaturated

mulChecked

Num a, Num a -> Result (Num a) [Overflow]

Num > mulChecked

minI8

I8

Num > minI8

maxI8

I8

Num > maxI8

minU8

U8

Num > minU8

maxU8

U8

Num > maxU8

minI16

I16

Num > minI16

maxI16

I16

Num > maxI16

minU16

U16

Num > minU16

maxU16

U16

Num > maxU16

minI32

I32

Num > minI32

maxI32

I32

Num > maxI32

minU32

U32

Num > minU32

maxU32

U32

Num > maxU32

minI64

I64

Num > minI64

maxI64

I64

Num > maxI64

minU64

U64

Num > minU64

maxU64

U64

Num > maxU64

minI128

I128

Num > minI128

maxI128

I128

Num > maxI128

minU128

U128

Num > minU128

maxU128

U128

Num > maxU128

minF32

F32

Num > minF32

maxF32

F32

Num > maxF32

minF64

F64

Num > minF64

maxF64

F64

Num > maxF64

toI8

Int * -> I8

Num > toI8

toI16

Int * -> I16

Num > toI16

toI32

Int * -> I32

Num > toI32

toI64

Int * -> I64

Num > toI64

toI128

Int * -> I128

Num > toI128

toU8

Int * -> U8

Num > toU8

toU16

Int * -> U16

Num > toU16

toU32

Int * -> U32

Num > toU32

toU64

Int * -> U64

Num > toU64

toU128

Int * -> U128

Num > toU128

toF32

Num * -> F32

Num > toF32

toF64

Num * -> F64

Num > toF64

toI8Checked

Int * -> Result I8 [OutOfBounds]

Num > toI8Checked

toI16Checked

Int * -> Result I16 [OutOfBounds]

Num > toI16Checked

toI32Checked

Int * -> Result I32 [OutOfBounds]

Num > toI32Checked

toI64Checked

Int * -> Result I64 [OutOfBounds]

Num > toI64Checked

toI128Checked

Int * -> Result I128 [OutOfBounds]

Num > toI128Checked

toU8Checked

Int * -> Result U8 [OutOfBounds]

Num > toU8Checked

toU16Checked

Int * -> Result U16 [OutOfBounds]

Num > toU16Checked

toU32Checked

Int * -> Result U32 [OutOfBounds]

Num > toU32Checked

toU64Checked

Int * -> Result U64 [OutOfBounds]

Num > toU64Checked

toU128Checked

Int * -> Result U128 [OutOfBounds]

Num > toU128Checked

toF32Checked

Num * -> Result F32 [OutOfBounds]

Num > toF32Checked

toF64Checked

Num * -> Result F64 [OutOfBounds]

Num > toF64Checked

withoutDecimalPoint

Dec -> I128

Num > withoutDecimalPoint

withDecimalPoint

I128 -> Dec

Num > withDecimalPoint

f32ToParts

F32 -> { sign : Bool, exponent : U8, fraction : U32 }

Num > f32ToParts

f64ToParts

F64 -> { sign : Bool, exponent : U16, fraction : U64 }

Num > f64ToParts

f32FromParts

{ sign : Bool, exponent : U8, fraction : U32 } -> F32

Num > f32FromParts

f64FromParts

{ sign : Bool, exponent : U16, fraction : U64 } -> F64

Num > f64FromParts

nanF32

F32

Num > nanF32

nanF64

F64

Num > nanF64

infinityF32

F32

Num > infinityF32

infinityF64

F64

Num > infinityF64

Eq

implements isEq : a, a -> Bool where a implements Eq

Bool > Eq

Bool

Bool > Bool

true

Bool

Bool > true

false

Bool

Bool > false

and

Bool, Bool -> Bool

Bool > and

or

Bool, Bool -> Bool

Bool > or

not

Bool -> Bool

Bool > not

isNotEq

a, a -> Bool where a implements Eq

Bool > isNotEq

Result

[ Ok ok, Err err ]

Result > Result

isOk

Result ok err -> Bool

Result > isOk

isErr

Result ok err -> Bool

Result > isErr

withDefault

Result ok err, ok -> ok

Result > withDefault

map

Result a err, (a -> b) -> Result b err

Result > map

mapErr

Result ok a, (a -> b) -> Result ok b

Result > mapErr

mapBoth

Result ok1 err1, (ok1 -> ok2), (err1 -> err2) -> Result ok2 err2

Result > mapBoth

map2

Result a err, Result b err, (a, b -> c) -> Result c err

Result > map2

try

Result a err, (a -> Result b err) -> Result b err

Result > try

onErr

Result a err, (err -> Result a otherErr) -> Result a otherErr

Result > onErr

onErr!

Result a err, (err => Result a otherErr) => Result a otherErr

Result > onErr!

isEmpty

List * -> Bool

List > isEmpty

get

List a, U64 -> Result a [OutOfBounds]

List > get

replace

List a, U64, a -> { list : List a, value : a }

List > replace

set

List a, U64, a -> List a

List > set

update

List a, U64, (a -> a) -> List a

List > update

append

List a, a -> List a

List > append

appendIfOk

List a, Result a * -> List a

List > appendIfOk

prepend

List a, a -> List a

List > prepend

prependIfOk

List a, Result a * -> List a

List > prependIfOk

len

List * -> U64

List > len

withCapacity

U64 -> List *

List > withCapacity

reserve

List a, U64 -> List a

List > reserve

releaseExcessCapacity

List a -> List a

List > releaseExcessCapacity

concat

List a, List a -> List a

List > concat

last

List a -> Result a [ListWasEmpty]

List > last

single

a -> List a

List > single

repeat

a, U64 -> List a

List > repeat

reverse

List a -> List a

List > reverse

join

List (List a) -> List a

List > join

contains

List a, a -> Bool where a implements Eq

List > contains

walk

List elem, state, (state, elem -> state) -> state

List > walk

walkWithIndex

List elem, state, (state, elem, U64 -> state) -> state

List > walkWithIndex

walkWithIndexUntil

List elem, state, (state, elem, U64 -> [ Continue state, Break state ]) -> state

List > walkWithIndexUntil

walkBackwards

List elem, state, (state, elem -> state) -> state

List > walkBackwards

walkUntil

List elem, state, (state, elem -> [ Continue state, Break state ]) -> state

List > walkUntil

walkBackwardsUntil

List elem, state, (state, elem -> [ Continue state, Break state ]) -> state

List > walkBackwardsUntil

walkFrom

List elem, U64, state, (state, elem -> state) -> state

List > walkFrom

walkFromUntil

List elem, U64, state, (state, elem -> [ Continue state, Break state ]) -> state

List > walkFromUntil

sum

List (Num a) -> Num a

List > sum

product

List (Num a) -> Num a

List > product

any

List a, (a -> Bool) -> Bool

List > any

all

List a, (a -> Bool) -> Bool

List > all

keepIf

List a, (a -> Bool) -> List a

List > keepIf

dropIf

List a, (a -> Bool) -> List a

List > dropIf

countIf

List a, (a -> Bool) -> U64

List > countIf

keepOks

List before, (before -> Result after *) -> List after

List > keepOks

keepErrs

List before, (before -> Result * after) -> List after

List > keepErrs

map

List a, (a -> b) -> List b

List > map

map2

List a, List b, (a, b -> c) -> List c

List > map2

map3

List a, List b, List c, (a, b, c -> d) -> List d

List > map3

map4

List a, List b, List c, List d, (a, b, c, d -> e) -> List e

List > map4

mapWithIndex

List a, (a, U64 -> b) -> List b

List > mapWithIndex

range

List > range

sortWith

List a, (a, a -> [ LT, EQ, GT ]) -> List a

List > sortWith

sortAsc

List (Num a) -> List (Num a)

List > sortAsc

sortDesc

List (Num a) -> List (Num a)

List > sortDesc

swap

List a, U64, U64 -> List a

List > swap

first

List a -> Result a [ListWasEmpty]

List > first

takeFirst

List elem, U64 -> List elem

List > takeFirst

takeLast

List elem, U64 -> List elem

List > takeLast

dropFirst

List elem, U64 -> List elem

List > dropFirst

dropLast

List elem, U64 -> List elem

List > dropLast

dropAt

List elem, U64 -> List elem

List > dropAt

min

List (Num a) -> Result (Num a) [ListWasEmpty]

List > min

max

List (Num a) -> Result (Num a) [ListWasEmpty]

List > max

joinMap

List a, (a -> List b) -> List b

List > joinMap

findFirst

List elem, (elem -> Bool) -> Result elem [NotFound]

List > findFirst

findLast

List elem, (elem -> Bool) -> Result elem [NotFound]

List > findLast

findFirstIndex

List elem, (elem -> Bool) -> Result U64 [NotFound]

List > findFirstIndex

findLastIndex

List elem, (elem -> Bool) -> Result U64 [NotFound]

List > findLastIndex

sublist

List elem, { start : U64, len : U64 } -> List elem

List > sublist

intersperse

List elem, elem -> List elem

List > intersperse

startsWith

List elem, List elem -> Bool where elem implements Eq

List > startsWith

endsWith

List elem, List elem -> Bool where elem implements Eq

List > endsWith

splitAt

List elem, U64 -> { before : List elem, others : List elem }

List > splitAt

splitOn

List a, a -> List (List a) where a implements Eq

List > splitOn

splitOnList

List a, List a -> List (List a) where a implements Eq

List > splitOnList

splitFirst

List elem, elem -> Result { before : List elem, after : List elem } [NotFound] where elem implements Eq

List > splitFirst

splitLast

List elem, elem -> Result { before : List elem, after : List elem } [NotFound] where elem implements Eq

List > splitLast

chunksOf

List a, U64 -> List (List a)

List > chunksOf

mapTry

List elem, (elem -> Result ok err) -> Result (List ok) err

List > mapTry

walkTry

List elem, state, (state, elem -> Result state err) -> Result state err

List > walkTry

concatUtf8

List U8, Str -> List U8

List > concatUtf8

forEach!

List a, (a => {}) => {}

List > forEach!

forEachTry!

List a, (a => Result {} err) => Result {} err

List > forEachTry!

Dict

Dict > Dict

empty

{} -> Dict * *

Dict > empty

withCapacity

U64 -> Dict * *

Dict > withCapacity

reserve

Dict k v, U64 -> Dict k v

Dict > reserve

releaseExcessCapacity

Dict k v -> Dict k v

Dict > releaseExcessCapacity

capacity

Dict * * -> U64

Dict > capacity

single

k, v -> Dict k v

Dict > single

fromList

List ( k, v ) -> Dict k v

Dict > fromList

len

Dict * * -> U64

Dict > len

isEmpty

Dict * * -> Bool

Dict > isEmpty

clear

Dict k v -> Dict k v

Dict > clear

map

Dict k a, (k, a -> b) -> Dict k b

Dict > map

joinMap

Dict a b, (a, b -> Dict x y) -> Dict x y

Dict > joinMap

walk

Dict k v, state, (state, k, v -> state) -> state

Dict > walk

walkUntil

Dict k v, state, (state, k, v -> [ Continue state, Break state ]) -> state

Dict > walkUntil

keepIf

Dict k v, ( ( k, v ) -> Bool) -> Dict k v

Dict > keepIf

dropIf

Dict k v, ( ( k, v ) -> Bool) -> Dict k v

Dict > dropIf

get

Dict k v, k -> Result v [KeyNotFound]

Dict > get

contains

Dict k v, k -> Bool

Dict > contains

insert

Dict k v, k, v -> Dict k v

Dict > insert

remove

Dict k v, k -> Dict k v

Dict > remove

update

Dict k v, k, (Result v [Missing] -> Result v [Missing]) -> Dict k v

Dict > update

toList

Dict k v -> List ( k, v )

Dict > toList

keys

Dict k v -> List k

Dict > keys

values

Dict k v -> List v

Dict > values

insertAll

Dict k v, Dict k v -> Dict k v

Dict > insertAll

keepShared

Dict k v, Dict k v -> Dict k v where v implements Eq

Dict > keepShared

removeAll

Dict k v, Dict k v -> Dict k v

Dict > removeAll

Set

Set > Set

empty

{} -> Set *

Set > empty

withCapacity

U64 -> Set *

Set > withCapacity

reserve

Set k, U64 -> Set k

Set > reserve

releaseExcessCapacity

Set k -> Set k

Set > releaseExcessCapacity

single

k -> Set k

Set > single

insert

Set k, k -> Set k

Set > insert

len

Set * -> U64

Set > len

capacity

Set * -> U64

Set > capacity

isEmpty

Set * -> Bool

Set > isEmpty

remove

Set k, k -> Set k

Set > remove

contains

Set k, k -> Bool

Set > contains

toList

Set k -> List k

Set > toList

fromList

List k -> Set k

Set > fromList

union

Set k, Set k -> Set k

Set > union

intersection

Set k, Set k -> Set k

Set > intersection

difference

Set k, Set k -> Set k

Set > difference

walk

Set k, state, (state, k -> state) -> state

Set > walk

map

Set a, (a -> b) -> Set b

Set > map

joinMap

Set a, (a -> Set b) -> Set b

Set > joinMap

walkUntil

Set k, state, (state, k -> [ Continue state, Break state ]) -> state

Set > walkUntil

keepIf

Set k, (k -> Bool) -> Set k

Set > keepIf

dropIf

Set k, (k -> Bool) -> Set k

Set > dropIf

DecodeError

[TooShort]

Decode > DecodeError

DecodeResult

Decode > DecodeResult

Decoder

Decode > Decoder

Decoding

implements decoder : Decoder val fmt where val implements Decoding, fmt implements DecoderFormatting

Decode > Decoding

DecoderFormatting

implements u8 : Decoder U8 fmt where fmt implements DecoderFormatting u16 : Decoder U16 fmt where fmt implements DecoderFormatting u32 : Decoder U32 fmt where fmt implements DecoderFormatting u64 : Decoder U64 fmt where fmt implements DecoderFormatting u128 : Decoder U128 fmt where fmt implements DecoderFormatting i8 : Decoder I8 fmt where fmt implements DecoderFormatting i16 : Decoder I16 fmt where fmt implements DecoderFormatting i32 : Decoder I32 fmt where fmt implements DecoderFormatting i64 : Decoder I64 fmt where fmt implements DecoderFormatting i128 : Decoder I128 fmt where fmt implements DecoderFormatting f32 : Decoder F32 fmt where fmt implements DecoderFormatting f64 : Decoder F64 fmt where fmt implements DecoderFormatting dec : Decoder Dec fmt where fmt implements DecoderFormatting bool : Decoder Bool fmt where fmt implements DecoderFormatting string : Decoder Str fmt where fmt implements DecoderFormatting list : Decoder elem fmt -> Decoder (List elem) fmt where fmt implements DecoderFormatting record : state, (state, Str -> [ Keep (Decoder state fmt), Skip ]), (state, fmt -> Result val DecodeError) -> Decoder val fmt where fmt implements DecoderFormatting tuple : state, (state, U64 -> [ Next (Decoder state fmt), TooLong ]), (state -> Result val DecodeError) -> Decoder val fmt where fmt implements DecoderFormatting

Decode > DecoderFormatting

custom

(List U8, fmt -> DecodeResult val) -> Decoder val fmt where fmt implements DecoderFormatting

Decode > custom

decodeWith

List U8, Decoder val fmt, fmt -> DecodeResult val where fmt implements DecoderFormatting

Decode > decodeWith

fromBytesPartial

List U8, fmt -> DecodeResult val where val implements Decoding, fmt implements DecoderFormatting

Decode > fromBytesPartial

fromBytes

List U8, fmt -> Result val [Leftover (List U8)]DecodeError where val implements Decoding, fmt implements DecoderFormatting

Decode > fromBytes

mapResult

DecodeResult a, (a -> b) -> DecodeResult b

Decode > mapResult

Encoder

Encode > Encoder

Encoding

implements toEncoder : val -> Encoder fmt where val implements Encoding, fmt implements EncoderFormatting

Encode > Encoding

EncoderFormatting

implements u8 : U8 -> Encoder fmt where fmt implements EncoderFormatting u16 : U16 -> Encoder fmt where fmt implements EncoderFormatting u32 : U32 -> Encoder fmt where fmt implements EncoderFormatting u64 : U64 -> Encoder fmt where fmt implements EncoderFormatting u128 : U128 -> Encoder fmt where fmt implements EncoderFormatting i8 : I8 -> Encoder fmt where fmt implements EncoderFormatting i16 : I16 -> Encoder fmt where fmt implements EncoderFormatting i32 : I32 -> Encoder fmt where fmt implements EncoderFormatting i64 : I64 -> Encoder fmt where fmt implements EncoderFormatting i128 : I128 -> Encoder fmt where fmt implements EncoderFormatting f32 : F32 -> Encoder fmt where fmt implements EncoderFormatting f64 : F64 -> Encoder fmt where fmt implements EncoderFormatting dec : Dec -> Encoder fmt where fmt implements EncoderFormatting bool : Bool -> Encoder fmt where fmt implements EncoderFormatting string : Str -> Encoder fmt where fmt implements EncoderFormatting list : List elem, (elem -> Encoder fmt) -> Encoder fmt where fmt implements EncoderFormatting record : List { key : Str, value : Encoder fmt } -> Encoder fmt where fmt implements EncoderFormatting tuple : List (Encoder fmt) -> Encoder fmt where fmt implements EncoderFormatting tag : Str, List (Encoder fmt) -> Encoder fmt where fmt implements EncoderFormatting

Encode > EncoderFormatting

custom

(List U8, fmt -> List U8) -> Encoder fmt where fmt implements EncoderFormatting

Encode > custom

appendWith

List U8, Encoder fmt, fmt -> List U8 where fmt implements EncoderFormatting

Encode > appendWith

append

List U8, val, fmt -> List U8 where val implements Encoding, fmt implements EncoderFormatting

Encode > append

toBytes

val, fmt -> List U8 where val implements Encoding, fmt implements EncoderFormatting

Encode > toBytes

Hash

implements hash : hasher, a -> hasher where a implements Hash, hasher implements Hasher

Hash > Hash

Hasher

implements addBytes : a, List U8 -> a where a implements Hasher addU8 : a, U8 -> a where a implements Hasher addU16 : a, U16 -> a where a implements Hasher addU32 : a, U32 -> a where a implements Hasher addU64 : a, U64 -> a where a implements Hasher addU128 : a, U128 -> a where a implements Hasher complete : a -> U64 where a implements Hasher

Hash > Hasher

hashStrBytes

Hash > hashStrBytes

hashList

Hash > hashList

hashBool

a, Bool -> a where a implements Hasher

Hash > hashBool

hashI8

a, I8 -> a where a implements Hasher

Hash > hashI8

hashI16

a, I16 -> a where a implements Hasher

Hash > hashI16

hashI32

a, I32 -> a where a implements Hasher

Hash > hashI32

hashI64

a, I64 -> a where a implements Hasher

Hash > hashI64

hashI128

a, I128 -> a where a implements Hasher

Hash > hashI128

hashDec

a, Dec -> a where a implements Hasher

Hash > hashDec

hashUnordered

Hash > hashUnordered

box

a -> Box a

Box > box

unbox

Box a -> a

Box > unbox

KeyValWalker

collection, state, (state, key, val -> state) -> state

Inspect > KeyValWalker

ElemWalker

collection, state, (state, elem -> state) -> state

Inspect > ElemWalker

InspectFormatter

implements init : {} -> f where f implements InspectFormatter tag : Str, List (Inspector f) -> Inspector f where f implements InspectFormatter tuple : List (Inspector f) -> Inspector f where f implements InspectFormatter record : List { key : Str, value : Inspector f } -> Inspector f where f implements InspectFormatter bool : Bool -> Inspector f where f implements InspectFormatter str : Str -> Inspector f where f implements InspectFormatter list : list, ElemWalker state list elem, (elem -> Inspector f) -> Inspector f where f implements InspectFormatter set : set, ElemWalker state set elem, (elem -> Inspector f) -> Inspector f where f implements InspectFormatter dict : dict, KeyValWalker state dict key value, (key -> Inspector f), (value -> Inspector f) -> Inspector f where f implements InspectFormatter opaque : * -> Inspector f where f implements InspectFormatter function : * -> Inspector f where f implements InspectFormatter u8 : U8 -> Inspector f where f implements InspectFormatter i8 : I8 -> Inspector f where f implements InspectFormatter u16 : U16 -> Inspector f where f implements InspectFormatter i16 : I16 -> Inspector f where f implements InspectFormatter u32 : U32 -> Inspector f where f implements InspectFormatter i32 : I32 -> Inspector f where f implements InspectFormatter u64 : U64 -> Inspector f where f implements InspectFormatter i64 : I64 -> Inspector f where f implements InspectFormatter u128 : U128 -> Inspector f where f implements InspectFormatter i128 : I128 -> Inspector f where f implements InspectFormatter f32 : F32 -> Inspector f where f implements InspectFormatter f64 : F64 -> Inspector f where f implements InspectFormatter dec : Dec -> Inspector f where f implements InspectFormatter

Inspect > InspectFormatter

Inspector

Inspect > Inspector

custom

(f -> f) -> Inspector f where f implements InspectFormatter

Inspect > custom

apply

Inspector f, f -> f where f implements InspectFormatter

Inspect > apply

Inspect

implements toInspector : val -> Inspector f where val implements Inspect, f implements InspectFormatter

Inspect > Inspect

inspect

val -> f where val implements Inspect, f implements InspectFormatter

Inspect > inspect

toStr

val -> Str where val implements Inspect

Inspect > toStr

Task

Task > Task

forever

Task a err -> Task * err

Task > forever

loop

state, (state -> Task [ Step state, Done done ] err) -> Task done err

Task > loop

ok

a -> Task a *

Task > ok

err

a -> Task * a

Task > err

attempt

Task a b, (Result a b -> Task c d) -> Task c d

Task > attempt

await

Task a b, (a -> Task c b) -> Task c b

Task > await

onErr

Task a b, (b -> Task a c) -> Task a c

Task > onErr

map

Task a c, (a -> b) -> Task b c

Task > map

mapErr

Task c a, (a -> b) -> Task c b

Task > mapErr

fromResult

Result a b -> Task a b

Task > fromResult

batch

Task a c -> Task (a -> b) c -> Task b c

Task > batch

sequence

List (Task ok err) -> Task (List ok) err

Task > sequence

forEach

List a, (a -> Task {} b) -> Task {} b

Task > forEach

result

Task ok err -> Task (Result ok err) *

Task > result