`Bosatsu/Predef`

Index

Types: Bool, Char, Comparison, Dict, Float64, Fn1, Fn2, Fn3, Fn4, Fn5, Fn6, Fn7, Fn8, Fn9, Fn10, Fn11, Fn12, Fn13, Fn14, Fn15, Fn16, Fn17, Fn18, Fn19, Fn20, Fn21, Fn22, Fn23, Fn24, Fn25, Fn26, Fn27, Fn28, Fn29, Fn30, Fn31, Fn32, Int, List, Option, Order, String, Test, Tuple1, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, Tuple8, Tuple9, Tuple10, Tuple11, Tuple12, Tuple13, Tuple14, Tuple15, Tuple16, Tuple17, Tuple18, Tuple19, Tuple20, Tuple21, Tuple22, Tuple23, Tuple24, Tuple25, Tuple26, Tuple27, Tuple28, Tuple29, Tuple30, Tuple31, Tuple32, Unit
Values: add, add_key, addf, and_Int, build_List, char_List_to_String, char_to_Int, char_to_String, clear_Dict, cmp_Float64, cmp_Int, cmp_String, concat, concat_String, div, divf, empty_Dict, eq_Int, flat_map_List, foldl_List, foldr_List, gcd_Int, get_key, int_loop, int_to_Char, int_to_String, items, length_String, map_List, mod_Int, mul, not_Int, or_Int, partition_String, range, range_fold, remove_key, replicate_List, reverse, reverse_concat, rpartition_String, shift_left_Int, shift_right_Int, string_Order, string_to_Int, sub, subf, tail_or_empty_String, timesf, trace, uncons_String, uncurry2, uncurry3, xor_Int

Types

`Bool`

type Bool

Constructors

False
True

`Char`

type Char

`Comparison`

Standardize notion of ordering

type Comparison

Constructors

EQ
GT
LT

`Dict[k, v]`

Standard dictionaries

type Dict[k: *, v: +*]

`Float64`

type Float64

`Fn1[i0, z]`

type Fn1[i0: -*, z: +*]

`Fn2[i0, i1, z]`

type Fn2[i0: -*, i1: -*, z: +*]

`Fn3[i0, i1, i2, z]`

type Fn3[i0: -*, i1: -*, i2: -*, z: +*]

`Fn4[i0, i1, i2, i3, z]`

type Fn4[i0: -*, i1: -*, i2: -*, i3: -*, z: +*]

`Fn5[i0, i1, i2, i3, i4, z]`

type Fn5[i0: -*, i1: -*, i2: -*, i3: -*, i4: -*, z: +*]

`Fn6[i0, i1, i2, i3, i4, i5, z]`

type Fn6[i0: -*, i1: -*, i2: -*, i3: -*, i4: -*, i5: -*, z: +*]

`Fn7[i0, i1, i2, i3, i4, i5, i6, z]`

type Fn7[i0: -*, i1: -*, i2: -*, i3: -*, i4: -*, i5: -*, i6: -*, z: +*]

`Fn8[i0, i1, i2, i3, i4, i5, i6, i7, z]`

type Fn8[i0: -*, i1: -*, i2: -*, i3: -*, i4: -*, i5: -*, i6: -*, i7: -*, z: +*]

`Fn9[i0, i1, i2, i3, i4, i5, i6, i7, i8, z]`

type Fn9[i0: -*, i1: -*, i2: -*, i3: -*, i4: -*, i5: -*, i6: -*, i7: -*, i8: -*, z: +*]

`Fn10[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, z]`

type Fn10[i0: -*, i1: -*, i2: -*, i3: -*, i4: -*, i5: -*, i6: -*, i7: -*, i8: -*, i9: -*, z: +*]

`Fn11[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, z]`

type Fn11[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    z: +*]

`Fn12[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, z]`

type Fn12[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    z: +*]

`Fn13[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, z]`

type Fn13[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    z: +*]

`Fn14[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, z]`

type Fn14[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    z: +*]

`Fn15[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, z]`

type Fn15[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    z: +*]

`Fn16[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, z]`

type Fn16[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    z: +*]

`Fn17[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, z]`

type Fn17[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    z: +*]

`Fn18[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, z]`

type Fn18[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    z: +*]

`Fn19[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, z]`

type Fn19[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    z: +*]

`Fn20[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, z]`

type Fn20[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    z: +*]

`Fn21[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, z]`

type Fn21[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    i20: -*,
    z: +*]

`Fn22[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, z]`

type Fn22[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    i20: -*,
    i21: -*,
    z: +*]

`Fn23[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, z]`

type Fn23[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    i20: -*,
    i21: -*,
    i22: -*,
    z: +*]

`Fn24[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, z]`

type Fn24[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    i20: -*,
    i21: -*,
    i22: -*,
    i23: -*,
    z: +*]

`Fn25[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, z]`

type Fn25[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    i20: -*,
    i21: -*,
    i22: -*,
    i23: -*,
    i24: -*,
    z: +*]

`Fn26[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25, z]`

type Fn26[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    i20: -*,
    i21: -*,
    i22: -*,
    i23: -*,
    i24: -*,
    i25: -*,
    z: +*]

`Fn27[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25, i26, z]`

type Fn27[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    i20: -*,
    i21: -*,
    i22: -*,
    i23: -*,
    i24: -*,
    i25: -*,
    i26: -*,
    z: +*]

`Fn28[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25, i26, i27, z]`

type Fn28[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    i20: -*,
    i21: -*,
    i22: -*,
    i23: -*,
    i24: -*,
    i25: -*,
    i26: -*,
    i27: -*,
    z: +*]

`Fn29[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25, i26, i27, i28, z]`

type Fn29[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    i20: -*,
    i21: -*,
    i22: -*,
    i23: -*,
    i24: -*,
    i25: -*,
    i26: -*,
    i27: -*,
    i28: -*,
    z: +*]

`Fn30[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25, i26, i27, i28, i29, z]`

type Fn30[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    i20: -*,
    i21: -*,
    i22: -*,
    i23: -*,
    i24: -*,
    i25: -*,
    i26: -*,
    i27: -*,
    i28: -*,
    i29: -*,
    z: +*]

`Fn31[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25, i26, i27, i28, i29, i30, z]`

type Fn31[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    i20: -*,
    i21: -*,
    i22: -*,
    i23: -*,
    i24: -*,
    i25: -*,
    i26: -*,
    i27: -*,
    i28: -*,
    i29: -*,
    i30: -*,
    z: +*]

`Fn32[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25, i26, i27, i28, i29, i30, i31, z]`

type Fn32[i0: -*,
    i1: -*,
    i2: -*,
    i3: -*,
    i4: -*,
    i5: -*,
    i6: -*,
    i7: -*,
    i8: -*,
    i9: -*,
    i10: -*,
    i11: -*,
    i12: -*,
    i13: -*,
    i14: -*,
    i15: -*,
    i16: -*,
    i17: -*,
    i18: -*,
    i19: -*,
    i20: -*,
    i21: -*,
    i22: -*,
    i23: -*,
    i24: -*,
    i25: -*,
    i26: -*,
    i27: -*,
    i28: -*,
    i29: -*,
    i30: -*,
    i31: -*,
    z: +*]

`Int`

Int functions

type Int

`List[a]`

Support for built-in lists

type List[a: +*]

Constructors

EmptyList
NonEmptyList(head: a, tail: List[a])

`Option[a]`

type Option[a: +*]

Constructors

None
Some(v: a)

`Order[a]`

type Order[a: -*]

Constructors

Order(to_Fn: (a, a) -> Comparison)

`String`

String functions

type String

`Test`

Support for built-in testing:

type Test

Constructors

Assertion(value: Bool, message: String)
TestSuite(name: String, tests: List[Test])

`Tuple1[a]`

type Tuple1[a: +*]

Constructors

Tuple1(item1: a)

`Tuple2[a, b]`

type Tuple2[a: +*, b: +*]

Constructors

Tuple2(item1: a, item2: b)

`Tuple3[a, b, c]`

type Tuple3[a: +*, b: +*, c: +*]

Constructors

Tuple3(item1: a, item2: b, item3: c)

`Tuple4[a, b, c, d]`

type Tuple4[a: +*, b: +*, c: +*, d: +*]

Constructors

Tuple4(item1: a, item2: b, item3: c, item4: d)

`Tuple5[a, b, c, d, e]`

type Tuple5[a: +*, b: +*, c: +*, d: +*, e: +*]

Constructors

Tuple5(item1: a, item2: b, item3: c, item4: d, item5: e)

`Tuple6[a, b, c, d, e, f]`

type Tuple6[a: +*, b: +*, c: +*, d: +*, e: +*, f: +*]

Constructors

Tuple6(item1: a, item2: b, item3: c, item4: d, item5: e, item6: f)

`Tuple7[a, b, c, d, e, f, g]`

type Tuple7[a: +*, b: +*, c: +*, d: +*, e: +*, f: +*, g: +*]

Constructors

Tuple7(item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g)

`Tuple8[a, b, c, d, e, f, g, h]`

type Tuple8[a: +*, b: +*, c: +*, d: +*, e: +*, f: +*, g: +*, h: +*]

Constructors

Tuple8(item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h)

`Tuple9[a, b, c, d, e, f, g, h, i]`

type Tuple9[a: +*, b: +*, c: +*, d: +*, e: +*, f: +*, g: +*, h: +*, i: +*]

Constructors

Tuple9(item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i)

`Tuple10[a, b, c, d, e, f, g, h, i, j]`

type Tuple10[a: +*, b: +*, c: +*, d: +*, e: +*, f: +*, g: +*, h: +*, i: +*, j: +*]

Constructors

Tuple10( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j )

`Tuple11[a, b, c, d, e, f, g, h, i, j, k]`

type Tuple11[a: +*, b: +*, c: +*, d: +*, e: +*, f: +*, g: +*, h: +*, i: +*, j: +*, k: +*]

Constructors

Tuple11( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k )

`Tuple12[a, b, c, d, e, f, g, h, i, j, k, l]`

type Tuple12[a: +*, b: +*, c: +*, d: +*, e: +*, f: +*, g: +*, h: +*, i: +*, j: +*, k: +*, l: +*]

Constructors

Tuple12( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l )

`Tuple13[a, b, c, d, e, f, g, h, i, j, k, l, m]`

type Tuple13[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*]

Constructors

Tuple13( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m )

`Tuple14[a, b, c, d, e, f, g, h, i, j, k, l, m, n]`

type Tuple14[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*]

Constructors

Tuple14( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n )

`Tuple15[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o]`

type Tuple15[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*]

Constructors

Tuple15( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o )

`Tuple16[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p]`

type Tuple16[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*]

Constructors

Tuple16( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p )

`Tuple17[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q]`

type Tuple17[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*]

Constructors

Tuple17( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q )

`Tuple18[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r]`

type Tuple18[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*]

Constructors

Tuple18( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r )

`Tuple19[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s]`

type Tuple19[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*]

Constructors

Tuple19( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s )

`Tuple20[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t]`

type Tuple20[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*]

Constructors

Tuple20( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t )

`Tuple21[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]`

type Tuple21[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*,
    u: +*]

Constructors

Tuple21( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t, item21: u )

`Tuple22[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]`

type Tuple22[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*,
    u: +*,
    v: +*]

Constructors

Tuple22( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t, item21: u, item22: v )

`Tuple23[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]`

type Tuple23[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*,
    u: +*,
    v: +*,
    w: +*]

Constructors

Tuple23( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t, item21: u, item22: v, item23: w )

`Tuple24[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]`

type Tuple24[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*,
    u: +*,
    v: +*,
    w: +*,
    x: +*]

Constructors

Tuple24( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t, item21: u, item22: v, item23: w, item24: x )

`Tuple25[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]`

type Tuple25[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*,
    u: +*,
    v: +*,
    w: +*,
    x: +*,
    y: +*]

Constructors

Tuple25( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t, item21: u, item22: v, item23: w, item24: x, item25: y )

`Tuple26[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]`

type Tuple26[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*,
    u: +*,
    v: +*,
    w: +*,
    x: +*,
    y: +*,
    z: +*]

Constructors

Tuple26( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t, item21: u, item22: v, item23: w, item24: x, item25: y, item26: z )

`Tuple27[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a0]`

type Tuple27[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*,
    u: +*,
    v: +*,
    w: +*,
    x: +*,
    y: +*,
    z: +*,
    a0: +*]

Constructors

Tuple27( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t, item21: u, item22: v, item23: w, item24: x, item25: y, item26: z, item27: a0 )

`Tuple28[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a0, b0]`

type Tuple28[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*,
    u: +*,
    v: +*,
    w: +*,
    x: +*,
    y: +*,
    z: +*,
    a0: +*,
    b0: +*]

Constructors

Tuple28( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t, item21: u, item22: v, item23: w, item24: x, item25: y, item26: z, item27: a0, item28: b0 )

`Tuple29[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a0, b0, c0]`

type Tuple29[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*,
    u: +*,
    v: +*,
    w: +*,
    x: +*,
    y: +*,
    z: +*,
    a0: +*,
    b0: +*,
    c0: +*]

Constructors

Tuple29( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t, item21: u, item22: v, item23: w, item24: x, item25: y, item26: z, item27: a0, item28: b0, item29: c0 )

`Tuple30[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a0, b0, c0, d0]`

type Tuple30[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*,
    u: +*,
    v: +*,
    w: +*,
    x: +*,
    y: +*,
    z: +*,
    a0: +*,
    b0: +*,
    c0: +*,
    d0: +*]

Constructors

Tuple30( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t, item21: u, item22: v, item23: w, item24: x, item25: y, item26: z, item27: a0, item28: b0, item29: c0, item30: d0 )

`Tuple31[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a0, b0, c0, d0, e0]`

type Tuple31[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*,
    u: +*,
    v: +*,
    w: +*,
    x: +*,
    y: +*,
    z: +*,
    a0: +*,
    b0: +*,
    c0: +*,
    d0: +*,
    e0: +*]

Constructors

Tuple31( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t, item21: u, item22: v, item23: w, item24: x, item25: y, item26: z, item27: a0, item28: b0, item29: c0, item30: d0, item31: e0 )

`Tuple32[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a0, b0, c0, d0, e0, f0]`

type Tuple32[a: +*,
    b: +*,
    c: +*,
    d: +*,
    e: +*,
    f: +*,
    g: +*,
    h: +*,
    i: +*,
    j: +*,
    k: +*,
    l: +*,
    m: +*,
    n: +*,
    o: +*,
    p: +*,
    q: +*,
    r: +*,
    s: +*,
    t: +*,
    u: +*,
    v: +*,
    w: +*,
    x: +*,
    y: +*,
    z: +*,
    a0: +*,
    b0: +*,
    c0: +*,
    d0: +*,
    e0: +*,
    f0: +*]

Constructors

Tuple32( item1: a, item2: b, item3: c, item4: d, item5: e, item6: f, item7: g, item8: h, item9: i, item10: j, item11: k, item12: l, item13: m, item14: n, item15: o, item16: p, item17: q, item18: r, item19: s, item20: t, item21: u, item22: v, item23: w, item24: x, item25: y, item26: z, item27: a0, item28: b0, item29: c0, item30: d0, item31: e0, item32: f0 )

`Unit`

type Unit

Constructors

Unit

Values

`add`

Integer addition.

def add(a: Int, b: Int) -> Int

`add_key`

Insert or replace a key/value pair.

def add_key[a, b](dict: Dict[a, b], key: a, value: b) -> Dict[a, b]

`addf`

Floating-point addition.

def addf(a: Float64, b: Float64) -> Float64

`and_Int`

Bitwise AND.

def and_Int(a: Int, b: Int) -> Int

`build_List`

Build a list from a right-fold style builder.

def build_List[a](fn: forall b: *. ((a, b) -> b, b) -> b) -> List[a]

`char_List_to_String`

Concatenate a list of characters into a string.

def char_List_to_String(chars: List[Char]) -> String

`char_to_Int`

Unicode code point value for a character.

def char_to_Int(c: Char) -> Int

`char_to_String`

Convert a character to a one-character string.

def char_to_String(c: Char) -> String

`clear_Dict`

Remove all entries while preserving key ordering.

def clear_Dict[a, b](dict: Dict[a, b]) -> Dict[a, b]

`cmp_Float64`

Total Float64 comparison.

def cmp_Float64(a: Float64, b: Float64) -> Comparison

`cmp_Int`

Total integer comparison.

def cmp_Int(a: Int, b: Int) -> Comparison

`cmp_String`

Total string comparison.

def cmp_String(str0: String, str1: String) -> Comparison

`concat`

Append front and back.

def concat[a](front: List[a], back: List[a]) -> List[a]

`concat_String`

Concatenate a list of strings.

def concat_String(items: List[String]) -> String

`div`

Integer division.

def div(a: Int, b: Int) -> Int

`divf`

Floating-point division.

def divf(a: Float64, b: Float64) -> Float64

`empty_Dict`

Create an empty dictionary using comp for key ordering.

def empty_Dict[a](comp: Order[a]) -> Dict[a, forall a: *. a]

`eq_Int`

Integer equality.

def eq_Int(a: Int, b: Int) -> Bool

`flat_map_List`

Map each item to a list and flatten the result.

def flat_map_List[a, b](lst: List[a], fn: a -> List[b]) -> List[b]

`foldl_List`

Left fold over a list. Supports the deforestation rewrite: foldr_List(build_List(g), f, x) => g(f, x) See “A Shortcut to Deforestation” by Gill et. al.

def foldl_List[a, b](lst: List[a], item: b, fn: (b, a) -> b) -> b

`foldr_List`

Fold a list from right to left.

def foldr_List[a, b](list: List[a], fn: (a, b) -> b, acc: b) -> b

`gcd_Int`

Greatest common divisor for two integers.

def gcd_Int(a: Int, b: Int) -> Int

`get_key`

Look up the value associated with key.

def get_key[a, b](dict: Dict[a, b], key: a) -> Option[b]

`int_loop`

Loop until the returned Int is <= 0 or >= intValue.

def int_loop[a](intValue: Int, state: a, fn: (Int, a) -> (Int, a)) -> a

`int_to_Char`

Convert a Unicode code point to a character.

def int_to_Char(code_point: Int) -> Option[Char]

`int_to_String`

Convert an integer to its base-10 string form.

def int_to_String(i: Int) -> String

`items`

Return dictionary items in key order.

def items[a, b](dict: Dict[a, b]) -> List[(a, b)]

`length_String`

Count Unicode code points in a string.

def length_String(s: String) -> Int

`map_List`

Map each item in lst with fn.

def map_List[a, b](lst: List[a], fn: a -> b) -> List[b]

`mod_Int`

Integer modulus.

def mod_Int(a: Int, mod: Int) -> Int

`mul`

Integer multiplication.

def mul(a: Int, b: Int) -> Int

`not_Int`

Bitwise NOT.

def not_Int(a: Int) -> Int

`or_Int`

Bitwise OR.

def or_Int(a: Int, b: Int) -> Int

`partition_String`

if this returns Some((a, b)) then arg == concat_String([a, sep, b]) a and b are always proper substrings, so partition_String(a, "") == None this matches from the left, so partition_String(a, sep) == None

def partition_String(arg: String, sep: String) -> Option[(String, String)]

`range`

Build [0, 1, ..., exclusiveUpper - 1].

def range(exclusiveUpper: Int) -> List[Int]

`range_fold`

Fold over [inclusiveLower, ..., exclusiveUpper - 1].

def range_fold[a](inclusiveLower: Int, exclusiveUpper: Int, init: a, fn: (a, Int) -> a) -> a

`remove_key`

Remove a key from the dictionary (no-op if missing).

def remove_key[a, b](dict: Dict[a, b], key: a) -> Dict[a, b]

`replicate_List`

Repeat item cnt times.

def replicate_List[a](item: a, cnt: Int) -> List[a]

`reverse`

Reverse a list.

def reverse[a](as: List[a]) -> List[a]

`reverse_concat`

Reverse front and prepend it to back.

def reverse_concat[a](front: List[a], back: List[a]) -> List[a]

`rpartition_String`

if this returns Some((a, b)) then arg == concat_String([a, sep, b]) a and b are always proper substrings, so rpartition_String(a, "") == None this matches from the right, so partition_String(b, sep) == None

def rpartition_String(arg: String, sep: String) -> Option[(String, String)]

`shift_left_Int`

Bitwise left shift.

def shift_left_Int(arg: Int, shift: Int) -> Int

`shift_right_Int`

Bitwise right shift.

def shift_right_Int(arg: Int, shift: Int) -> Int

`string_Order`

Ordering instance for strings.

string_Order: Order[String]

`string_to_Int`

Parse a base-10 integer from a string.

def string_to_Int(s: String) -> Option[Int]

`sub`

Integer subtraction.

def sub(a: Int, b: Int) -> Int

`subf`

Floating-point subtraction.

def subf(a: Float64, b: Float64) -> Float64

`tail_or_empty_String`

if arg is empty this returns "", otherwise it drops exactly one codepoint (equivalent to the tail from uncons_String, but without constructing Option/Tuple)

def tail_or_empty_String(arg: String) -> String

`timesf`

Floating-point multiplication.

def timesf(a: Float64, b: Float64) -> Float64

`trace`

Emit a debug trace prefixed with prefix, then return item.

def trace[a](prefix: String, item: a) -> a

`uncons_String`

if this returns Some((h, t)) then arg == concat_String([char_to_String(h), t]) h is exactly one codepoint and t is the remaining suffix

def uncons_String(arg: String) -> Option[(Char, String)]

`uncurry2`

Some utilities for dealing with functions

def uncurry2[a, b, c](f: a -> b -> c) -> (a, b) -> c

`uncurry3`

Convert a curried 3-argument function into one that takes a tuple of 3 arguments.

def uncurry3[a, b, c, d](f: a -> b -> c -> d) -> (a, b, c) -> d

`xor_Int`

Bitwise XOR.

def xor_Int(a: Int, b: Int) -> Int

The source code for this page can be found here.

Next: Bosatsu/Prog