language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-02 19:32:17 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
roc/crates/compiler/load_internal/log.log
faldor20 cdf218fe7a
first working version of docs hover
2024-03-11 11:10:34 +10:00

58647 lines
2.1 MiB
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

warning: variable does not need to be mutable
--> crates/compiler/load_internal/src/file.rs:3342:5
|
3342 | mut documentation: VecMap<ModuleId, ModuleDocumentation>,
| ----^^^^^^^^^^^^^
| |
| help: remove this `mut`
|
= note: `#[warn(unused_mut)]` on by default
warning: `roc_load_internal` (lib) generated 1 warning (run `cargo fix --lib -p roc_load_internal` to apply 1 suggestion)
warning: unused variable: `prob`
--> crates/compiler/load_internal/tests/test_load.rs:430:9
|
430 | let prob = format!("{:#?}", loaded_modu...
| ^^^^ help: if this is intentional, prefix it with an underscore: `_prob`
|
= note: `#[warn(unused_variables)]` on by default
warning: unused variable: `prob_type`
--> crates/compiler/load_internal/tests/test_load.rs:431:9
|
431 | let prob_type = format!("{:#?}", loaded...
| ^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_prob_type`
warning: `roc_load_internal` (test "test_load") generated 2 warnings (run `cargo fix --test "test_load"` to apply 2 suggestions)
warning: `roc_load_internal` (lib test) generated 1 warning (1 duplicate)
Finished test [unoptimized + debuginfo] target(s) in 0.12s
Running unittests src/lib.rs (/home/eli/Code/roc/roc/target/debug/deps/roc_load_internal-96623c951353fc2b)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running tests/test_load.rs (/home/eli/Code/roc/roc/target/debug/deps/test_load-0e98648b386b463b)
running 34 tests
test file_not_found - should panic ... ok
test app_missing_package_import ... ok
test app_quicksort ... ok
test iface_quicksort ... ok
test iface_dep_types ... ok
test app_dep_types ... ok
test import_alias ... ok
test imported_file_not_found - should panic ... ok
test import_transitive_alias ... ok
test imported_dep_regression ... ok
test ingested_file_not_found - should panic ... ok
test import_builtin_in_platform_and_check_app ... ok
test ingested_file_bytes ... ok
test ingested_file ... ok
test issue_2863_module_type_does_not_exist ... ok
test interface_with_deps ... ok
test load_docs ... FAILED
test module_cyclic_import_itself ... ok
test module_cyclic_import_transitive ... ok
test module_doesnt_match_file_path ... ok
test module_interface_with_qualified_import ... ok
test load_astar ... ok
test nested_module_has_incorrect_name ... ok
test non_roc_file_extension ... ok
test load_principal_types ... ok
test platform_does_not_exist ... ok
test parse_problem ... ok
test platform_parse_error ... ok
test load_unit ... ok
test roc_file_no_extension ... ok
test opaque_wrapped_unwrapped_outside_defining_module ... ok
test platform_exposes_main_return_by_pointer_issue ... ok
test quicksort_one_def ... ok
test test_load_and_typecheck ... ok
failures:
---- load_docs stdout ----
<<docs:
"Most users won't need Box, it is used for:\n- Holding unknown Roc types when developing [platforms](https://github.com/roc-lang/roc/wiki/Roc-concepts-explained#platform).\n- To improve performance in rare cases.\n\n"
docs>>
<<docs:
Some(
"Allocates a value on the heap. Boxing is an expensive process as it copies\nthe value from the stack to the heap. This may provide a performance\noptimization for advanced use cases with large values. A platform may require\nthat some values are boxed.\n```\nexpect Box.unbox (Box.box \"Stack Faster\") == \"Stack Faster\"\n```\n",
)
docs>>
<<docs:
Some(
"Returns a boxed value.\n```\nexpect Box.unbox (Box.box \"Stack Faster\") == \"Stack Faster\"\n```\n",
)
docs>>
adding docs for "Box.roc",
docs ModuleDocumentation {
name: "Box",
entries: [
DetachedDoc(
"Most users won't need Box, it is used for:\n- Holding unknown Roc types when developing [platforms](https://github.com/roc-lang/roc/wiki/Roc-concepts-explained#platform).\n- To improve performance in rare cases.\n\n",
),
DocDef(
DocDef {
name: "box",
symbol: `Box.box`,
type_vars: [],
type_annotation: Function {
args: [
BoundVariable(
"a",
),
],
output: Apply {
name: "Box",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Allocates a value on the heap. Boxing is an expensive process as it copies\nthe value from the stack to the heap. This may provide a performance\noptimization for advanced use cases with large values. A platform may require\nthat some values are boxed.\n```\nexpect Box.unbox (Box.box \"Stack Faster\") == \"Stack Faster\"\n```\n",
),
},
),
DocDef(
DocDef {
name: "unbox",
symbol: `Box.unbox`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Box",
parts: [
BoundVariable(
"a",
),
],
},
],
output: BoundVariable(
"a",
),
},
docs: Some(
"Returns a boxed value.\n```\nexpect Box.unbox (Box.box \"Stack Faster\") == \"Stack Faster\"\n```\n",
),
},
),
],
scope: Scope {
aliases: VecMap {
keys: [],
values: [],
},
abilities_store: IAbilitiesStore {
members_of_ability: {},
specialization_to_root: {},
ability_members: {},
declared_implementations: {},
specializations: {},
next_specialization_id: 1,
resolved_specializations: {},
},
home: Box,
exposed_ident_count: 3,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
66,
111,
120,
98,
111,
120,
117,
110,
98,
111,
120,
],
lengths: [
Interned(3),
Interned(3),
Interned(5),
],
offsets: [
0,
3,
6,
],
strings: [
"Box",
"box",
"unbox",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffedbcdff0,
head: 000000,
bits: 3,
capacity: 64,
} [
0,
1,
1,
],
regions: [
…,
@616-619,
@737-742,
],
home: Box,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`Box.box`,
`Box.unbox`,
],
},
},
<<docs:
Some(
"Defines a type that can be compared for total equality.\n\nTotal equality means that all values of the type can be compared to each\nother, and two values `a`, `b` are identical if and only if `isEq a b` is\n`Bool.true`.\n\nNot all types support total equality. For example, [`F32`](../Num#F32) and [`F64`](../Num#F64) can\nbe a `NaN` ([Not a Number](https://en.wikipedia.org/wiki/NaN)), and the\n[IEEE-754](https://en.wikipedia.org/wiki/IEEE_754) floating point standard\nspecifies that two `NaN`s are not equal.\n",
)
docs>>
<<docs:
Some(
"Represents the boolean true and false using an opaque type.\n`Bool` implements the `Eq` ability.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"The boolean true value.\n",
)
docs>>
<<docs:
Some(
"The boolean false value.\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` when both inputs are `Bool.true`. This is equivalent to\nthe logic [AND](https://en.wikipedia.org/wiki/Logical_conjunction)\ngate. The infix operator `&&` can also be used as shorthand for\n`Bool.and`.\n\n```\nexpect (Bool.and Bool.true Bool.true) == Bool.true\nexpect (Bool.true && Bool.true) == Bool.true\nexpect (Bool.false && Bool.true) == Bool.false\nexpect (Bool.true && Bool.false) == Bool.false\nexpect (Bool.false && Bool.false) == Bool.false\n```\n\n## Performance Details\n\nIn Roc the `&&` and `||` work the same way as any\nother function. However, in some languages `&&` and `||` are special-cased.\nIn these languages the compiler will skip evaluating the expression after the\nfirst operator under certain circumstances. For example an expression like\n`enablePets && likesDogs user` would compile to.\n```\nif enablePets then\n likesDogs user\nelse\n Bool.false\n```\nRoc does not do this because conditionals like `if` and `when` have a\nperformance cost. Calling a function can sometimes be faster across the board\nthan doing an `if` to decide whether to skip calling it.\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` when either input is a `Bool.true`. This is equivalent to\nthe logic [OR](https://en.wikipedia.org/wiki/Logical_disjunction) gate.\nThe infix operator `||` can also be used as shorthand for `Bool.or`.\n```\nexpect (Bool.or Bool.false Bool.true) == Bool.true\nexpect (Bool.true || Bool.true) == Bool.true\nexpect (Bool.false || Bool.true) == Bool.true\nexpect (Bool.true || Bool.false) == Bool.true\nexpect (Bool.false || Bool.false) == Bool.false\n```\n\n## Performance Details\n\nIn Roc the `&&` and `||` work the same way as any\nother functions. However, in some languages `&&` and `||` are special-cased.\nRefer to the note in `Bool.and` for more detail.\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.false` when given `Bool.true`, and vice versa. This is\nequivalent to the logic [NOT](https://en.wikipedia.org/wiki/Negation)\ngate. The operator `!` can also be used as shorthand for `Bool.not`.\n```\nexpect (Bool.not Bool.false) == Bool.true\nexpect (!Bool.false) == Bool.true\n```\n",
)
docs>>
<<docs:
Some(
"This will call the function `Bool.isEq` on the inputs, and then `Bool.not`\non the result. The is equivalent to the logic\n[XOR](https://en.wikipedia.org/wiki/Exclusive_or) gate. The infix operator\n`!=` can also be used as shorthand for `Bool.isNotEq`.\n\n**Note** that `isNotEq` does not accept arguments whose types contain\nfunctions.\n```\nexpect (Bool.isNotEq Bool.false Bool.true) == Bool.true\nexpect (Bool.false != Bool.false) == Bool.false\nexpect \"Apples\" != \"Oranges\"\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
adding docs for "Bool.roc",
docs ModuleDocumentation {
name: "Bool",
entries: [
DocDef(
DocDef {
name: "Eq",
symbol: `Bool.Eq`,
type_vars: [],
type_annotation: Ability {
members: [
AbilityMember {
name: "isEq",
type_annotation: Function {
args: [
BoundVariable(
"a",
),
BoundVariable(
"a",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
able_variables: [
(
"a",
[
Apply {
name: "Eq",
parts: [],
},
],
),
],
docs: Some(
"Returns `Bool.true` if the input values are equal. This is\nequivalent to the logic\n[XNOR](https://en.wikipedia.org/wiki/Logical_equality) gate. The infix\noperator `==` can be used as shorthand for `Bool.isEq`.\n\n**Note** that when `isEq` is determined by the Roc compiler, values are\ncompared using structural equality. The rules for this are as follows:\n\n1. Tags are equal if their name and also contents are equal.\n2. Records are equal if their fields are equal.\n3. The collections [Str], [List], [Dict], and [Set] are equal iff they\nare the same length and their elements are equal.\n4. [Num] values are equal if their numbers are equal. However, if both\ninputs are *NaN* then `isEq` returns `Bool.false`. Refer to `Num.isNaN`\nfor more detail.\n5. Functions cannot be compared for structural equality, therefore Roc\ncannot derive `isEq` for types that contain functions.\n",
),
},
],
},
docs: Some(
"Defines a type that can be compared for total equality.\n\nTotal equality means that all values of the type can be compared to each\nother, and two values `a`, `b` are identical if and only if `isEq a b` is\n`Bool.true`.\n\nNot all types support total equality. For example, [`F32`](../Num#F32) and [`F64`](../Num#F64) can\nbe a `NaN` ([Not a Number](https://en.wikipedia.org/wiki/NaN)), and the\n[IEEE-754](https://en.wikipedia.org/wiki/IEEE_754) floating point standard\nspecifies that two `NaN`s are not equal.\n",
),
},
),
DocDef(
DocDef {
name: "Bool",
symbol: `Bool.Bool`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: Some(
"Represents the boolean true and false using an opaque type.\n`Bool` implements the `Eq` ability.\n",
),
},
),
DocDef(
DocDef {
name: "true",
symbol: `Bool.true`,
type_vars: [],
type_annotation: Apply {
name: "Bool",
parts: [],
},
docs: Some(
"The boolean true value.\n",
),
},
),
DocDef(
DocDef {
name: "false",
symbol: `Bool.false`,
type_vars: [],
type_annotation: Apply {
name: "Bool",
parts: [],
},
docs: Some(
"The boolean false value.\n",
),
},
),
DocDef(
DocDef {
name: "and",
symbol: `Bool.and`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Bool",
parts: [],
},
Apply {
name: "Bool",
parts: [],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` when both inputs are `Bool.true`. This is equivalent to\nthe logic [AND](https://en.wikipedia.org/wiki/Logical_conjunction)\ngate. The infix operator `&&` can also be used as shorthand for\n`Bool.and`.\n\n```\nexpect (Bool.and Bool.true Bool.true) == Bool.true\nexpect (Bool.true && Bool.true) == Bool.true\nexpect (Bool.false && Bool.true) == Bool.false\nexpect (Bool.true && Bool.false) == Bool.false\nexpect (Bool.false && Bool.false) == Bool.false\n```\n\n## Performance Details\n\nIn Roc the `&&` and `||` work the same way as any\nother function. However, in some languages `&&` and `||` are special-cased.\nIn these languages the compiler will skip evaluating the expression after the\nfirst operator under certain circumstances. For example an expression like\n`enablePets && likesDogs user` would compile to.\n```\nif enablePets then\n likesDogs user\nelse\n Bool.false\n```\nRoc does not do this because conditionals like `if` and `when` have a\nperformance cost. Calling a function can sometimes be faster across the board\nthan doing an `if` to decide whether to skip calling it.\n",
),
},
),
DocDef(
DocDef {
name: "or",
symbol: `Bool.or`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Bool",
parts: [],
},
Apply {
name: "Bool",
parts: [],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` when either input is a `Bool.true`. This is equivalent to\nthe logic [OR](https://en.wikipedia.org/wiki/Logical_disjunction) gate.\nThe infix operator `||` can also be used as shorthand for `Bool.or`.\n```\nexpect (Bool.or Bool.false Bool.true) == Bool.true\nexpect (Bool.true || Bool.true) == Bool.true\nexpect (Bool.false || Bool.true) == Bool.true\nexpect (Bool.true || Bool.false) == Bool.true\nexpect (Bool.false || Bool.false) == Bool.false\n```\n\n## Performance Details\n\nIn Roc the `&&` and `||` work the same way as any\nother functions. However, in some languages `&&` and `||` are special-cased.\nRefer to the note in `Bool.and` for more detail.\n",
),
},
),
DocDef(
DocDef {
name: "not",
symbol: `Bool.not`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Bool",
parts: [],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.false` when given `Bool.true`, and vice versa. This is\nequivalent to the logic [NOT](https://en.wikipedia.org/wiki/Negation)\ngate. The operator `!` can also be used as shorthand for `Bool.not`.\n```\nexpect (Bool.not Bool.false) == Bool.true\nexpect (!Bool.false) == Bool.true\n```\n",
),
},
),
DocDef(
DocDef {
name: "isNotEq",
symbol: `Bool.isNotEq`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"a",
),
BoundVariable(
"a",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
implements: [
ImplementsClause {
name: "a",
abilities: [
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: Some(
"This will call the function `Bool.isEq` on the inputs, and then `Bool.not`\non the result. The is equivalent to the logic\n[XOR](https://en.wikipedia.org/wiki/Exclusive_or) gate. The infix operator\n`!=` can also be used as shorthand for `Bool.isNotEq`.\n\n**Note** that `isNotEq` does not accept arguments whose types contain\nfunctions.\n```\nexpect (Bool.isNotEq Bool.false Bool.true) == Bool.true\nexpect (Bool.false != Bool.false) == Bool.false\nexpect \"Apples\" != \"Oranges\"\n```\n",
),
},
),
DocDef(
DocDef {
name: "structuralEq",
symbol: `Bool.structuralEq`,
type_vars: [],
type_annotation: Function {
args: [
BoundVariable(
"a",
),
BoundVariable(
"a",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "structuralNotEq",
symbol: `Bool.structuralNotEq`,
type_vars: [],
type_annotation: Function {
args: [
BoundVariable(
"a",
),
BoundVariable(
"a",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: None,
},
),
],
scope: Scope {
aliases: VecMap {
keys: [
`Bool.Bool`,
],
values: [
Alias {
region: @1780-1784,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: ['False', 'True'],
kind: Opaque,
},
],
},
abilities_store: IAbilitiesStore {
members_of_ability: {
`Bool.Eq`: [
`Bool.isEq`,
],
},
specialization_to_root: {
`Bool.boolIsEq`: ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
},
},
ability_members: {
`Bool.isEq`: AbilityMemberData {
parent_ability: `Bool.Eq`,
region: @1635-1639,
typ: Local {
signature_var: 65,
signature: Fn(<63>, <63> |Uls(63:`Bool.isEq`:1)| -> (DelayedAlias `Bool.Bool`)),
variables: MemberVariables {
able_vars: [
63,
],
rigid_vars: [
64,
],
flex_vars: [],
},
},
},
},
declared_implementations: {
ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
}: Impl(
`Bool.boolIsEq`,
),
},
specializations: {},
next_specialization_id: 1,
resolved_specializations: {},
},
home: Bool,
exposed_ident_count: 11,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
66,
111,
111,
108,
102,
97,
108,
115,
101,
116,
114,
117,
101,
97,
110,
100,
111,
114,
110,
111,
116,
120,
111,
114,
105,
115,
78,
111,
116,
69,
113,
69,
113,
105,
115,
69,
113,
98,
111,
111,
108,
73,
115,
69,
113,
115,
116,
114,
117,
99,
116,
117,
114,
97,
108,
69,
113,
115,
116,
114,
117,
99,
116,
117,
114,
97,
108,
78,
111,
116,
69,
113,
69,
113,
66,
111,
111,
108,
98,
49,
98,
50,
49,
55,
49,
56,
97,
98,
],
lengths: [
Interned(4),
Interned(5),
Interned(4),
Interned(3),
Interned(2),
Interned(3),
Interned(3),
Interned(7),
Interned(2),
Interned(4),
Interned(8),
Interned(12),
Interned(15),
Interned(2),
Interned(4),
Interned(2),
Interned(2),
Generated(2),
Generated(2),
Interned(1),
Interned(1),
],
offsets: [
0,
4,
9,
13,
16,
18,
21,
24,
31,
33,
37,
45,
57,
72,
74,
78,
80,
82,
84,
86,
87,
],
strings: [
"Bool",
"false",
"true",
"and",
"or",
"not",
"xor",
"isNotEq",
"Eq",
"isEq",
"boolIsEq",
"structuralEq",
"structuralNotEq",
"Eq",
"Bool",
"b1",
"b2",
"17",
"18",
"a",
"b",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffec6ad400,
head: 000000,
bits: 21,
capacity: 64,
} [
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
],
regions: [
@1780-1801,
@1991-1996,
@1931-1935,
@3186-3189,
@3922-3924,
@4260-4263,
…,
@4834-4841,
@629-631,
@1635-1639,
@1838-1846,
@5001-5013,
@5165-5180,
…,
…,
@1856-1858,
@1866-1868,
…,
…,
@4845-4846,
@4848-4849,
],
home: Bool,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`Bool.Bool`,
`Bool.Eq`,
`Bool.true`,
`Bool.false`,
`Bool.and`,
`Bool.or`,
`Bool.not`,
`Bool.isEq`,
`Bool.isNotEq`,
],
},
},
<<docs:
Some(
"The result of an operation that could fail: either the operation went\nokay, or else there was an error of some sort.\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` if the result indicates a success, else returns `Bool.false`\n```\nResult.isOk (Ok 5)\n```\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` if the result indicates a failure, else returns `Bool.false`\n```\nResult.isErr (Err \"uh oh\")\n```\n",
)
docs>>
<<docs:
Some(
"If the result is `Ok`, returns the value it holds. Otherwise, returns\nthe given default value.\n```\nResult.withDefault (Ok 7) 42\nResult.withDefault (Err \"uh oh\") 42\n```\n",
)
docs>>
<<docs:
Some(
"If the result is `Ok`, transforms the value it holds by running a conversion\nfunction on it. Then returns a new `Ok` holding the transformed value. If the\nresult is `Err`, this has no effect. Use [mapErr] to transform an `Err`.\n```\nResult.map (Ok 12) Num.neg\nResult.map (Err \"yipes!\") Num.neg\n```\n\nFunctions like `map` are common in Roc; see for example [List.map],\n`Set.map`, and `Dict.map`.\n",
)
docs>>
<<docs:
Some(
"If the result is `Err`, transforms the value it holds by running a conversion\nfunction on it. Then returns a new `Err` holding the transformed value. If\nthe result is `Ok`, this has no effect. Use [map] to transform an `Ok`.\n```\nResult.mapErr (Err \"yipes!\") Str.isEmpty\nResult.mapErr (Ok 12) Str.isEmpty\n```\n",
)
docs>>
<<docs:
Some(
"If the result is `Ok`, transforms the entire result by running a conversion\nfunction on the value the `Ok` holds. Then returns that new result. If the\nresult is `Err`, this has no effect. Use `onErr` to transform an `Err`.\n```\nResult.try (Ok -1) \\num -> if num < 0 then Err \"negative!\" else Ok -num\nResult.try (Err \"yipes!\") \\num -> if num < 0 then Err \"negative!\" else Ok -num\n```\n",
)
docs>>
<<docs:
Some(
"If the result is `Err`, transforms the entire result by running a conversion\nfunction on the value the `Err` holds. Then returns that new result. If the\nresult is `Ok`, this has no effect. Use `try` to transform an `Ok`.\n```\nResult.onErr (Ok 10) \\errorNum -> Str.toU64 errorNum\nResult.onErr (Err \"42\") \\errorNum -> Str.toU64 errorNum\n```\n",
)
docs>>
adding docs for "Result.roc",
docs ModuleDocumentation {
name: "Result",
entries: [
DocDef(
DocDef {
name: "Result",
symbol: `Result.Result`,
type_vars: [
"ok",
"err",
],
type_annotation: TagUnion {
tags: [
Tag {
name: "Ok",
values: [
BoundVariable(
"ok",
),
],
},
Tag {
name: "Err",
values: [
BoundVariable(
"err",
),
],
},
],
extension: NoTypeAnn,
},
docs: Some(
"The result of an operation that could fail: either the operation went\nokay, or else there was an error of some sort.\n",
),
},
),
DocDef(
DocDef {
name: "isOk",
symbol: `Result.isOk`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Result",
parts: [
BoundVariable(
"ok",
),
BoundVariable(
"err",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` if the result indicates a success, else returns `Bool.false`\n```\nResult.isOk (Ok 5)\n```\n",
),
},
),
DocDef(
DocDef {
name: "isErr",
symbol: `Result.isErr`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Result",
parts: [
BoundVariable(
"ok",
),
BoundVariable(
"err",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` if the result indicates a failure, else returns `Bool.false`\n```\nResult.isErr (Err \"uh oh\")\n```\n",
),
},
),
DocDef(
DocDef {
name: "withDefault",
symbol: `Result.withDefault`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Result",
parts: [
BoundVariable(
"ok",
),
BoundVariable(
"err",
),
],
},
BoundVariable(
"ok",
),
],
output: BoundVariable(
"ok",
),
},
docs: Some(
"If the result is `Ok`, returns the value it holds. Otherwise, returns\nthe given default value.\n```\nResult.withDefault (Ok 7) 42\nResult.withDefault (Err \"uh oh\") 42\n```\n",
),
},
),
DocDef(
DocDef {
name: "map",
symbol: `Result.map`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Result",
parts: [
BoundVariable(
"a",
),
BoundVariable(
"err",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: BoundVariable(
"b",
),
},
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"b",
),
BoundVariable(
"err",
),
],
},
},
docs: Some(
"If the result is `Ok`, transforms the value it holds by running a conversion\nfunction on it. Then returns a new `Ok` holding the transformed value. If the\nresult is `Err`, this has no effect. Use [mapErr] to transform an `Err`.\n```\nResult.map (Ok 12) Num.neg\nResult.map (Err \"yipes!\") Num.neg\n```\n\nFunctions like `map` are common in Roc; see for example [List.map],\n`Set.map`, and `Dict.map`.\n",
),
},
),
DocDef(
DocDef {
name: "mapErr",
symbol: `Result.mapErr`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Result",
parts: [
BoundVariable(
"ok",
),
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: BoundVariable(
"b",
),
},
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"ok",
),
BoundVariable(
"b",
),
],
},
},
docs: Some(
"If the result is `Err`, transforms the value it holds by running a conversion\nfunction on it. Then returns a new `Err` holding the transformed value. If\nthe result is `Ok`, this has no effect. Use [map] to transform an `Ok`.\n```\nResult.mapErr (Err \"yipes!\") Str.isEmpty\nResult.mapErr (Ok 12) Str.isEmpty\n```\n",
),
},
),
DocDef(
DocDef {
name: "try",
symbol: `Result.try`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Result",
parts: [
BoundVariable(
"a",
),
BoundVariable(
"err",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"b",
),
BoundVariable(
"err",
),
],
},
},
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"b",
),
BoundVariable(
"err",
),
],
},
},
docs: Some(
"If the result is `Ok`, transforms the entire result by running a conversion\nfunction on the value the `Ok` holds. Then returns that new result. If the\nresult is `Err`, this has no effect. Use `onErr` to transform an `Err`.\n```\nResult.try (Ok -1) \\num -> if num < 0 then Err \"negative!\" else Ok -num\nResult.try (Err \"yipes!\") \\num -> if num < 0 then Err \"negative!\" else Ok -num\n```\n",
),
},
),
DocDef(
DocDef {
name: "onErr",
symbol: `Result.onErr`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Result",
parts: [
BoundVariable(
"a",
),
BoundVariable(
"err",
),
],
},
Function {
args: [
BoundVariable(
"err",
),
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"a",
),
BoundVariable(
"otherErr",
),
],
},
},
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"a",
),
BoundVariable(
"otherErr",
),
],
},
},
docs: Some(
"If the result is `Err`, transforms the entire result by running a conversion\nfunction on the value the `Err` holds. Then returns that new result. If the\nresult is `Ok`, this has no effect. Use `try` to transform an `Ok`.\n```\nResult.onErr (Ok 10) \\errorNum -> Str.toU64 errorNum\nResult.onErr (Err \"42\") \\errorNum -> Str.toU64 errorNum\n```\n",
),
},
),
],
scope: Scope {
aliases: VecMap {
keys: [
`Bool.Bool`,
`Result.Result`,
],
values: [
Alias {
region: @1780-1784,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: ['False', 'True'],
kind: Opaque,
},
Alias {
region: @241-254,
type_variables: [
@248-250 AliasVar {
name: 'ok',
var: 64,
opt_bound_abilities: None,
},
@251-254 AliasVar {
name: 'err',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['Err' <65>, 'Ok' <64>]<63>,
kind: Structural,
},
],
},
abilities_store: IAbilitiesStore {
members_of_ability: {
`Bool.Eq`: [
`Bool.isEq`,
],
},
specialization_to_root: {
`Bool.boolIsEq`: ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
},
},
ability_members: {
`Bool.isEq`: AbilityMemberData {
parent_ability: `Bool.Eq`,
region: @1635-1639,
typ: Imported,
},
},
declared_implementations: {
ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
}: Impl(
`Bool.boolIsEq`,
),
},
specializations: {},
next_specialization_id: 1,
resolved_specializations: {},
},
home: Result,
exposed_ident_count: 10,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "Bool",
},
),
`Bool.Bool`,
@109-113,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
82,
101,
115,
117,
108,
116,
79,
107,
69,
114,
114,
109,
97,
112,
109,
97,
112,
69,
114,
114,
119,
105,
116,
104,
68,
101,
102,
97,
117,
108,
116,
116,
114,
121,
105,
115,
79,
107,
105,
115,
69,
114,
114,
111,
110,
69,
114,
114,
114,
101,
115,
117,
108,
116,
100,
101,
102,
97,
117,
108,
116,
118,
97,
108,
117,
101,
116,
114,
97,
110,
115,
102,
111,
114,
109,
118,
49,
56,
101,
50,
48,
50,
52,
50,
54,
51,
49,
51,
53,
],
lengths: [
Interned(6),
Interned(2),
Interned(3),
Interned(3),
Interned(6),
Interned(11),
Interned(3),
Interned(4),
Interned(5),
Interned(5),
Interned(6),
Interned(6),
Interned(6),
Interned(7),
Interned(5),
Interned(6),
Interned(9),
Interned(1),
Generated(2),
Interned(1),
Generated(2),
Interned(6),
Interned(9),
Interned(1),
Generated(2),
Interned(1),
Generated(2),
Interned(6),
Interned(9),
Interned(1),
Interned(1),
Generated(2),
Interned(6),
Interned(9),
Interned(1),
Generated(2),
Interned(1),
],
offsets: [
0,
6,
8,
11,
14,
20,
31,
34,
38,
43,
48,
48,
48,
54,
61,
48,
66,
75,
76,
78,
79,
48,
66,
75,
81,
78,
83,
48,
66,
75,
78,
85,
48,
66,
75,
87,
78,
],
strings: [
"Result",
"Ok",
"Err",
"map",
"mapErr",
"withDefault",
"try",
"isOk",
"isErr",
"onErr",
"result",
"result",
"result",
"default",
"value",
"result",
"transform",
"v",
"18",
"e",
"20",
"result",
"transform",
"v",
"24",
"e",
"26",
"result",
"transform",
"v",
"e",
"31",
"result",
"transform",
"v",
"35",
"e",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffecb00b40,
head: 000000,
bits: 37,
capacity: 64,
} [
1,
0,
0,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
regions: [
@241-273,
…,
…,
@1563-1566,
@2042-2048,
@991-1002,
@2608-2611,
@424-428,
@674-679,
@3136-3141,
@432-438,
@683-689,
@1006-1012,
@1014-1021,
@1055-1060,
@1570-1576,
@1578-1587,
@1621-1622,
…,
@1655-1656,
…,
@2052-2058,
@2060-2069,
@2103-2104,
…,
@2125-2126,
…,
@2615-2621,
@2623-2632,
@2666-2667,
@2695-2696,
…,
@3145-3151,
@3153-3162,
@3196-3197,
…,
@3218-3219,
],
home: Result,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`Result.Result`,
`Result.isOk`,
`Result.isErr`,
`Result.map`,
`Result.mapErr`,
`Result.try`,
`Result.onErr`,
`Result.withDefault`,
],
},
},
<<docs:
Some(
"Represents a number that could be either an [Int] or a [Frac].\n\nThis is useful for functions that can work on either, for example [Num.add], whose type is:\n```\nadd : Num a, Num a -> Num a\n```\nThe number 1.5 technically has the type `Num (Fraction *)`, so when you pass\ntwo of them to [Num.add], the answer you get is `3.0 : Num (Fraction *)`.\n\nSimilarly, the number 0x1 (that is, the integer 1 in hexadecimal notation)\ntechnically has the type `Num (Integer *)`, so when you pass two of them to\n[Num.add], the answer you get is `2 : Num (Integer *)`.\n\nThe type [`Frac a`](#Frac) is defined to be an alias for `Num (Fraction a)`,\nso `3.0 : Num (Fraction *)` is the same value as `3.0 : Frac *`.\nSimilarly, the type [`Int a`](#Int) is defined to be an alias for\n`Num (Integer a)`, so `2 : Num (Integer *)` is the same value as\n`2 : Int *`.\n\nIn this way, the [Num] type makes it possible to have `1 + 0x1` return\n`2 : Int *` and `1.5 + 1.5` return `3.0 : Frac`.\n\n## Number Literals\n\nNumber literals without decimal points (like `0`, `4` or `360`)\nhave the type `Num *` at first, but usually end up taking on\na more specific type based on how they're used.\n\nFor example, in `(1 + List.len myList)`, the `1` has the type `Num *` at first,\nbut because `List.len` returns a `U64`, the `1` ends up changing from\n`Num *` to the more specific `U64`, and the expression as a whole\nends up having the type `U64`.\n\nSometimes number literals don't become more specific. For example,\nthe `Num.toStr` function has the type `Num * -> Str`. This means that\nwhen calling `Num.toStr (5 + 6)`, the expression `(5 + 6)`\nstill has the type `Num *`. When this happens, `Num *` defaults to\nbeing an [I64] - so this addition expression would overflow\nif either 5 or 6 were replaced with a number big enough to cause\naddition overflow on an [I64] value.\n\nIf this default of [I64] is not big enough for your purposes,\nyou can add an `i128` to the end of the number literal, like so:\n```\nNum.toStr 5_000_000_000i128\n```\nThis `i128` suffix specifies that you want this number literal to be\nan [I128] instead of a `Num *`. All the other numeric types have\nsuffixes just like `i128`; here are some other examples:\n\n* `215u8` is a `215` value of type [U8]\n* `76.4f32` is a `76.4` value of type [F32]\n* `123.45dec` is a `123.45` value of type [Dec]\n\nIn practice, these are rarely needed. It's most common to write\nnumber literals without any suffix.\n",
)
docs>>
<<docs:
Some(
"A fixed-size integer - that is, a number with no fractional component.\n\nIntegers come in two flavors: signed and unsigned. Signed integers can be\nnegative (\"signed\" refers to how they can incorporate a minus sign),\nwhereas unsigned integers cannot be negative.\n\nSince integers have a fixed size, the size you choose determines both the\nrange of numbers it can represent, and also how much memory it takes up.\n\n[U8] is an an example of an integer. It is an unsigned [Int] that takes up 8 bits\n(aka 1 byte) in memory. The `U` is for Unsigned and the 8 is for 8 bits.\nBecause it has 8 bits to work with, it can store 256 numbers (2^8),\nand because it is unsigned, its min value is 0. This means the 256 numbers\nit can store range from 0 to 255.\n\n[I8] is a signed integer that takes up 8 bits. The `I` is for Integer, since\nintegers in mathematics are signed by default. Because it has 8 bits just\nlike [U8], it can store 256 numbers (still 2^8), but because it is signed,\nthe range is different. Its 256 numbers range from -128 to 127.\n\nHere are some other examples:\n\n* [U16] is like [U8], except it takes up 16 bits in memory. It can store 65,536 numbers (2^16), ranging from 0 to 65,536.\n* [I16] is like [U16], except it is signed. It can still store the same 65,536 numbers (2^16), ranging from -32,768 to 32,767.\n\nThis pattern continues up to [U128] and [I128].\n\n## Performance Details\n\nIn general, using smaller numeric sizes means your program will use less memory.\nHowever, if a mathematical operation results in an answer that is too big\nor too small to fit in the size available for that answer (which is typically\nthe same size as the inputs), then you'll get an overflow error.\n\nAs such, minimizing memory usage without causing overflows involves choosing\nnumber sizes based on your knowledge of what numbers you expect your program\nto encounter at runtime.\n\nMinimizing memory usage does not imply maximum runtime speed!\nCPUs are typically fastest at performing integer operations on integers that\nare the same size as that CPU's native machine word size. That means a 64-bit\nCPU is typically fastest at executing instructions on [U64] and [I64] values,\nwhereas a 32-bit CPU is typically fastest on [U32] and [I32] values.\n\nPutting these factors together, here are some reasonable guidelines for optimizing performance through integer size choice:\n\n* Start by deciding if this integer should allow negative numbers, and choose signed or unsigned accordingly.\n* Next, think about the range of numbers you expect this number to hold. Choose the smallest size you will never expect to overflow, no matter the inputs your program receives. (Validating inputs for size, and presenting the user with an error if they are too big, can help guard against overflow.)\n* Finally, if a particular numeric calculation is running too slowly, you can try experimenting with other number sizes. This rarely makes a meaningful difference, but some processors can operate on different number sizes at different speeds.\n\nAll number literals without decimal points are compatible with [Int] values.\n\nYou can optionally put underscores in your [Int] literals.\nThey have no effect on the number's value, but can make large numbers easier to read.\n```\n1_000_000\n```\nIntegers come in two flavors: *signed* and *unsigned*.\n\n* *Unsigned* integers can never be negative. The lowest value they can hold is zero.\n* *Signed* integers can be negative.\n\nIntegers also come in different sizes. Choosing a size depends on your performance\nneeds and the range of numbers you need to represent. At a high level, the\ngeneral trade-offs are:\n\n* Larger integer sizes can represent a wider range of numbers. If you absolutely need to represent numbers in a certain range, make sure to pick an integer size that can hold them!\n* Smaller integer sizes take up less memory. These savings rarely matter in variables and function arguments, but the sizes of integers that you use in data structures can add up. This can also affect whether those data structures fit in [cache lines](https://en.wikipedia.org/wiki/CPU_cache#Cache_performance), which can be a performance bottleneck.\n* Certain CPUs work faster on some numeric sizes than others. If the CPU is taking too long to run numeric calculations, you may find a performance improvement by experimenting with numeric sizes that are larger than otherwise necessary. However, in practice, doing this typically degrades overall performance, so be careful to measure properly!\n\nHere are the different fixed size integer types:\n\n| Range | Type | Size |\n|--------------------------------------------------------|-------|----------|\n| ` -128` | [I8] | 1 Byte |\n| ` 127` | | |\n|--------------------------------------------------------|-------|----------|\n| ` 0` | [U8] | 1 Byte |\n| ` 255` | | |\n|--------------------------------------------------------|-------|----------|\n| ` -32_768` | [I16] | 2 Bytes |\n| ` 32_767` | | |\n|--------------------------------------------------------|-------|----------|\n| ` 0` | [U16] | 2 Bytes |\n| ` 65_535` | | |\n|--------------------------------------------------------|-------|----------|\n| ` -2_147_483_648` | [I32] | 4 Bytes |\n| ` 2_147_483_647` | | |\n|--------------------------------------------------------|-------|----------|\n| ` 0` | [U32] | 4 Bytes |\n| ` (over 4 billion) 4_294_967_295` | | |\n|--------------------------------------------------------|-------|----------|\n| ` -9_223_372_036_854_775_808` | [I64] | 8 Bytes |\n| ` 9_223_372_036_854_775_807` | | |\n|--------------------------------------------------------|-------|----------|\n| ` 0` | [U64] | 8 Bytes |\n| ` (over 18 quintillion) 18_446_744_073_709_551_615` | | |\n|--------------------------------------------------------|-------|----------|\n| `-170_141_183_460_469_231_731_687_303_715_884_105_728` | [I128]| 16 Bytes |\n| ` 170_141_183_460_469_231_731_687_303_715_884_105_727` | | |\n|--------------------------------------------------------|-------|----------|\n| ` (over 340 undecillion) 0` | [U128]| 16 Bytes |\n| ` 340_282_366_920_938_463_463_374_607_431_768_211_455` | | |\n\nIf any operation would result in an [Int] that is either too big\nor too small to fit in that range (e.g. calling `Num.maxI32 + 1`),\nthen the operation will *overflow*. When an overflow occurs, the program will crash.\n\nAs such, it's very important to design your code not to exceed these bounds!\nIf you need to do math outside these bounds, consider using a larger numeric size.\n",
)
docs>>
<<docs:
Some(
"A fixed-size number with a fractional component.\n\nRoc fractions come in two flavors: fixed-point base-10 and floating-point base-2.\n\n* [Dec] is a 128-bit [fixed-point](https://en.wikipedia.org/wiki/Fixed-point_arithmetic) base-10 number. It's a great default choice, especially when precision is important - for example when representing currency. With [Dec], `0.1 + 0.2` returns `0.3`. [Dec] has 18 decimal places of precision and a range from `-170_141_183_460_469_231_731.687303715884105728` to `170_141_183_460_469_231_731.687303715884105727`.\n* [F64] and [F32] are [floating-point](https://en.wikipedia.org/wiki/Floating-point_arithmetic) base-2 numbers. They sacrifice precision for lower memory usage and improved performance on some operations. This makes them a good fit for representing graphical coordinates. With [F64], `0.1 + 0.2` returns `0.30000000000000004`.\n\nIf you don't specify a type, Roc will default to using [Dec] because it's\nthe least error-prone overall. For example, suppose you write this:\n```\nwasItPrecise = 0.1 + 0.2 == 0.3\n```\nThe value of `wasItPrecise` here will be `Bool.true`, because Roc uses [Dec]\nby default when there are no types specified.\n\nIn contrast, suppose we use `f32` or `f64` for one of these numbers:\n```\nwasItPrecise = 0.1f64 + 0.2 == 0.3\n```\nHere, `wasItPrecise` will be `Bool.false` because the entire calculation will have\nbeen done in a base-2 floating point calculation, which causes noticeable\nprecision loss in this case.\n\nThe floating-point numbers ([F32] and [F64]) also have three values which\nare not ordinary [finite numbers](https://en.wikipedia.org/wiki/Finite_number).\nThey are:\n* ∞ ([infinity](https://en.wikipedia.org/wiki/Infinity))\n* -∞ (negative infinity)\n* *NaN* ([not a number](https://en.wikipedia.org/wiki/NaN))\n\nThese values are different from ordinary numbers in that they only occur\nwhen a floating-point calculation encounters an error. For example:\n* Dividing a positive [F64] by `0.0` returns ∞.\n* Dividing a negative [F64] by `0.0` returns -∞.\n* Dividing a [F64] of `0.0` by `0.0` returns [*NaN*](Num.isNaN).\n\nThese rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)\nfloating point standard. Because almost all modern processors are built to\nthis standard, deviating from these rules has a significant performance\ncost! Since the most common reason to choose [F64] or [F32] over [Dec] is\naccess to hardware-accelerated performance, Roc follows these rules exactly.\n\nThere's no literal syntax for these error values, but you can check to see if\nyou ended up with one of them by using #isNaN, #isFinite, and #isInfinite.\nWhenever a function in this module could return one of these values, that\npossibility is noted in the function's documentation.\n\n## Performance Details\n\nOn typical modern CPUs, performance is similar between [Dec], [F64], and [F32]\nfor addition and subtraction. For example, [F32] and [F64] do addition using\na single CPU floating-point addition instruction, which typically takes a\nfew clock cycles to complete. In contrast, [Dec] does addition using a few\nCPU integer arithmetic instructions, each of which typically takes only one\nclock cycle to complete. Exact numbers will vary by CPU, but they should be\nsimilar overall.\n\n[Dec] is significantly slower for multiplication and division. It not only\nneeds to do more arithmetic instructions than [F32] and [F64] do, but also\nthose instructions typically take more clock cycles to complete.\n\nWith [Num.sqrt] and trigonometry functions like [Num.cos], there is\nan even bigger performance difference. [F32] and [F64] can do these in a\nsingle instruction, whereas [Dec] needs entire custom procedures - which use\nloops and conditionals. If you need to do performance-critical trigonometry\nor square roots, either [F64] or [F32] is probably a better choice than the\nusual default choice of [Dec], despite the precision problems they bring.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"A signed 8-bit integer, ranging from -128 to 127\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"A 64-bit [IEEE 754 binary floating-point number](https://en.wikipedia.org/wiki/IEEE_754).\n\n[F64] represents decimal numbers less precisely than [Dec] does, but operations on it\ncan be faster because CPUs have hardware-level support for [F64] but not [Dec]. There\nare other tradeoffs between the two, such as:\n* [Dec] has a fixed number of digits it can represent before the decimal point, and a fixed number it can represent after the decimal point. In contrast, [F64]'s decimal point can \"float\"—which conceptually means if you don't need many digits before the decimal point, you can get more digits of precision afterwards (and vice versa).\n* [Dec] represents its number internally in [base-10](https://en.wikipedia.org/wiki/Decimal), whereas [F64] uses [base-2](https://en.wikipedia.org/wiki/Binary_number). This can lead to imprecise answers like `0.1 + 0.2` returning `0.3` for [Dec] and `0.30000000000000004` for [F64]. This is not a bug; rather, it's a consequence of [F64]'s base-2 representation.\n* [Dec] always gives a precise answer (or an error), whereas [F64] can lose precision. For example, increasing a very large [F64] number (using addition, perhaps) can result in the whole number portion being incorrect. `1234567890123456789 + 100` correctly results in a number ending in `889` for `Dec`, but results in a number ending `800` in [F64] due to precision loss.\n",
)
docs>>
<<docs:
Some(
"A 32-bit [IEEE 754 binary floating-point number](https://en.wikipedia.org/wiki/IEEE_754).\n\nThis works just like [F64] (see its docs for a comparison with [Dec]) except it's smaller.\nThat in turn means it takes up less memory, but can store smaller numbers (and becomes imprecise\nmore easily than [F64] does).\n",
)
docs>>
<<docs:
Some(
"A [decimal](https://en.wikipedia.org/wiki/Decimal) number.\n\n[Dec] is a more precise way to represent decimal numbers (like currency) than [F32] and [F64]\nare, because [Dec] is represented in memory as base-10. In contrast, [F64] and [F32]\nare [base-2](https://en.wikipedia.org/wiki/Binary_number) in memory, which can lead to decimal\nprecision loss even when doing addition and subtraction. For example, when\nusing [F64], `0.1 + 0.2` returns 0.30000000000000004,\nwhereas when using [Dec], `0.1 + 0.2` returns 0.3.\n\nUnder the hood, a [Dec] is an [I128], and operations on it perform\n[base-10 fixed-point arithmetic](https://en.wikipedia.org/wiki/Fixed-point_arithmetic)\nwith 18 decimal places of precision.\n\nThis means a [Dec] can represent whole numbers up to slightly over 170\nquintillion, along with 18 decimal places. (To be precise, it can store\nnumbers between `-170_141_183_460_469_231_731.687303715884105728`\nand `170_141_183_460_469_231_731.687303715884105727`.) Why 18\ndecimal places? It's the highest number of decimal places where you can\nstill convert any [U64] to a [Dec] without losing information.\n\nThere are some use cases where [F64] and [F32] can be better choices than [Dec]\ndespite their issues with base-10 numbers. For example, in graphical applications\nthey can be a better choice for representing coordinates because they take up\nless memory, certain relevant calculations run faster (see performance\ndetails, below), and base-10 generally isn't as big a concern when\ndealing with screen coordinates as it is when dealing with currency.\n\nAnother scenario where [F64] can be a better choice than [Dec] is when representing\nextremely small numbers. The smallest positive [F64] that can be represented without precision\nloss is 2^(−1074), which is about 5 * 10^(-324). Here is that number next to the smallest\n[Dec] that can be represented:\n\n* Smallest [F64]: 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005\n* Smallest [Dec]: 0.000000000000000001\n\nThis is because [floating-point](https://en.wikipedia.org/wiki/Floating-point_arithmetic) numbers\nlike [F64] can gain more digits of precision after the `.` when they aren't using as many digits\nbefore the `.` - and this applies the most if the digit before `.` is `0`. So whereas [Dec] always\nhas 18 digits after the `.`, the number of digits after the `.` that [F32] can [F64] can represent\nwithout precision loss depends on what comes before it.\n\n## Performance Details\n\nCPUs have dedicated instructions for many [F32] and [F64] operations, but none for [Dec].\nInternally, [Dec] is represented as a 128-bit integer and uses multiple instructions to\nperform fractional operations. This gives [F32] and [F64] performance advantages\nfor many operations.\n\nHere's a comparison of about how long [Dec] takes to perform a given operation compared to [F64],\nbased on benchmarks on an [M1](https://en.wikipedia.org/wiki/Apple_M1) CPU:\n* [add] 0.6x\n* [sub] 0.6x\n* [mul] 15x\n* [div] 55x\n* [sin] 3.9x\n* [cos] 3.6x\n* [tan] 2.3x\n* [asin] 1.8x\n* [acos] 1.7x\n* [atan] 1.7x\n\nKeep in mind that arithmetic instructions are basically [the fastest thing a CPU does](http://norvig.com/21-days.html#answers),\nso (for example) a network request that takes 10 milliseconds to complete would go on this\nlist as about 10000000x. So these performance differences might be more or less noticeable than\nthe base-10 representation differences depending on the use case.\n",
)
docs>>
<<docs:
Some(
"Euler's number (e)\n",
)
docs>>
<<docs:
Some(
"Archimedes' constant (π)\n",
)
docs>>
<<docs:
Some(
"Circle constant (τ)\n",
)
docs>>
<<docs:
Some(
"Convert a number to a [Str].\n\n```\nNum.toStr 42\n```\nOnly [Frac] values will include a decimal point, and they will always include one.\n```\nNum.toStr 4.2\nNum.toStr 4.0\n```\nWhen this function is given a non-[finite](Num.isFinite)\n[F64] or [F32] value, the returned string will be `\"NaN\"`, `\"∞\"`, or `\"-∞\"`.\n\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns `Bool.true` if the first number is less than the second.\n\n`a < b` is shorthand for `Num.isLt a b`.\n\nIf either argument is [*NaN*](Num.isNaN), returns `Bool.false` no matter what. (*NaN*\nis [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).)\n```\n5\n |> Num.isLt 6\n```\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` if the first number is greater than the second.\n\n`a > b` is shorthand for `Num.isGt a b`.\n\nIf either argument is [*NaN*](Num.isNaN), returns `Bool.false` no matter what. (*NaN*\nis [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).)\n```\n6\n |> Num.isGt 5\n```\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` if the first number is less than or equal to the second.\n\n`a <= b` is shorthand for `Num.isLte a b`.\n\nIf either argument is [*NaN*](Num.isNaN), returns `Bool.false` no matter what. (*NaN*\nis [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).)\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` if the first number is greater than or equal to the second.\n\n`a >= b` is shorthand for `Num.isGte a b`.\n\nIf either argument is [*NaN*](Num.isNaN), returns `Bool.false` no matter what. (*NaN*\nis [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).)\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` if the first number and second number are within a specific threshold\n\nA specific relative and absolute tolerance can be provided to change the threshold\n\nThis function is symmetric: `Num.isApproxEq a b == Num.isApproxEq b a`\n\nIf either argument is [*NaN*](Num.isNaN), returns `Bool.false` no matter what. (*NaN*\nis [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).)\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` if the number is `0`, and `Bool.false` otherwise.\n",
)
docs>>
<<docs:
Some(
"A number is even if dividing it by 2 gives a remainder of 0.\n\nExamples of even numbers: 0, 2, 4, 6, 8, -2, -4, -6, -8\n",
)
docs>>
<<docs:
Some(
"A number is odd if dividing it by 2 gives a remainder of 1.\n\nExamples of odd numbers: 1, 3, 5, 7, -1, -3, -5, -7\n",
)
docs>>
<<docs:
Some(
"Positive numbers are greater than `0`.\n",
)
docs>>
<<docs:
Some(
"Negative numbers are less than `0`.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns `Bool.true` if the [Frac] is not a number as defined by [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)\n\n```\nNum.isNaN (0 / 0)\n```\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` if the [Frac] is positive or negative infinity as defined by [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)\n\n```\nNum.isInfinite (1 / 0)\n\nNum.isInfinite (-1 / 0)\n```\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` if the [Frac] is not an infinity as defined by [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)\n\n```\nNum.isFinite 42\n```\n",
)
docs>>
<<docs:
Some(
"Returns the absolute value of the number.\n\n* For a positive number, returns the same number.\n* For a negative number, returns the same number except positive.\n* For zero, returns zero.\n```\nNum.abs 4\n\nNum.abs -2.5\n\nNum.abs 0\n\nNum.abs 0.0\n```\nThis is safe to use with any [Frac], but it can cause overflow when used with certain [Int] values.\n\nFor example, calling #Num.abs on the lowest value of a signed integer (such as [Num.minI64] or [Num.minI32]) will cause overflow.\nThis is because, for any given size of signed integer (32-bit, 64-bit, etc.) its negated lowest value turns out to be 1 higher than\nthe highest value it can represent. (For this reason, calling [Num.neg] on the lowest signed value will also cause overflow.)\n\nCalling this on an unsigned integer (like [U32] or [U64]) never does anything.\n",
)
docs>>
<<docs:
Some(
"Returns the absolute difference between two numbers.\n\n```\nNum.absDiff 5 3\n\nNum.absDiff -3 5\n\nNum.absDiff 3.0 5.0\n```\n\nIf the answer to this operation can't fit in the return value (e.g. an\n[I8] answer that's higher than 127 or lower than -128), the result is an\n*overflow*. For [F64] and [F32], overflow results in an answer of either\n∞ or -∞. For all other number types, overflow results in a panic.\n",
)
docs>>
<<docs:
Some(
"Returns a negative number when given a positive one, and vice versa.\n```\nNum.neg 5\n\nNum.neg -2.5\n\nNum.neg 0\n\nNum.neg 0.0\n```\nThis is safe to use with any [Frac], but it can cause overflow when used with certain [Int] values.\n\nFor example, calling #Num.neg on the lowest value of a signed integer (such as [Num.minI64] or [Num.minI32]) will cause overflow.\nThis is because, for any given size of signed integer (32-bit, 64-bit, etc.) its negated lowest value turns out to be 1 higher than\nthe highest value it can represent. (For this reason, calling #Num.abs on the lowest signed value will also cause overflow.)\n\nAdditionally, calling #Num.neg on any unsigned integer (such as any [U64] or [U32] value) other than zero will cause overflow.\n\n(It will never crash when given a [Frac], however, because of how floating point numbers represent positive and negative numbers.)\n",
)
docs>>
<<docs:
Some(
"Adds two numbers of the same type.\n\n(To add an [Int] and a [Frac], first convert one so that they both have the same type. There are functions in this module that can convert both [Int] to [Frac] and the other way around.)\n\n`a + b` is shorthand for `Num.add a b`.\n```\n5 + 7\n\nNum.add 5 7\n```\n`Num.add` can be convenient in pipelines.\n```\nFrac.pi\n |> Num.add 1.0\n```\nIf the answer to this operation can't fit in the return value (e.g. an\n[I8] answer that's higher than 127 or lower than -128), the result is an\n*overflow*. For [F64] and [F32], overflow results in an answer of either\n∞ or -∞. For all other number types, overflow results in a panic.\n",
)
docs>>
<<docs:
Some(
"Subtracts two numbers of the same type.\n\n(To subtract an [Int] and a [Frac], first convert one so that they both have the same type. There are functions in this module that can convert both [Int] to [Frac] and the other way around.)\n\n`a - b` is shorthand for `Num.sub a b`.\n```\n7 - 5\n\nNum.sub 7 5\n```\n`Num.sub` can be convenient in pipelines.\n```\nFrac.pi\n |> Num.sub 2.0\n```\nIf the answer to this operation can't fit in the return value (e.g. an\n[I8] answer that's higher than 127 or lower than -128), the result is an\n*overflow*. For [F64] and [F32], overflow results in an answer of either\n∞ or -∞. For all other number types, overflow results in a panic.\n",
)
docs>>
<<docs:
Some(
"Multiplies two numbers of the same type.\n\n(To multiply an [Int] and a [Frac], first convert one so that they both have the same type. There are functions in this module that can convert both [Int] to [Frac] and the other way around.)\n\n`a * b` is shorthand for `Num.mul a b`.\n```\n5 * 7\n\nNum.mul 5 7\n```\n\n`Num.mul` can be convenient in pipelines.\n\n```\nFrac.pi\n |> Num.mul 2.0\n```\nIf the answer to this operation can't fit in the return value (e.g. an\n[I8] answer that's higher than 127 or lower than -128), the result is an\n*overflow*. For [F64] and [F32], overflow results in an answer of either\n∞ or -∞. For all other number types, overflow results in a panic.\n",
)
docs>>
<<docs:
Some(
"Obtains the smaller between two numbers of the same type.\n\n```\nNum.min 100 0\n\nNum.min 3.0 -3.0\n```\n",
)
docs>>
<<docs:
Some(
"Obtains the greater between two numbers of the same type.\n\n```\nNum.max 100 0\n\nNum.max 3.0 -3.0\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns an approximation of the absolute value of a [Frac]'s square root.\n\nThe square root of a negative number is an irrational number, and [Frac] only\nsupports rational numbers. As such, you should make sure never to pass this\nfunction a negative number! Calling [sqrt] on a negative [Dec] will cause a panic.\n\nCalling [sqrt] on [F32] and [F64] values follows these rules:\n* Passing a negative [F64] or [F32] returns [*NaN*](Num.isNaN).\n* Passing [*NaN*](Num.isNaN) or -∞ also returns [*NaN*](Num.isNaN).\n* Passing ∞ returns ∞.\n\n> These rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)\n> floating point standard. Because almost all modern processors are built to\n> this standard, deviating from these rules has a significant performance\n> cost! Since the most common reason to choose [F64] or [F32] over [Dec] is\n> access to hardware-accelerated performance, Roc follows these rules exactly.\n```\nNum.sqrt 4.0\n\nNum.sqrt 1.5\n\nNum.sqrt 0.0\n\nNum.sqrt -4.0f64\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Natural logarithm\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Divides one [Frac] by another.\n\n`a / b` is shorthand for `Num.div a b`.\n\n[Division by zero is undefined in mathematics](https://en.wikipedia.org/wiki/Division_by_zero).\nAs such, you should make sure never to pass zero as the denominator to this function!\nCalling [div] on a [Dec] denominator of zero will cause a panic.\n\nCalling [div] on [F32] and [F64] values follows these rules:\n* Dividing a positive [F64] or [F32] by zero returns ∞.\n* Dividing a negative [F64] or [F32] by zero returns -∞.\n* Dividing a zero [F64] or [F32] by zero returns [*NaN*](Num.isNaN).\n\n> These rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)\n> floating point standard. Because almost all modern processors are built to\n> this standard, deviating from these rules has a significant performance\n> cost! Since the most common reason to choose [F64] or [F32] over [Dec] is\n> access to hardware-accelerated performance, Roc follows these rules exactly.\n\nTo divide an [Int] and a [Frac], first convert the [Int] to a [Frac] using\none of the functions in this module like #toDec.\n```\n5.0 / 7.0\n\nNum.div 5 7\n```\n`Num.div` can be convenient in pipelines.\n```\nNum.pi\n |> Num.div 2.0\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Divides two integers, truncating the result towards zero.\n\n`a // b` is shorthand for `Num.divTrunc a b`.\n\nDivision by zero is undefined in mathematics. As such, you should make\nsure never to pass zero as the denominator to this function! If you do,\nit will crash.\n```\n5 // 7\n\nNum.divTrunc 5 7\n\n8 // -3\n\nNum.divTrunc 8 -3\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"traps (hardware fault) when given zero as the second argument.\n",
)
docs>>
<<docs:
Some(
"Obtains the remainder (truncating modulo) from the division of two integers.\n\n`a % b` is shorthand for `Num.rem a b`.\n```\n5 % 7\n\nNum.rem 5 7\n\n-8 % -3\n\nNum.rem -8 -3\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"traps (hardware fault) when given zero as the second argument.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Does a \"bitwise and\". Each bit of the output is 1 if the corresponding bit\nof x AND of y is 1, otherwise it's 0.\n",
)
docs>>
<<docs:
Some(
"Does a \"bitwise exclusive or\". Each bit of the output is the same as the\ncorresponding bit in x if that bit in y is 0, and it's the complement of\nthe bit in x if that bit in y is 1.\n",
)
docs>>
<<docs:
Some(
"Does a \"bitwise or\". Each bit of the output is 0 if the corresponding bit\nof x OR of y is 0, otherwise it's 1.\n",
)
docs>>
<<docs:
Some(
"Returns the complement of x - the number you get by switching each 1 for a\n0 and each 0 for a 1. This is the same as -x - 1.\n",
)
docs>>
<<docs:
Some(
"Bitwise left shift of a number by another\n\nThe least significant bits always become 0. This means that shifting left is\nlike multiplying by factors of two for unsigned integers.\n```\nshiftLeftBy 0b0000_0011 2 == 0b0000_1100\n\n0b0000_0101 |> shiftLeftBy 2 == 0b0000_1100\n```\nIn some languages `shiftLeftBy` is implemented as a binary operator `<<`.\n",
)
docs>>
<<docs:
Some(
"Bitwise arithmetic shift of a number by another\n\nThe most significant bits are copied from the current.\n```\nshiftRightBy 0b0000_1100 2 == 0b0000_0011\n\n0b0001_0100 |> shiftRightBy 2 == 0b0000_0101\n\n0b1001_0000 |> shiftRightBy 2 == 0b1110_0100\n```\nIn some languages `shiftRightBy` is implemented as a binary operator `>>>`.\n",
)
docs>>
<<docs:
Some(
"Bitwise logical right shift of a number by another\n\nThe most significant bits always become 0. This means that shifting right is\nlike dividing by factors of two for unsigned integers.\n```\nshiftRightZfBy 0b0010_1000 2 == 0b0000_1010\n\n0b0010_1000 |> shiftRightZfBy 2 == 0b0000_1010\n\n0b1001_0000 |> shiftRightZfBy 2 == 0b0010_0100\n```\nIn some languages `shiftRightZfBy` is implemented as a binary operator `>>`.\n",
)
docs>>
<<docs:
Some(
"Round off the given fraction to the nearest integer.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Raises a [Frac] to the power of another [Frac].\n\nFor an [Int] alternative to this function, see [Num.powInt]\n",
)
docs>>
<<docs:
Some(
"Raises an integer to the power of another, by multiplying the integer by\nitself the given number of times.\n\nThis process is known as [exponentiation by squaring](https://en.wikipedia.org/wiki/Exponentiation_by_squaring).\n\nFor a [Frac] alternative to this function, which supports negative exponents,\nsee #Num.pow.\n\n## Warning\n\nIt is very easy for this function to produce an answer\nso large it causes an overflow.\n",
)
docs>>
<<docs:
Some(
"Counts the number of most-significant (leading in a big-Endian sense) zeroes in an integer.\n\n```\nNum.countLeadingZeroBits 0b0001_1100u8\n\n3\n\nNum.countLeadingZeroBits 0b0000_0000u8\n\n8\n```\n",
)
docs>>
<<docs:
Some(
"Counts the number of least-significant (trailing in a big-Endian sense) zeroes in an integer.\n\n```\nNum.countTrailingZeroBits 0b0001_1100u8\n\n2\n\nNum.countTrailingZeroBits 0b0000_0000u8\n\n8\n```\n",
)
docs>>
<<docs:
Some(
"Counts the number of set bits in an integer.\n\n```\nNum.countOneBits 0b0001_1100u8\n\n3\n\nNum.countOneBits 0b0000_0000u8\n\n0\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Adds two numbers, clamping on the maximum representable number rather than\noverflowing.\n\nThis is the same as [Num.add] except for the saturating behavior if the\naddition is to overflow.\nFor example, if `x : U8` is 200 and `y : U8` is 100, `addSaturated x y` will\nyield 255, the maximum value of a `U8`.\n",
)
docs>>
<<docs:
Some(
"Adds two numbers and checks for overflow.\n\nThis is the same as [Num.add] except if the operation overflows, instead of\npanicking or returning ∞ or -∞, it will return `Err Overflow`.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Subtracts two numbers, clamping on the minimum representable number rather\nthan overflowing.\n\nThis is the same as [Num.sub] except for the saturating behavior if the\nsubtraction is to overflow.\nFor example, if `x : U8` is 10 and `y : U8` is 20, `subSaturated x y` will\nyield 0, the minimum value of a `U8`.\n",
)
docs>>
<<docs:
Some(
"Subtracts two numbers and checks for overflow.\n\nThis is the same as [Num.sub] except if the operation overflows, instead of\npanicking or returning ∞ or -∞, it will return `Err Overflow`.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Multiplies two numbers, clamping on the maximum representable number rather than\noverflowing.\n\nThis is the same as [Num.mul] except for the saturating behavior if the\naddition is to overflow.\n",
)
docs>>
<<docs:
Some(
"Multiplies two numbers and checks for overflow.\n\nThis is the same as [Num.mul] except if the operation overflows, instead of\npanicking or returning ∞ or -∞, it will return `Err Overflow`.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns the lowest number that can be stored in an [I8] without underflowing\nits available memory and crashing.\n\nFor reference, this number is `-128`.\n\nNote that the positive version of this number is larger than [Num.maxI8],\nwhich means if you call [Num.abs] on [Num.minI8], it will overflow and crash!\n",
)
docs>>
<<docs:
Some(
"Returns the highest number that can be stored in an [I8] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `127`.\n\nNote that this is smaller than the positive version of [Num.minI8],\nwhich means if you call [Num.abs] on [Num.minI8], it will overflow and crash!\n",
)
docs>>
<<docs:
Some(
"Returns the lowest number that can be stored in a [U8] without underflowing\nits available memory and crashing.\n\nFor reference, this number is zero, because [U8] is\n[unsigned](https://en.wikipedia.org/wiki/Signed_number_representations),\nand zero is the lowest unsigned number.\nUnsigned numbers cannot be negative.\n",
)
docs>>
<<docs:
Some(
"Returns the highest number that can be stored in a [U8] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `255`.\n",
)
docs>>
<<docs:
Some(
"Returns the lowest number that can be stored in an [I16] without underflowing\nits available memory and crashing.\n\nFor reference, this number is `-32_768`.\n\nNote that the positive version of this number is larger than [Num.maxI16],\nwhich means if you call [Num.abs] on [Num.minI16], it will overflow and crash!\n",
)
docs>>
<<docs:
Some(
"Returns the highest number that can be stored in an [I16] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `32_767`.\n\nNote that this is smaller than the positive version of [Num.minI16],\nwhich means if you call [Num.abs] on [Num.minI16], it will overflow and crash!\n",
)
docs>>
<<docs:
Some(
"Returns the lowest number that can be stored in a [U16] without underflowing\nits available memory and crashing.\n\nFor reference, this number is zero, because [U16] is\n[unsigned](https://en.wikipedia.org/wiki/Signed_number_representations),\nand zero is the lowest unsigned number.\nUnsigned numbers cannot be negative.\n",
)
docs>>
<<docs:
Some(
"Returns the highest number that can be stored in a [U16] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `65_535`.\n",
)
docs>>
<<docs:
Some(
"Returns the lowest number that can be stored in an [I32] without underflowing\nits available memory and crashing.\n\nFor reference, this number is `-2_147_483_648`.\n\nNote that the positive version of this number is larger than [Num.maxI32],\nwhich means if you call [Num.abs] on [Num.minI32], it will overflow and crash!\n",
)
docs>>
<<docs:
Some(
"Returns the highest number that can be stored in an [I32] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `2_147_483_647`,\nwhich is over 2 million.\n\nNote that this is smaller than the positive version of [Num.minI32],\nwhich means if you call [Num.abs] on [Num.minI32], it will overflow and crash!\n",
)
docs>>
<<docs:
Some(
"Returns the lowest number that can be stored in a [U32] without underflowing\nits available memory and crashing.\n\nFor reference, this number is zero, because [U32] is\n[unsigned](https://en.wikipedia.org/wiki/Signed_number_representations),\nand zero is the lowest unsigned number.\nUnsigned numbers cannot be negative.\n",
)
docs>>
<<docs:
Some(
"Returns the highest number that can be stored in a [U32] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `4_294_967_295`.\n",
)
docs>>
<<docs:
Some(
"Returns the lowest number that can be stored in an [I64] without underflowing\nits available memory and crashing.\n\nFor reference, this number is `-9_223_372_036_854_775_808`,\nwhich is under 9 quintillion.\n\nNote that the positive version of this number is larger than [Num.maxI64],\nwhich means if you call [Num.abs] on [Num.minI64], it will overflow and crash!\n",
)
docs>>
<<docs:
Some(
"Returns the highest number that can be stored in an [I64] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `9_223_372_036_854_775_807`,\nwhich is over 9 quintillion.\n\nNote that this is smaller than the positive version of [Num.minI64],\nwhich means if you call [Num.abs] on [Num.minI64], it will overflow and crash!\n",
)
docs>>
<<docs:
Some(
"Returns the lowest number that can be stored in a [U64] without underflowing\nits available memory and crashing.\n\nFor reference, this number is zero, because [U64] is\n[unsigned](https://en.wikipedia.org/wiki/Signed_number_representations),\nand zero is the lowest unsigned number.\nUnsigned numbers cannot be negative.\n",
)
docs>>
<<docs:
Some(
"Returns the highest number that can be stored in a [U64] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `18_446_744_073_709_551_615`,\nwhich is over 18 quintillion.\n",
)
docs>>
<<docs:
Some(
"Returns the lowest number that can be stored in an [I128] without underflowing\nits available memory and crashing.\n\nFor reference, this number is `-170_141_183_460_469_231_731_687_303_715_884_105_728`.\nwhich is under 170 undecillion.\n\nNote that the positive version of this number is larger than [Num.maxI128],\nwhich means if you call [Num.abs] on [Num.minI128], it will overflow and crash!\n",
)
docs>>
<<docs:
Some(
"Returns the highest number that can be stored in an [I128] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `170_141_183_460_469_231_731_687_303_715_884_105_727`,\nwhich is over 170 undecillion.\n\nNote that this is smaller than the positive version of [Num.minI128],\nwhich means if you call [Num.abs] on [Num.minI128], it will overflow and crash!\n",
)
docs>>
<<docs:
Some(
"Returns the lowest number that can be stored in a [U128] without underflowing\nits available memory and crashing.\n\nFor reference, this number is zero, because [U128] is\n[unsigned](https://en.wikipedia.org/wiki/Signed_number_representations),\nand zero is the lowest unsigned number.\nUnsigned numbers cannot be negative.\n",
)
docs>>
<<docs:
Some(
"Returns the highest number that can be stored in a [U128] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `340_282_366_920_938_463_463_374_607_431_768_211_455`,\nwhich is over 340 undecillion.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Converts an [Int] to an [I8]. If the given number can't be precisely represented in an [I8],\nthe returned number may be different from the given number.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Converts a [Num] to an [F32]. If the given number can't be precisely represented in an [F32],\nthe returned number may be different from the given number.\n",
)
docs>>
<<docs:
Some(
"Converts a [Num] to an [F64]. If the given number can't be precisely represented in an [F64],\nthe returned number may be different from the given number.\n",
)
docs>>
<<docs:
Some(
"Converts a [Int] to an [I8].\nIf the given integer can't be precisely represented in an [I8], returns\n`Err OutOfBounds`.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
adding docs for "Num.roc",
docs ModuleDocumentation {
name: "Num",
entries: [
DocDef(
DocDef {
name: "Num",
symbol: `Num.Num`,
type_vars: [
"range",
],
type_annotation: NoTypeAnn,
docs: Some(
"Represents a number that could be either an [Int] or a [Frac].\n\nThis is useful for functions that can work on either, for example [Num.add], whose type is:\n```\nadd : Num a, Num a -> Num a\n```\nThe number 1.5 technically has the type `Num (Fraction *)`, so when you pass\ntwo of them to [Num.add], the answer you get is `3.0 : Num (Fraction *)`.\n\nSimilarly, the number 0x1 (that is, the integer 1 in hexadecimal notation)\ntechnically has the type `Num (Integer *)`, so when you pass two of them to\n[Num.add], the answer you get is `2 : Num (Integer *)`.\n\nThe type [`Frac a`](#Frac) is defined to be an alias for `Num (Fraction a)`,\nso `3.0 : Num (Fraction *)` is the same value as `3.0 : Frac *`.\nSimilarly, the type [`Int a`](#Int) is defined to be an alias for\n`Num (Integer a)`, so `2 : Num (Integer *)` is the same value as\n`2 : Int *`.\n\nIn this way, the [Num] type makes it possible to have `1 + 0x1` return\n`2 : Int *` and `1.5 + 1.5` return `3.0 : Frac`.\n\n## Number Literals\n\nNumber literals without decimal points (like `0`, `4` or `360`)\nhave the type `Num *` at first, but usually end up taking on\na more specific type based on how they're used.\n\nFor example, in `(1 + List.len myList)`, the `1` has the type `Num *` at first,\nbut because `List.len` returns a `U64`, the `1` ends up changing from\n`Num *` to the more specific `U64`, and the expression as a whole\nends up having the type `U64`.\n\nSometimes number literals don't become more specific. For example,\nthe `Num.toStr` function has the type `Num * -> Str`. This means that\nwhen calling `Num.toStr (5 + 6)`, the expression `(5 + 6)`\nstill has the type `Num *`. When this happens, `Num *` defaults to\nbeing an [I64] - so this addition expression would overflow\nif either 5 or 6 were replaced with a number big enough to cause\naddition overflow on an [I64] value.\n\nIf this default of [I64] is not big enough for your purposes,\nyou can add an `i128` to the end of the number literal, like so:\n```\nNum.toStr 5_000_000_000i128\n```\nThis `i128` suffix specifies that you want this number literal to be\nan [I128] instead of a `Num *`. All the other numeric types have\nsuffixes just like `i128`; here are some other examples:\n\n* `215u8` is a `215` value of type [U8]\n* `76.4f32` is a `76.4` value of type [F32]\n* `123.45dec` is a `123.45` value of type [Dec]\n\nIn practice, these are rarely needed. It's most common to write\nnumber literals without any suffix.\n",
),
},
),
DocDef(
DocDef {
name: "Int",
symbol: `Num.Int`,
type_vars: [
"range",
],
type_annotation: NoTypeAnn,
docs: Some(
"A fixed-size integer - that is, a number with no fractional component.\n\nIntegers come in two flavors: signed and unsigned. Signed integers can be\nnegative (\"signed\" refers to how they can incorporate a minus sign),\nwhereas unsigned integers cannot be negative.\n\nSince integers have a fixed size, the size you choose determines both the\nrange of numbers it can represent, and also how much memory it takes up.\n\n[U8] is an an example of an integer. It is an unsigned [Int] that takes up 8 bits\n(aka 1 byte) in memory. The `U` is for Unsigned and the 8 is for 8 bits.\nBecause it has 8 bits to work with, it can store 256 numbers (2^8),\nand because it is unsigned, its min value is 0. This means the 256 numbers\nit can store range from 0 to 255.\n\n[I8] is a signed integer that takes up 8 bits. The `I` is for Integer, since\nintegers in mathematics are signed by default. Because it has 8 bits just\nlike [U8], it can store 256 numbers (still 2^8), but because it is signed,\nthe range is different. Its 256 numbers range from -128 to 127.\n\nHere are some other examples:\n\n* [U16] is like [U8], except it takes up 16 bits in memory. It can store 65,536 numbers (2^16), ranging from 0 to 65,536.\n* [I16] is like [U16], except it is signed. It can still store the same 65,536 numbers (2^16), ranging from -32,768 to 32,767.\n\nThis pattern continues up to [U128] and [I128].\n\n## Performance Details\n\nIn general, using smaller numeric sizes means your program will use less memory.\nHowever, if a mathematical operation results in an answer that is too big\nor too small to fit in the size available for that answer (which is typically\nthe same size as the inputs), then you'll get an overflow error.\n\nAs such, minimizing memory usage without causing overflows involves choosing\nnumber sizes based on your knowledge of what numbers you expect your program\nto encounter at runtime.\n\nMinimizing memory usage does not imply maximum runtime speed!\nCPUs are typically fastest at performing integer operations on integers that\nare the same size as that CPU's native machine word size. That means a 64-bit\nCPU is typically fastest at executing instructions on [U64] and [I64] values,\nwhereas a 32-bit CPU is typically fastest on [U32] and [I32] values.\n\nPutting these factors together, here are some reasonable guidelines for optimizing performance through integer size choice:\n\n* Start by deciding if this integer should allow negative numbers, and choose signed or unsigned accordingly.\n* Next, think about the range of numbers you expect this number to hold. Choose the smallest size you will never expect to overflow, no matter the inputs your program receives. (Validating inputs for size, and presenting the user with an error if they are too big, can help guard against overflow.)\n* Finally, if a particular numeric calculation is running too slowly, you can try experimenting with other number sizes. This rarely makes a meaningful difference, but some processors can operate on different number sizes at different speeds.\n\nAll number literals without decimal points are compatible with [Int] values.\n\nYou can optionally put underscores in your [Int] literals.\nThey have no effect on the number's value, but can make large numbers easier to read.\n```\n1_000_000\n```\nIntegers come in two flavors: *signed* and *unsigned*.\n\n* *Unsigned* integers can never be negative. The lowest value they can hold is zero.\n* *Signed* integers can be negative.\n\nIntegers also come in different sizes. Choosing a size depends on your performance\nneeds and the range of numbers you need to represent. At a high level, the\ngeneral trade-offs are:\n\n* Larger integer sizes can represent a wider range of numbers. If you absolutely need to represent numbers in a certain range, make sure to pick an integer size that can hold them!\n* Smaller integer sizes take up less memory. These savings rarely matter in variables and function arguments, but the sizes of integers that you use in data structures can add up. This can also affect whether those data structures fit in [cache lines](https://en.wikipedia.org/wiki/CPU_cache#Cache_performance), which can be a performance bottleneck.\n* Certain CPUs work faster on some numeric sizes than others. If the CPU is taking too long to run numeric calculations, you may find a performance improvement by experimenting with numeric sizes that are larger than otherwise necessary. However, in practice, doing this typically degrades overall performance, so be careful to measure properly!\n\nHere are the different fixed size integer types:\n\n| Range | Type | Size |\n|--------------------------------------------------------|-------|----------|\n| ` -128` | [I8] | 1 Byte |\n| ` 127` | | |\n|--------------------------------------------------------|-------|----------|\n| ` 0` | [U8] | 1 Byte |\n| ` 255` | | |\n|--------------------------------------------------------|-------|----------|\n| ` -32_768` | [I16] | 2 Bytes |\n| ` 32_767` | | |\n|--------------------------------------------------------|-------|----------|\n| ` 0` | [U16] | 2 Bytes |\n| ` 65_535` | | |\n|--------------------------------------------------------|-------|----------|\n| ` -2_147_483_648` | [I32] | 4 Bytes |\n| ` 2_147_483_647` | | |\n|--------------------------------------------------------|-------|----------|\n| ` 0` | [U32] | 4 Bytes |\n| ` (over 4 billion) 4_294_967_295` | | |\n|--------------------------------------------------------|-------|----------|\n| ` -9_223_372_036_854_775_808` | [I64] | 8 Bytes |\n| ` 9_223_372_036_854_775_807` | | |\n|--------------------------------------------------------|-------|----------|\n| ` 0` | [U64] | 8 Bytes |\n| ` (over 18 quintillion) 18_446_744_073_709_551_615` | | |\n|--------------------------------------------------------|-------|----------|\n| `-170_141_183_460_469_231_731_687_303_715_884_105_728` | [I128]| 16 Bytes |\n| ` 170_141_183_460_469_231_731_687_303_715_884_105_727` | | |\n|--------------------------------------------------------|-------|----------|\n| ` (over 340 undecillion) 0` | [U128]| 16 Bytes |\n| ` 340_282_366_920_938_463_463_374_607_431_768_211_455` | | |\n\nIf any operation would result in an [Int] that is either too big\nor too small to fit in that range (e.g. calling `Num.maxI32 + 1`),\nthen the operation will *overflow*. When an overflow occurs, the program will crash.\n\nAs such, it's very important to design your code not to exceed these bounds!\nIf you need to do math outside these bounds, consider using a larger numeric size.\n",
),
},
),
DocDef(
DocDef {
name: "Frac",
symbol: `Num.Frac`,
type_vars: [
"range",
],
type_annotation: NoTypeAnn,
docs: Some(
"A fixed-size number with a fractional component.\n\nRoc fractions come in two flavors: fixed-point base-10 and floating-point base-2.\n\n* [Dec] is a 128-bit [fixed-point](https://en.wikipedia.org/wiki/Fixed-point_arithmetic) base-10 number. It's a great default choice, especially when precision is important - for example when representing currency. With [Dec], `0.1 + 0.2` returns `0.3`. [Dec] has 18 decimal places of precision and a range from `-170_141_183_460_469_231_731.687303715884105728` to `170_141_183_460_469_231_731.687303715884105727`.\n* [F64] and [F32] are [floating-point](https://en.wikipedia.org/wiki/Floating-point_arithmetic) base-2 numbers. They sacrifice precision for lower memory usage and improved performance on some operations. This makes them a good fit for representing graphical coordinates. With [F64], `0.1 + 0.2` returns `0.30000000000000004`.\n\nIf you don't specify a type, Roc will default to using [Dec] because it's\nthe least error-prone overall. For example, suppose you write this:\n```\nwasItPrecise = 0.1 + 0.2 == 0.3\n```\nThe value of `wasItPrecise` here will be `Bool.true`, because Roc uses [Dec]\nby default when there are no types specified.\n\nIn contrast, suppose we use `f32` or `f64` for one of these numbers:\n```\nwasItPrecise = 0.1f64 + 0.2 == 0.3\n```\nHere, `wasItPrecise` will be `Bool.false` because the entire calculation will have\nbeen done in a base-2 floating point calculation, which causes noticeable\nprecision loss in this case.\n\nThe floating-point numbers ([F32] and [F64]) also have three values which\nare not ordinary [finite numbers](https://en.wikipedia.org/wiki/Finite_number).\nThey are:\n* ∞ ([infinity](https://en.wikipedia.org/wiki/Infinity))\n* -∞ (negative infinity)\n* *NaN* ([not a number](https://en.wikipedia.org/wiki/NaN))\n\nThese values are different from ordinary numbers in that they only occur\nwhen a floating-point calculation encounters an error. For example:\n* Dividing a positive [F64] by `0.0` returns ∞.\n* Dividing a negative [F64] by `0.0` returns -∞.\n* Dividing a [F64] of `0.0` by `0.0` returns [*NaN*](Num.isNaN).\n\nThese rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)\nfloating point standard. Because almost all modern processors are built to\nthis standard, deviating from these rules has a significant performance\ncost! Since the most common reason to choose [F64] or [F32] over [Dec] is\naccess to hardware-accelerated performance, Roc follows these rules exactly.\n\nThere's no literal syntax for these error values, but you can check to see if\nyou ended up with one of them by using #isNaN, #isFinite, and #isInfinite.\nWhenever a function in this module could return one of these values, that\npossibility is noted in the function's documentation.\n\n## Performance Details\n\nOn typical modern CPUs, performance is similar between [Dec], [F64], and [F32]\nfor addition and subtraction. For example, [F32] and [F64] do addition using\na single CPU floating-point addition instruction, which typically takes a\nfew clock cycles to complete. In contrast, [Dec] does addition using a few\nCPU integer arithmetic instructions, each of which typically takes only one\nclock cycle to complete. Exact numbers will vary by CPU, but they should be\nsimilar overall.\n\n[Dec] is significantly slower for multiplication and division. It not only\nneeds to do more arithmetic instructions than [F32] and [F64] do, but also\nthose instructions typically take more clock cycles to complete.\n\nWith [Num.sqrt] and trigonometry functions like [Num.cos], there is\nan even bigger performance difference. [F32] and [F64] can do these in a\nsingle instruction, whereas [Dec] needs entire custom procedures - which use\nloops and conditionals. If you need to do performance-critical trigonometry\nor square roots, either [F64] or [F32] is probably a better choice than the\nusual default choice of [Dec], despite the precision problems they bring.\n",
),
},
),
DocDef(
DocDef {
name: "Signed128",
symbol: `Num.Signed128`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Signed64",
symbol: `Num.Signed64`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Signed32",
symbol: `Num.Signed32`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Signed16",
symbol: `Num.Signed16`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Signed8",
symbol: `Num.Signed8`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Unsigned128",
symbol: `Num.Unsigned128`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Unsigned64",
symbol: `Num.Unsigned64`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Unsigned32",
symbol: `Num.Unsigned32`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Unsigned16",
symbol: `Num.Unsigned16`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Unsigned8",
symbol: `Num.Unsigned8`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Integer",
symbol: `Num.Integer`,
type_vars: [
"range",
],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "I128",
symbol: `Num.I128`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "I64",
symbol: `Num.I64`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "I32",
symbol: `Num.I32`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "I16",
symbol: `Num.I16`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "I8",
symbol: `Num.I8`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: Some(
"A signed 8-bit integer, ranging from -128 to 127\n",
),
},
),
DocDef(
DocDef {
name: "U128",
symbol: `Num.U128`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "U64",
symbol: `Num.U64`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "U32",
symbol: `Num.U32`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "U16",
symbol: `Num.U16`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "U8",
symbol: `Num.U8`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Decimal",
symbol: `Num.Decimal`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Binary64",
symbol: `Num.Binary64`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Binary32",
symbol: `Num.Binary32`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "FloatingPoint",
symbol: `Num.FloatingPoint`,
type_vars: [
"range",
],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "F64",
symbol: `Num.F64`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: Some(
"A 64-bit [IEEE 754 binary floating-point number](https://en.wikipedia.org/wiki/IEEE_754).\n\n[F64] represents decimal numbers less precisely than [Dec] does, but operations on it\ncan be faster because CPUs have hardware-level support for [F64] but not [Dec]. There\nare other tradeoffs between the two, such as:\n* [Dec] has a fixed number of digits it can represent before the decimal point, and a fixed number it can represent after the decimal point. In contrast, [F64]'s decimal point can \"float\"—which conceptually means if you don't need many digits before the decimal point, you can get more digits of precision afterwards (and vice versa).\n* [Dec] represents its number internally in [base-10](https://en.wikipedia.org/wiki/Decimal), whereas [F64] uses [base-2](https://en.wikipedia.org/wiki/Binary_number). This can lead to imprecise answers like `0.1 + 0.2` returning `0.3` for [Dec] and `0.30000000000000004` for [F64]. This is not a bug; rather, it's a consequence of [F64]'s base-2 representation.\n* [Dec] always gives a precise answer (or an error), whereas [F64] can lose precision. For example, increasing a very large [F64] number (using addition, perhaps) can result in the whole number portion being incorrect. `1234567890123456789 + 100` correctly results in a number ending in `889` for `Dec`, but results in a number ending `800` in [F64] due to precision loss.\n",
),
},
),
DocDef(
DocDef {
name: "F32",
symbol: `Num.F32`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: Some(
"A 32-bit [IEEE 754 binary floating-point number](https://en.wikipedia.org/wiki/IEEE_754).\n\nThis works just like [F64] (see its docs for a comparison with [Dec]) except it's smaller.\nThat in turn means it takes up less memory, but can store smaller numbers (and becomes imprecise\nmore easily than [F64] does).\n",
),
},
),
DocDef(
DocDef {
name: "Dec",
symbol: `Num.Dec`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: Some(
"A [decimal](https://en.wikipedia.org/wiki/Decimal) number.\n\n[Dec] is a more precise way to represent decimal numbers (like currency) than [F32] and [F64]\nare, because [Dec] is represented in memory as base-10. In contrast, [F64] and [F32]\nare [base-2](https://en.wikipedia.org/wiki/Binary_number) in memory, which can lead to decimal\nprecision loss even when doing addition and subtraction. For example, when\nusing [F64], `0.1 + 0.2` returns 0.30000000000000004,\nwhereas when using [Dec], `0.1 + 0.2` returns 0.3.\n\nUnder the hood, a [Dec] is an [I128], and operations on it perform\n[base-10 fixed-point arithmetic](https://en.wikipedia.org/wiki/Fixed-point_arithmetic)\nwith 18 decimal places of precision.\n\nThis means a [Dec] can represent whole numbers up to slightly over 170\nquintillion, along with 18 decimal places. (To be precise, it can store\nnumbers between `-170_141_183_460_469_231_731.687303715884105728`\nand `170_141_183_460_469_231_731.687303715884105727`.) Why 18\ndecimal places? It's the highest number of decimal places where you can\nstill convert any [U64] to a [Dec] without losing information.\n\nThere are some use cases where [F64] and [F32] can be better choices than [Dec]\ndespite their issues with base-10 numbers. For example, in graphical applications\nthey can be a better choice for representing coordinates because they take up\nless memory, certain relevant calculations run faster (see performance\ndetails, below), and base-10 generally isn't as big a concern when\ndealing with screen coordinates as it is when dealing with currency.\n\nAnother scenario where [F64] can be a better choice than [Dec] is when representing\nextremely small numbers. The smallest positive [F64] that can be represented without precision\nloss is 2^(−1074), which is about 5 * 10^(-324). Here is that number next to the smallest\n[Dec] that can be represented:\n\n* Smallest [F64]: 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005\n* Smallest [Dec]: 0.000000000000000001\n\nThis is because [floating-point](https://en.wikipedia.org/wiki/Floating-point_arithmetic) numbers\nlike [F64] can gain more digits of precision after the `.` when they aren't using as many digits\nbefore the `.` - and this applies the most if the digit before `.` is `0`. So whereas [Dec] always\nhas 18 digits after the `.`, the number of digits after the `.` that [F32] can [F64] can represent\nwithout precision loss depends on what comes before it.\n\n## Performance Details\n\nCPUs have dedicated instructions for many [F32] and [F64] operations, but none for [Dec].\nInternally, [Dec] is represented as a 128-bit integer and uses multiple instructions to\nperform fractional operations. This gives [F32] and [F64] performance advantages\nfor many operations.\n\nHere's a comparison of about how long [Dec] takes to perform a given operation compared to [F64],\nbased on benchmarks on an [M1](https://en.wikipedia.org/wiki/Apple_M1) CPU:\n* [add] 0.6x\n* [sub] 0.6x\n* [mul] 15x\n* [div] 55x\n* [sin] 3.9x\n* [cos] 3.6x\n* [tan] 2.3x\n* [asin] 1.8x\n* [acos] 1.7x\n* [atan] 1.7x\n\nKeep in mind that arithmetic instructions are basically [the fastest thing a CPU does](http://norvig.com/21-days.html#answers),\nso (for example) a network request that takes 10 milliseconds to complete would go on this\nlist as about 10000000x. So these performance differences might be more or less noticeable than\nthe base-10 representation differences depending on the use case.\n",
),
},
),
DocDef(
DocDef {
name: "e",
symbol: `Num.e`,
type_vars: [],
type_annotation: Apply {
name: "Frac",
parts: [
Wildcard,
],
},
docs: Some(
"Euler's number (e)\n",
),
},
),
DocDef(
DocDef {
name: "pi",
symbol: `Num.pi`,
type_vars: [],
type_annotation: Apply {
name: "Frac",
parts: [
Wildcard,
],
},
docs: Some(
"Archimedes' constant (π)\n",
),
},
),
DocDef(
DocDef {
name: "tau",
symbol: `Num.tau`,
type_vars: [],
type_annotation: Apply {
name: "Frac",
parts: [
Wildcard,
],
},
docs: Some(
"Circle constant (τ)\n",
),
},
),
DocDef(
DocDef {
name: "toStr",
symbol: `Num.toStr`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Convert a number to a [Str].\n\n```\nNum.toStr 42\n```\nOnly [Frac] values will include a decimal point, and they will always include one.\n```\nNum.toStr 4.2\nNum.toStr 4.0\n```\nWhen this function is given a non-[finite](Num.isFinite)\n[F64] or [F32] value, the returned string will be `\"NaN\"`, `\"∞\"`, or `\"-∞\"`.\n\n",
),
},
),
DocDef(
DocDef {
name: "intCast",
symbol: `Num.intCast`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"b",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "compare",
symbol: `Num.compare`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: TagUnion {
tags: [
Tag {
name: "LT",
values: [],
},
Tag {
name: "EQ",
values: [],
},
Tag {
name: "GT",
values: [],
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "isLt",
symbol: `Num.isLt`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` if the first number is less than the second.\n\n`a < b` is shorthand for `Num.isLt a b`.\n\nIf either argument is [*NaN*](Num.isNaN), returns `Bool.false` no matter what. (*NaN*\nis [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).)\n```\n5\n |> Num.isLt 6\n```\n",
),
},
),
DocDef(
DocDef {
name: "isGt",
symbol: `Num.isGt`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` if the first number is greater than the second.\n\n`a > b` is shorthand for `Num.isGt a b`.\n\nIf either argument is [*NaN*](Num.isNaN), returns `Bool.false` no matter what. (*NaN*\nis [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).)\n```\n6\n |> Num.isGt 5\n```\n",
),
},
),
DocDef(
DocDef {
name: "isLte",
symbol: `Num.isLte`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` if the first number is less than or equal to the second.\n\n`a <= b` is shorthand for `Num.isLte a b`.\n\nIf either argument is [*NaN*](Num.isNaN), returns `Bool.false` no matter what. (*NaN*\nis [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).)\n",
),
},
),
DocDef(
DocDef {
name: "isGte",
symbol: `Num.isGte`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` if the first number is greater than or equal to the second.\n\n`a >= b` is shorthand for `Num.isGte a b`.\n\nIf either argument is [*NaN*](Num.isNaN), returns `Bool.false` no matter what. (*NaN*\nis [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).)\n",
),
},
),
DocDef(
DocDef {
name: "isApproxEq",
symbol: `Num.isApproxEq`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
Record {
fields: [
OptionalField {
name: "rtol",
type_annotation: Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
},
OptionalField {
name: "atol",
type_annotation: Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
},
],
extension: NoTypeAnn,
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` if the first number and second number are within a specific threshold\n\nA specific relative and absolute tolerance can be provided to change the threshold\n\nThis function is symmetric: `Num.isApproxEq a b == Num.isApproxEq b a`\n\nIf either argument is [*NaN*](Num.isNaN), returns `Bool.false` no matter what. (*NaN*\nis [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).)\n",
),
},
),
DocDef(
DocDef {
name: "isZero",
symbol: `Num.isZero`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` if the number is `0`, and `Bool.false` otherwise.\n",
),
},
),
DocDef(
DocDef {
name: "isEven",
symbol: `Num.isEven`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"A number is even if dividing it by 2 gives a remainder of 0.\n\nExamples of even numbers: 0, 2, 4, 6, 8, -2, -4, -6, -8\n",
),
},
),
DocDef(
DocDef {
name: "isOdd",
symbol: `Num.isOdd`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"A number is odd if dividing it by 2 gives a remainder of 1.\n\nExamples of odd numbers: 1, 3, 5, 7, -1, -3, -5, -7\n",
),
},
),
DocDef(
DocDef {
name: "isPositive",
symbol: `Num.isPositive`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Positive numbers are greater than `0`.\n",
),
},
),
DocDef(
DocDef {
name: "isNegative",
symbol: `Num.isNegative`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Negative numbers are less than `0`.\n",
),
},
),
DocDef(
DocDef {
name: "toFrac",
symbol: `Num.toFrac`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Frac",
parts: [
Wildcard,
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "isNaN",
symbol: `Num.isNaN`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` if the [Frac] is not a number as defined by [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)\n\n```\nNum.isNaN (0 / 0)\n```\n",
),
},
),
DocDef(
DocDef {
name: "isInfinite",
symbol: `Num.isInfinite`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` if the [Frac] is positive or negative infinity as defined by [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)\n\n```\nNum.isInfinite (1 / 0)\n\nNum.isInfinite (-1 / 0)\n```\n",
),
},
),
DocDef(
DocDef {
name: "isFinite",
symbol: `Num.isFinite`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns `Bool.true` if the [Frac] is not an infinity as defined by [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)\n\n```\nNum.isFinite 42\n```\n",
),
},
),
DocDef(
DocDef {
name: "abs",
symbol: `Num.abs`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Returns the absolute value of the number.\n\n* For a positive number, returns the same number.\n* For a negative number, returns the same number except positive.\n* For zero, returns zero.\n```\nNum.abs 4\n\nNum.abs -2.5\n\nNum.abs 0\n\nNum.abs 0.0\n```\nThis is safe to use with any [Frac], but it can cause overflow when used with certain [Int] values.\n\nFor example, calling #Num.abs on the lowest value of a signed integer (such as [Num.minI64] or [Num.minI32]) will cause overflow.\nThis is because, for any given size of signed integer (32-bit, 64-bit, etc.) its negated lowest value turns out to be 1 higher than\nthe highest value it can represent. (For this reason, calling [Num.neg] on the lowest signed value will also cause overflow.)\n\nCalling this on an unsigned integer (like [U32] or [U64]) never does anything.\n",
),
},
),
DocDef(
DocDef {
name: "absDiff",
symbol: `Num.absDiff`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Returns the absolute difference between two numbers.\n\n```\nNum.absDiff 5 3\n\nNum.absDiff -3 5\n\nNum.absDiff 3.0 5.0\n```\n\nIf the answer to this operation can't fit in the return value (e.g. an\n[I8] answer that's higher than 127 or lower than -128), the result is an\n*overflow*. For [F64] and [F32], overflow results in an answer of either\n∞ or -∞. For all other number types, overflow results in a panic.\n",
),
},
),
DocDef(
DocDef {
name: "neg",
symbol: `Num.neg`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Returns a negative number when given a positive one, and vice versa.\n```\nNum.neg 5\n\nNum.neg -2.5\n\nNum.neg 0\n\nNum.neg 0.0\n```\nThis is safe to use with any [Frac], but it can cause overflow when used with certain [Int] values.\n\nFor example, calling #Num.neg on the lowest value of a signed integer (such as [Num.minI64] or [Num.minI32]) will cause overflow.\nThis is because, for any given size of signed integer (32-bit, 64-bit, etc.) its negated lowest value turns out to be 1 higher than\nthe highest value it can represent. (For this reason, calling #Num.abs on the lowest signed value will also cause overflow.)\n\nAdditionally, calling #Num.neg on any unsigned integer (such as any [U64] or [U32] value) other than zero will cause overflow.\n\n(It will never crash when given a [Frac], however, because of how floating point numbers represent positive and negative numbers.)\n",
),
},
),
DocDef(
DocDef {
name: "add",
symbol: `Num.add`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Adds two numbers of the same type.\n\n(To add an [Int] and a [Frac], first convert one so that they both have the same type. There are functions in this module that can convert both [Int] to [Frac] and the other way around.)\n\n`a + b` is shorthand for `Num.add a b`.\n```\n5 + 7\n\nNum.add 5 7\n```\n`Num.add` can be convenient in pipelines.\n```\nFrac.pi\n |> Num.add 1.0\n```\nIf the answer to this operation can't fit in the return value (e.g. an\n[I8] answer that's higher than 127 or lower than -128), the result is an\n*overflow*. For [F64] and [F32], overflow results in an answer of either\n∞ or -∞. For all other number types, overflow results in a panic.\n",
),
},
),
DocDef(
DocDef {
name: "sub",
symbol: `Num.sub`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Subtracts two numbers of the same type.\n\n(To subtract an [Int] and a [Frac], first convert one so that they both have the same type. There are functions in this module that can convert both [Int] to [Frac] and the other way around.)\n\n`a - b` is shorthand for `Num.sub a b`.\n```\n7 - 5\n\nNum.sub 7 5\n```\n`Num.sub` can be convenient in pipelines.\n```\nFrac.pi\n |> Num.sub 2.0\n```\nIf the answer to this operation can't fit in the return value (e.g. an\n[I8] answer that's higher than 127 or lower than -128), the result is an\n*overflow*. For [F64] and [F32], overflow results in an answer of either\n∞ or -∞. For all other number types, overflow results in a panic.\n",
),
},
),
DocDef(
DocDef {
name: "mul",
symbol: `Num.mul`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Multiplies two numbers of the same type.\n\n(To multiply an [Int] and a [Frac], first convert one so that they both have the same type. There are functions in this module that can convert both [Int] to [Frac] and the other way around.)\n\n`a * b` is shorthand for `Num.mul a b`.\n```\n5 * 7\n\nNum.mul 5 7\n```\n\n`Num.mul` can be convenient in pipelines.\n\n```\nFrac.pi\n |> Num.mul 2.0\n```\nIf the answer to this operation can't fit in the return value (e.g. an\n[I8] answer that's higher than 127 or lower than -128), the result is an\n*overflow*. For [F64] and [F32], overflow results in an answer of either\n∞ or -∞. For all other number types, overflow results in a panic.\n",
),
},
),
DocDef(
DocDef {
name: "min",
symbol: `Num.min`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Obtains the smaller between two numbers of the same type.\n\n```\nNum.min 100 0\n\nNum.min 3.0 -3.0\n```\n",
),
},
),
DocDef(
DocDef {
name: "max",
symbol: `Num.max`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Obtains the greater between two numbers of the same type.\n\n```\nNum.max 100 0\n\nNum.max 3.0 -3.0\n```\n",
),
},
),
DocDef(
DocDef {
name: "sin",
symbol: `Num.sin`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "cos",
symbol: `Num.cos`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "tan",
symbol: `Num.tan`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "asin",
symbol: `Num.asin`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "acos",
symbol: `Num.acos`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "atan",
symbol: `Num.atan`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "sqrt",
symbol: `Num.sqrt`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Returns an approximation of the absolute value of a [Frac]'s square root.\n\nThe square root of a negative number is an irrational number, and [Frac] only\nsupports rational numbers. As such, you should make sure never to pass this\nfunction a negative number! Calling [sqrt] on a negative [Dec] will cause a panic.\n\nCalling [sqrt] on [F32] and [F64] values follows these rules:\n* Passing a negative [F64] or [F32] returns [*NaN*](Num.isNaN).\n* Passing [*NaN*](Num.isNaN) or -∞ also returns [*NaN*](Num.isNaN).\n* Passing ∞ returns ∞.\n\n> These rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)\n> floating point standard. Because almost all modern processors are built to\n> this standard, deviating from these rules has a significant performance\n> cost! Since the most common reason to choose [F64] or [F32] over [Dec] is\n> access to hardware-accelerated performance, Roc follows these rules exactly.\n```\nNum.sqrt 4.0\n\nNum.sqrt 1.5\n\nNum.sqrt 0.0\n\nNum.sqrt -4.0f64\n```\n",
),
},
),
DocDef(
DocDef {
name: "sqrtChecked",
symbol: `Num.sqrtChecked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
TagUnion {
tags: [
Tag {
name: "SqrtOfNegative",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "log",
symbol: `Num.log`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Natural logarithm\n",
),
},
),
DocDef(
DocDef {
name: "logChecked",
symbol: `Num.logChecked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
TagUnion {
tags: [
Tag {
name: "LogNeedsPositive",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "div",
symbol: `Num.div`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Divides one [Frac] by another.\n\n`a / b` is shorthand for `Num.div a b`.\n\n[Division by zero is undefined in mathematics](https://en.wikipedia.org/wiki/Division_by_zero).\nAs such, you should make sure never to pass zero as the denominator to this function!\nCalling [div] on a [Dec] denominator of zero will cause a panic.\n\nCalling [div] on [F32] and [F64] values follows these rules:\n* Dividing a positive [F64] or [F32] by zero returns ∞.\n* Dividing a negative [F64] or [F32] by zero returns -∞.\n* Dividing a zero [F64] or [F32] by zero returns [*NaN*](Num.isNaN).\n\n> These rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)\n> floating point standard. Because almost all modern processors are built to\n> this standard, deviating from these rules has a significant performance\n> cost! Since the most common reason to choose [F64] or [F32] over [Dec] is\n> access to hardware-accelerated performance, Roc follows these rules exactly.\n\nTo divide an [Int] and a [Frac], first convert the [Int] to a [Frac] using\none of the functions in this module like #toDec.\n```\n5.0 / 7.0\n\nNum.div 5 7\n```\n`Num.div` can be convenient in pipelines.\n```\nNum.pi\n |> Num.div 2.0\n```\n",
),
},
),
DocDef(
DocDef {
name: "divChecked",
symbol: `Num.divChecked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
TagUnion {
tags: [
Tag {
name: "DivByZero",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "divCeil",
symbol: `Num.divCeil`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "divCeilChecked",
symbol: `Num.divCeilChecked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
TagUnion {
tags: [
Tag {
name: "DivByZero",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "divTrunc",
symbol: `Num.divTrunc`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Divides two integers, truncating the result towards zero.\n\n`a // b` is shorthand for `Num.divTrunc a b`.\n\nDivision by zero is undefined in mathematics. As such, you should make\nsure never to pass zero as the denominator to this function! If you do,\nit will crash.\n```\n5 // 7\n\nNum.divTrunc 5 7\n\n8 // -3\n\nNum.divTrunc 8 -3\n```\n",
),
},
),
DocDef(
DocDef {
name: "divTruncChecked",
symbol: `Num.divTruncChecked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
TagUnion {
tags: [
Tag {
name: "DivByZero",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "divTruncUnchecked",
symbol: `Num.divTruncUnchecked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"traps (hardware fault) when given zero as the second argument.\n",
),
},
),
DocDef(
DocDef {
name: "rem",
symbol: `Num.rem`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Obtains the remainder (truncating modulo) from the division of two integers.\n\n`a % b` is shorthand for `Num.rem a b`.\n```\n5 % 7\n\nNum.rem 5 7\n\n-8 % -3\n\nNum.rem -8 -3\n```\n",
),
},
),
DocDef(
DocDef {
name: "remChecked",
symbol: `Num.remChecked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
TagUnion {
tags: [
Tag {
name: "DivByZero",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "remUnchecked",
symbol: `Num.remUnchecked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"traps (hardware fault) when given zero as the second argument.\n",
),
},
),
DocDef(
DocDef {
name: "isMultipleOf",
symbol: `Num.isMultipleOf`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "bitwiseAnd",
symbol: `Num.bitwiseAnd`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Does a \"bitwise and\". Each bit of the output is 1 if the corresponding bit\nof x AND of y is 1, otherwise it's 0.\n",
),
},
),
DocDef(
DocDef {
name: "bitwiseXor",
symbol: `Num.bitwiseXor`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Does a \"bitwise exclusive or\". Each bit of the output is the same as the\ncorresponding bit in x if that bit in y is 0, and it's the complement of\nthe bit in x if that bit in y is 1.\n",
),
},
),
DocDef(
DocDef {
name: "bitwiseOr",
symbol: `Num.bitwiseOr`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Does a \"bitwise or\". Each bit of the output is 0 if the corresponding bit\nof x OR of y is 0, otherwise it's 1.\n",
),
},
),
DocDef(
DocDef {
name: "bitwiseNot",
symbol: `Num.bitwiseNot`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Returns the complement of x - the number you get by switching each 1 for a\n0 and each 0 for a 1. This is the same as -x - 1.\n",
),
},
),
DocDef(
DocDef {
name: "shiftLeftBy",
symbol: `Num.shiftLeftBy`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U8",
parts: [],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Bitwise left shift of a number by another\n\nThe least significant bits always become 0. This means that shifting left is\nlike multiplying by factors of two for unsigned integers.\n```\nshiftLeftBy 0b0000_0011 2 == 0b0000_1100\n\n0b0000_0101 |> shiftLeftBy 2 == 0b0000_1100\n```\nIn some languages `shiftLeftBy` is implemented as a binary operator `<<`.\n",
),
},
),
DocDef(
DocDef {
name: "shiftRightBy",
symbol: `Num.shiftRightBy`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U8",
parts: [],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Bitwise arithmetic shift of a number by another\n\nThe most significant bits are copied from the current.\n```\nshiftRightBy 0b0000_1100 2 == 0b0000_0011\n\n0b0001_0100 |> shiftRightBy 2 == 0b0000_0101\n\n0b1001_0000 |> shiftRightBy 2 == 0b1110_0100\n```\nIn some languages `shiftRightBy` is implemented as a binary operator `>>>`.\n",
),
},
),
DocDef(
DocDef {
name: "shiftRightZfBy",
symbol: `Num.shiftRightZfBy`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U8",
parts: [],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Bitwise logical right shift of a number by another\n\nThe most significant bits always become 0. This means that shifting right is\nlike dividing by factors of two for unsigned integers.\n```\nshiftRightZfBy 0b0010_1000 2 == 0b0000_1010\n\n0b0010_1000 |> shiftRightZfBy 2 == 0b0000_1010\n\n0b1001_0000 |> shiftRightZfBy 2 == 0b0010_0100\n```\nIn some languages `shiftRightZfBy` is implemented as a binary operator `>>`.\n",
),
},
),
DocDef(
DocDef {
name: "round",
symbol: `Num.round`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Int",
parts: [
Wildcard,
],
},
},
docs: Some(
"Round off the given fraction to the nearest integer.\n",
),
},
),
DocDef(
DocDef {
name: "floor",
symbol: `Num.floor`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Int",
parts: [
Wildcard,
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "ceiling",
symbol: `Num.ceiling`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Int",
parts: [
Wildcard,
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "pow",
symbol: `Num.pow`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Frac",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Raises a [Frac] to the power of another [Frac].\n\nFor an [Int] alternative to this function, see [Num.powInt]\n",
),
},
),
DocDef(
DocDef {
name: "powInt",
symbol: `Num.powInt`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Raises an integer to the power of another, by multiplying the integer by\nitself the given number of times.\n\nThis process is known as [exponentiation by squaring](https://en.wikipedia.org/wiki/Exponentiation_by_squaring).\n\nFor a [Frac] alternative to this function, which supports negative exponents,\nsee #Num.pow.\n\n## Warning\n\nIt is very easy for this function to produce an answer\nso large it causes an overflow.\n",
),
},
),
DocDef(
DocDef {
name: "countLeadingZeroBits",
symbol: `Num.countLeadingZeroBits`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "U8",
parts: [],
},
},
docs: Some(
"Counts the number of most-significant (leading in a big-Endian sense) zeroes in an integer.\n\n```\nNum.countLeadingZeroBits 0b0001_1100u8\n\n3\n\nNum.countLeadingZeroBits 0b0000_0000u8\n\n8\n```\n",
),
},
),
DocDef(
DocDef {
name: "countTrailingZeroBits",
symbol: `Num.countTrailingZeroBits`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "U8",
parts: [],
},
},
docs: Some(
"Counts the number of least-significant (trailing in a big-Endian sense) zeroes in an integer.\n\n```\nNum.countTrailingZeroBits 0b0001_1100u8\n\n2\n\nNum.countTrailingZeroBits 0b0000_0000u8\n\n8\n```\n",
),
},
),
DocDef(
DocDef {
name: "countOneBits",
symbol: `Num.countOneBits`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "U8",
parts: [],
},
},
docs: Some(
"Counts the number of set bits in an integer.\n\n```\nNum.countOneBits 0b0001_1100u8\n\n3\n\nNum.countOneBits 0b0000_0000u8\n\n0\n```\n",
),
},
),
DocDef(
DocDef {
name: "addWrap",
symbol: `Num.addWrap`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"range",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"range",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"range",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "addSaturated",
symbol: `Num.addSaturated`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Adds two numbers, clamping on the maximum representable number rather than\noverflowing.\n\nThis is the same as [Num.add] except for the saturating behavior if the\naddition is to overflow.\nFor example, if `x : U8` is 200 and `y : U8` is 100, `addSaturated x y` will\nyield 255, the maximum value of a `U8`.\n",
),
},
),
DocDef(
DocDef {
name: "addChecked",
symbol: `Num.addChecked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
TagUnion {
tags: [
Tag {
name: "Overflow",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Adds two numbers and checks for overflow.\n\nThis is the same as [Num.add] except if the operation overflows, instead of\npanicking or returning ∞ or -∞, it will return `Err Overflow`.\n",
),
},
),
DocDef(
DocDef {
name: "addCheckedLowlevel",
symbol: `Num.addCheckedLowlevel`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Record {
fields: [
RecordField {
name: "b",
type_annotation: Apply {
name: "Bool",
parts: [],
},
},
RecordField {
name: "a",
type_annotation: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "subWrap",
symbol: `Num.subWrap`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"range",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"range",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"range",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "subSaturated",
symbol: `Num.subSaturated`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Subtracts two numbers, clamping on the minimum representable number rather\nthan overflowing.\n\nThis is the same as [Num.sub] except for the saturating behavior if the\nsubtraction is to overflow.\nFor example, if `x : U8` is 10 and `y : U8` is 20, `subSaturated x y` will\nyield 0, the minimum value of a `U8`.\n",
),
},
),
DocDef(
DocDef {
name: "subChecked",
symbol: `Num.subChecked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
TagUnion {
tags: [
Tag {
name: "Overflow",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Subtracts two numbers and checks for overflow.\n\nThis is the same as [Num.sub] except if the operation overflows, instead of\npanicking or returning ∞ or -∞, it will return `Err Overflow`.\n",
),
},
),
DocDef(
DocDef {
name: "subCheckedLowlevel",
symbol: `Num.subCheckedLowlevel`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Record {
fields: [
RecordField {
name: "b",
type_annotation: Apply {
name: "Bool",
parts: [],
},
},
RecordField {
name: "a",
type_annotation: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "mulWrap",
symbol: `Num.mulWrap`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
BoundVariable(
"range",
),
],
},
Apply {
name: "Int",
parts: [
BoundVariable(
"range",
),
],
},
],
output: Apply {
name: "Int",
parts: [
BoundVariable(
"range",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "mulSaturated",
symbol: `Num.mulSaturated`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Multiplies two numbers, clamping on the maximum representable number rather than\noverflowing.\n\nThis is the same as [Num.mul] except for the saturating behavior if the\naddition is to overflow.\n",
),
},
),
DocDef(
DocDef {
name: "mulChecked",
symbol: `Num.mulChecked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
TagUnion {
tags: [
Tag {
name: "Overflow",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Multiplies two numbers and checks for overflow.\n\nThis is the same as [Num.mul] except if the operation overflows, instead of\npanicking or returning ∞ or -∞, it will return `Err Overflow`.\n",
),
},
),
DocDef(
DocDef {
name: "mulCheckedLowlevel",
symbol: `Num.mulCheckedLowlevel`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Record {
fields: [
RecordField {
name: "b",
type_annotation: Apply {
name: "Bool",
parts: [],
},
},
RecordField {
name: "a",
type_annotation: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "minI8",
symbol: `Num.minI8`,
type_vars: [],
type_annotation: Apply {
name: "I8",
parts: [],
},
docs: Some(
"Returns the lowest number that can be stored in an [I8] without underflowing\nits available memory and crashing.\n\nFor reference, this number is `-128`.\n\nNote that the positive version of this number is larger than [Num.maxI8],\nwhich means if you call [Num.abs] on [Num.minI8], it will overflow and crash!\n",
),
},
),
DocDef(
DocDef {
name: "maxI8",
symbol: `Num.maxI8`,
type_vars: [],
type_annotation: Apply {
name: "I8",
parts: [],
},
docs: Some(
"Returns the highest number that can be stored in an [I8] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `127`.\n\nNote that this is smaller than the positive version of [Num.minI8],\nwhich means if you call [Num.abs] on [Num.minI8], it will overflow and crash!\n",
),
},
),
DocDef(
DocDef {
name: "minU8",
symbol: `Num.minU8`,
type_vars: [],
type_annotation: Apply {
name: "U8",
parts: [],
},
docs: Some(
"Returns the lowest number that can be stored in a [U8] without underflowing\nits available memory and crashing.\n\nFor reference, this number is zero, because [U8] is\n[unsigned](https://en.wikipedia.org/wiki/Signed_number_representations),\nand zero is the lowest unsigned number.\nUnsigned numbers cannot be negative.\n",
),
},
),
DocDef(
DocDef {
name: "maxU8",
symbol: `Num.maxU8`,
type_vars: [],
type_annotation: Apply {
name: "U8",
parts: [],
},
docs: Some(
"Returns the highest number that can be stored in a [U8] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `255`.\n",
),
},
),
DocDef(
DocDef {
name: "minI16",
symbol: `Num.minI16`,
type_vars: [],
type_annotation: Apply {
name: "I16",
parts: [],
},
docs: Some(
"Returns the lowest number that can be stored in an [I16] without underflowing\nits available memory and crashing.\n\nFor reference, this number is `-32_768`.\n\nNote that the positive version of this number is larger than [Num.maxI16],\nwhich means if you call [Num.abs] on [Num.minI16], it will overflow and crash!\n",
),
},
),
DocDef(
DocDef {
name: "maxI16",
symbol: `Num.maxI16`,
type_vars: [],
type_annotation: Apply {
name: "I16",
parts: [],
},
docs: Some(
"Returns the highest number that can be stored in an [I16] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `32_767`.\n\nNote that this is smaller than the positive version of [Num.minI16],\nwhich means if you call [Num.abs] on [Num.minI16], it will overflow and crash!\n",
),
},
),
DocDef(
DocDef {
name: "minU16",
symbol: `Num.minU16`,
type_vars: [],
type_annotation: Apply {
name: "U16",
parts: [],
},
docs: Some(
"Returns the lowest number that can be stored in a [U16] without underflowing\nits available memory and crashing.\n\nFor reference, this number is zero, because [U16] is\n[unsigned](https://en.wikipedia.org/wiki/Signed_number_representations),\nand zero is the lowest unsigned number.\nUnsigned numbers cannot be negative.\n",
),
},
),
DocDef(
DocDef {
name: "maxU16",
symbol: `Num.maxU16`,
type_vars: [],
type_annotation: Apply {
name: "U16",
parts: [],
},
docs: Some(
"Returns the highest number that can be stored in a [U16] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `65_535`.\n",
),
},
),
DocDef(
DocDef {
name: "minI32",
symbol: `Num.minI32`,
type_vars: [],
type_annotation: Apply {
name: "I32",
parts: [],
},
docs: Some(
"Returns the lowest number that can be stored in an [I32] without underflowing\nits available memory and crashing.\n\nFor reference, this number is `-2_147_483_648`.\n\nNote that the positive version of this number is larger than [Num.maxI32],\nwhich means if you call [Num.abs] on [Num.minI32], it will overflow and crash!\n",
),
},
),
DocDef(
DocDef {
name: "maxI32",
symbol: `Num.maxI32`,
type_vars: [],
type_annotation: Apply {
name: "I32",
parts: [],
},
docs: Some(
"Returns the highest number that can be stored in an [I32] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `2_147_483_647`,\nwhich is over 2 million.\n\nNote that this is smaller than the positive version of [Num.minI32],\nwhich means if you call [Num.abs] on [Num.minI32], it will overflow and crash!\n",
),
},
),
DocDef(
DocDef {
name: "minU32",
symbol: `Num.minU32`,
type_vars: [],
type_annotation: Apply {
name: "U32",
parts: [],
},
docs: Some(
"Returns the lowest number that can be stored in a [U32] without underflowing\nits available memory and crashing.\n\nFor reference, this number is zero, because [U32] is\n[unsigned](https://en.wikipedia.org/wiki/Signed_number_representations),\nand zero is the lowest unsigned number.\nUnsigned numbers cannot be negative.\n",
),
},
),
DocDef(
DocDef {
name: "maxU32",
symbol: `Num.maxU32`,
type_vars: [],
type_annotation: Apply {
name: "U32",
parts: [],
},
docs: Some(
"Returns the highest number that can be stored in a [U32] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `4_294_967_295`.\n",
),
},
),
DocDef(
DocDef {
name: "minI64",
symbol: `Num.minI64`,
type_vars: [],
type_annotation: Apply {
name: "I64",
parts: [],
},
docs: Some(
"Returns the lowest number that can be stored in an [I64] without underflowing\nits available memory and crashing.\n\nFor reference, this number is `-9_223_372_036_854_775_808`,\nwhich is under 9 quintillion.\n\nNote that the positive version of this number is larger than [Num.maxI64],\nwhich means if you call [Num.abs] on [Num.minI64], it will overflow and crash!\n",
),
},
),
DocDef(
DocDef {
name: "maxI64",
symbol: `Num.maxI64`,
type_vars: [],
type_annotation: Apply {
name: "I64",
parts: [],
},
docs: Some(
"Returns the highest number that can be stored in an [I64] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `9_223_372_036_854_775_807`,\nwhich is over 9 quintillion.\n\nNote that this is smaller than the positive version of [Num.minI64],\nwhich means if you call [Num.abs] on [Num.minI64], it will overflow and crash!\n",
),
},
),
DocDef(
DocDef {
name: "minU64",
symbol: `Num.minU64`,
type_vars: [],
type_annotation: Apply {
name: "U64",
parts: [],
},
docs: Some(
"Returns the lowest number that can be stored in a [U64] without underflowing\nits available memory and crashing.\n\nFor reference, this number is zero, because [U64] is\n[unsigned](https://en.wikipedia.org/wiki/Signed_number_representations),\nand zero is the lowest unsigned number.\nUnsigned numbers cannot be negative.\n",
),
},
),
DocDef(
DocDef {
name: "maxU64",
symbol: `Num.maxU64`,
type_vars: [],
type_annotation: Apply {
name: "U64",
parts: [],
},
docs: Some(
"Returns the highest number that can be stored in a [U64] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `18_446_744_073_709_551_615`,\nwhich is over 18 quintillion.\n",
),
},
),
DocDef(
DocDef {
name: "minI128",
symbol: `Num.minI128`,
type_vars: [],
type_annotation: Apply {
name: "I128",
parts: [],
},
docs: Some(
"Returns the lowest number that can be stored in an [I128] without underflowing\nits available memory and crashing.\n\nFor reference, this number is `-170_141_183_460_469_231_731_687_303_715_884_105_728`.\nwhich is under 170 undecillion.\n\nNote that the positive version of this number is larger than [Num.maxI128],\nwhich means if you call [Num.abs] on [Num.minI128], it will overflow and crash!\n",
),
},
),
DocDef(
DocDef {
name: "maxI128",
symbol: `Num.maxI128`,
type_vars: [],
type_annotation: Apply {
name: "I128",
parts: [],
},
docs: Some(
"Returns the highest number that can be stored in an [I128] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `170_141_183_460_469_231_731_687_303_715_884_105_727`,\nwhich is over 170 undecillion.\n\nNote that this is smaller than the positive version of [Num.minI128],\nwhich means if you call [Num.abs] on [Num.minI128], it will overflow and crash!\n",
),
},
),
DocDef(
DocDef {
name: "minU128",
symbol: `Num.minU128`,
type_vars: [],
type_annotation: Apply {
name: "U128",
parts: [],
},
docs: Some(
"Returns the lowest number that can be stored in a [U128] without underflowing\nits available memory and crashing.\n\nFor reference, this number is zero, because [U128] is\n[unsigned](https://en.wikipedia.org/wiki/Signed_number_representations),\nand zero is the lowest unsigned number.\nUnsigned numbers cannot be negative.\n",
),
},
),
DocDef(
DocDef {
name: "maxU128",
symbol: `Num.maxU128`,
type_vars: [],
type_annotation: Apply {
name: "U128",
parts: [],
},
docs: Some(
"Returns the highest number that can be stored in a [U128] without overflowing\nits available memory and crashing.\n\nFor reference, this number is `340_282_366_920_938_463_463_374_607_431_768_211_455`,\nwhich is over 340 undecillion.\n",
),
},
),
DocDef(
DocDef {
name: "minF32",
symbol: `Num.minF32`,
type_vars: [],
type_annotation: Apply {
name: "F32",
parts: [],
},
docs: None,
},
),
DocDef(
DocDef {
name: "maxF32",
symbol: `Num.maxF32`,
type_vars: [],
type_annotation: Apply {
name: "F32",
parts: [],
},
docs: None,
},
),
DocDef(
DocDef {
name: "minF64",
symbol: `Num.minF64`,
type_vars: [],
type_annotation: Apply {
name: "F64",
parts: [],
},
docs: None,
},
),
DocDef(
DocDef {
name: "maxF64",
symbol: `Num.maxF64`,
type_vars: [],
type_annotation: Apply {
name: "F64",
parts: [],
},
docs: None,
},
),
DocDef(
DocDef {
name: "toI8",
symbol: `Num.toI8`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "I8",
parts: [],
},
},
docs: Some(
"Converts an [Int] to an [I8]. If the given number can't be precisely represented in an [I8],\nthe returned number may be different from the given number.\n",
),
},
),
DocDef(
DocDef {
name: "toI16",
symbol: `Num.toI16`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "I16",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toI32",
symbol: `Num.toI32`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "I32",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toI64",
symbol: `Num.toI64`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "I64",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toI128",
symbol: `Num.toI128`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "I128",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toU8",
symbol: `Num.toU8`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "U8",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toU16",
symbol: `Num.toU16`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "U16",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toU32",
symbol: `Num.toU32`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "U32",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toU64",
symbol: `Num.toU64`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toU128",
symbol: `Num.toU128`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "U128",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toF32",
symbol: `Num.toF32`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "F32",
parts: [],
},
},
docs: Some(
"Converts a [Num] to an [F32]. If the given number can't be precisely represented in an [F32],\nthe returned number may be different from the given number.\n",
),
},
),
DocDef(
DocDef {
name: "toF64",
symbol: `Num.toF64`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "F64",
parts: [],
},
},
docs: Some(
"Converts a [Num] to an [F64]. If the given number can't be precisely represented in an [F64],\nthe returned number may be different from the given number.\n",
),
},
),
DocDef(
DocDef {
name: "toI8Checked",
symbol: `Num.toI8Checked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "I8",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Converts a [Int] to an [I8].\nIf the given integer can't be precisely represented in an [I8], returns\n`Err OutOfBounds`.\n",
),
},
),
DocDef(
DocDef {
name: "toI16Checked",
symbol: `Num.toI16Checked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "I16",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toI32Checked",
symbol: `Num.toI32Checked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "I32",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toI64Checked",
symbol: `Num.toI64Checked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "I64",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toI128Checked",
symbol: `Num.toI128Checked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "I128",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toU8Checked",
symbol: `Num.toU8Checked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "U8",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toU16Checked",
symbol: `Num.toU16Checked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "U16",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toU32Checked",
symbol: `Num.toU32Checked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "U32",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toU64Checked",
symbol: `Num.toU64Checked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "U64",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toU128Checked",
symbol: `Num.toU128Checked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Int",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "U128",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toF32Checked",
symbol: `Num.toF32Checked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "F32",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toF64Checked",
symbol: `Num.toF64Checked`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Num",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "F64",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
],
scope: Scope {
aliases: VecMap {
keys: [
`Result.Result`,
`Bool.Bool`,
`Num.Num`,
`Num.Int`,
`Num.Frac`,
`Num.Signed128`,
`Num.Signed64`,
`Num.Signed32`,
`Num.Signed16`,
`Num.Signed8`,
`Num.Unsigned128`,
`Num.Unsigned64`,
`Num.Unsigned32`,
`Num.Unsigned16`,
`Num.Unsigned8`,
`Num.Integer`,
`Num.I128`,
`Num.I64`,
`Num.I32`,
`Num.I16`,
`Num.I8`,
`Num.U128`,
`Num.U64`,
`Num.U32`,
`Num.U16`,
`Num.U8`,
`Num.Decimal`,
`Num.Binary64`,
`Num.Binary32`,
`Num.FloatingPoint`,
`Num.F64`,
`Num.F32`,
`Num.Dec`,
],
values: [
Alias {
region: @241-254,
type_variables: [
@248-250 AliasVar {
name: 'ok',
var: 64,
opt_bound_abilities: None,
},
@251-254 AliasVar {
name: 'err',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['Err' <65>, 'Ok' <64>]<63>,
kind: Structural,
},
Alias {
region: @1780-1784,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: ['False', 'True'],
kind: Opaque,
},
Alias {
region: @5228-5237,
type_variables: [
@5232-5237 AliasVar {
name: 'range',
var: 63,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <63>,
kind: Opaque,
},
Alias {
region: @12895-12904,
type_variables: [
@12899-12904 AliasVar {
name: 'range',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` <64>[ but actually <64> ])[ but actually (Alias `Num.Integer` <64>[ but actually <64> ]) ]),
kind: Structural,
},
Alias {
region: @17034-17044,
type_variables: [
@17039-17044 AliasVar {
name: 'range',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` <65>[ but actually <65> ])[ but actually (Alias `Num.FloatingPoint` <65>[ but actually <65> ]) ]),
kind: Structural,
},
Alias {
region: @17074-17083,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17090-17098,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17105-17113,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17120-17128,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17135-17142,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17150-17161,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17168-17178,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17185-17195,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17202-17212,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17219-17228,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17236-17249,
type_variables: [
@17244-17249 AliasVar {
name: 'range',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <66>,
kind: Opaque,
},
Alias {
region: @17260-17264,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17291-17294,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17320-17323,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17349-17352,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17431-17433,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Int` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ]) ]) ]),
kind: Structural,
},
Alias {
region: @17449-17453,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17482-17485,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17513-17516,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17544-17547,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17575-17577,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17605-17612,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17619-17627,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17634-17642,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17650-17669,
type_variables: [
@17664-17669 AliasVar {
name: 'range',
var: 67,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <67>,
kind: Opaque,
},
Alias {
region: @19085-19088,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @19444-19447,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @23363-23366,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ]) ]),
kind: Structural,
},
],
},
abilities_store: IAbilitiesStore {
members_of_ability: {
`Bool.Eq`: [
`Bool.isEq`,
],
},
specialization_to_root: {
`Bool.boolIsEq`: ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
},
},
ability_members: {
`Bool.isEq`: AbilityMemberData {
parent_ability: `Bool.Eq`,
region: @1635-1639,
typ: Imported,
},
},
declared_implementations: {
ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
}: Impl(
`Bool.boolIsEq`,
),
},
specializations: {},
next_specialization_id: 1,
resolved_specializations: {},
},
home: Num,
exposed_ident_count: 159,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "Result",
},
),
`Result.Result`,
@2638-2644,
),
(
Ident(
IdentStr {
string: "Bool",
},
),
`Bool.Bool`,
@2613-2617,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
78,
117,
109,
73,
49,
50,
56,
85,
49,
50,
56,
73,
54,
52,
85,
54,
52,
73,
51,
50,
85,
51,
50,
73,
49,
54,
85,
49,
54,
73,
56,
85,
56,
73,
110,
116,
101,
103,
101,
114,
70,
54,
52,
70,
51,
50,
70,
108,
111,
97,
116,
105,
110,
103,
80,
111,
105,
110,
116,
109,
97,
120,
70,
51,
50,
109,
105,
110,
70,
51,
50,
97,
98,
115,
110,
101,
103,
97,
100,
100,
115,
117,
98,
109,
117,
108,
105,
115,
76,
116,
105,
115,
76,
116,
101,
105,
115,
71,
116,
105,
115,
71,
116,
101,
116,
111,
70,
114,
97,
99,
115,
105,
110,
99,
111,
115,
116,
97,
110,
105,
115,
90,
101,
114,
111,
105,
115,
69,
118,
101,
110,
105,
115,
79,
100,
100,
105,
115,
80,
111,
115,
105,
116,
105,
118,
101,
105,
115,
78,
101,
103,
97,
116,
105,
118,
101,
114,
101,
109,
114,
101,
109,
67,
104,
101,
99,
107,
101,
100,
100,
105,
118,
100,
105,
118,
67,
104,
101,
99,
107,
101,
100,
100,
105,
118,
84,
114,
117,
110,
99,
100,
105,
118,
84,
114,
117,
110,
99,
67,
104,
101,
99,
107,
101,
100,
115,
113,
114,
116,
115,
113,
114,
116,
67,
104,
101,
99,
107,
101,
100,
108,
111,
103,
108,
111,
103,
67,
104,
101,
99,
107,
101,
100,
114,
111,
117,
110,
100,
99,
111,
109,
112,
97,
114,
101,
112,
111,
119,
99,
101,
105,
108,
105,
110,
103,
112,
111,
119,
73,
110,
116,
102,
108,
111,
111,
114,
97,
100,
100,
87,
114,
97,
112,
97,
100,
100,
67,
104,
101,
99,
107,
101,
100,
97,
100,
100,
83,
97,
116,
117,
114,
97,
116,
101,
100,
97,
116,
97,
110,
97,
99,
111,
115,
97,
115,
105,
110,
83,
105,
103,
110,
101,
100,
49,
50,
56,
83,
105,
103,
110,
101,
100,
54,
52,
83,
105,
103,
110,
101,
100,
51,
50,
83,
105,
103,
110,
101,
100,
49,
54,
83,
105,
103,
110,
101,
100,
56,
85,
110,
115,
105,
103,
110,
101,
100,
49,
50,
56,
85,
110,
115,
105,
103,
110,
101,
100,
54,
52,
85,
110,
115,
105,
103,
110,
101,
100,
51,
50,
85,
110,
115,
105,
103,
110,
101,
100,
49,
54,
85,
110,
115,
105,
103,
110,
101,
100,
56,
66,
105,
110,
97,
114,
121,
54,
52,
66,
105,
110,
97,
114,
121,
51,
50,
98,
105,
116,
119,
105,
115,
101,
65,
110,
100,
98,
105,
116,
119,
105,
115,
101,
88,
111,
114,
98,
105,
116,
119,
105,
115,
101,
79,
114,
115,
104,
105,
102,
116,
76,
101,
102,
116,
66,
121,
115,
104,
105,
102,
116,
82,
105,
103,
104,
116,
66,
121,
115,
104,
105,
102,
116,
82,
105,
103,
104,
116,
90,
102,
66,
121,
115,
117,
98,
87,
114,
97,
112,
115,
117,
98,
67,
104,
101,
99,
107,
101,
100,
115,
117,
98,
83,
97,
116,
117,
114,
97,
116,
101,
100,
109,
117,
108,
87,
114,
97,
112,
109,
117,
108,
67,
104,
101,
99,
107,
101,
100,
109,
117,
108,
83,
97,
116,
117,
114,
97,
116,
101,
100,
73,
110,
116,
70,
114,
97,
99,
101,
112,
105,
116,
97,
117,
105,
115,
77,
117,
108,
116,
105,
112,
108,
101,
79,
102,
68,
101,
99,
105,
109,
97,
108,
68,
101,
99,
99,
111,
117,
110,
116,
79,
110,
101,
66,
105,
116,
115,
97,
98,
115,
68,
105,
102,
102,
105,
115,
78,
97,
78,
105,
115,
73,
110,
102,
105,
110,
105,
116,
101,
105,
115,
70,
105,
110,
105,
116,
101,
99,
111,
117,
110,
116,
76,
101,
97,
100,
105,
110,
103,
90,
101,
114,
111,
66,
105,
116,
115,
99,
111,
117,
110,
116,
84,
114,
97,
105,
108,
105,
110,
103,
90,
101,
114,
111,
66,
105,
116,
115,
116,
111,
83,
116,
114,
109,
105,
110,
73,
56,
109,
97,
120,
73,
56,
109,
105,
110,
85,
56,
109,
97,
120,
85,
56,
109,
105,
110,
73,
49,
54,
109,
97,
120,
73,
49,
54,
109,
105,
110,
85,
49,
54,
109,
97,
120,
85,
49,
54,
109,
105,
110,
73,
51,
50,
109,
97,
120,
73,
51,
50,
109,
105,
110,
85,
51,
50,
109,
97,
120,
85,
51,
50,
109,
105,
110,
73,
54,
52,
109,
97,
120,
73,
54,
52,
109,
105,
110,
85,
54,
52,
109,
97,
120,
85,
54,
52,
109,
105,
110,
73,
49,
50,
56,
109,
97,
120,
73,
49,
50,
56,
109,
105,
110,
85,
49,
50,
56,
109,
97,
120,
85,
49,
50,
56,
116,
111,
73,
56,
116,
111,
73,
56,
67,
104,
101,
99,
107,
101,
100,
116,
111,
73,
49,
54,
116,
111,
73,
49,
54,
67,
104,
101,
99,
107,
101,
100,
116,
111,
73,
51,
50,
116,
111,
73,
51,
50,
67,
104,
101,
99,
107,
101,
100,
116,
111,
73,
54,
52,
116,
111,
73,
54,
52,
67,
104,
101,
99,
107,
101,
100,
116,
111,
73,
49,
50,
56,
116,
111,
73,
49,
50,
56,
67,
104,
101,
99,
107,
101,
100,
116,
111,
85,
56,
116,
111,
85,
56,
67,
104,
101,
99,
107,
101,
100,
116,
111,
85,
49,
54,
116,
111,
85,
49,
54,
67,
104,
101,
99,
107,
101,
100,
116,
111,
85,
51,
50,
116,
111,
85,
51,
50,
67,
104,
101,
99,
107,
101,
100,
116,
111,
85,
54,
52,
116,
111,
85,
54,
52,
67,
104,
101,
99,
107,
101,
100,
116,
111,
85,
49,
50,
56,
116,
111,
85,
49,
50,
56,
67,
104,
101,
99,
107,
101,
100,
100,
105,
118,
67,
101,
105,
108,
100,
105,
118,
67,
101,
105,
108,
67,
104,
101,
99,
107,
101,
100,
116,
111,
70,
51,
50,
116,
111,
70,
51,
50,
67,
104,
101,
99,
107,
101,
100,
116,
111,
70,
54,
52,
116,
111,
70,
54,
52,
67,
104,
101,
99,
107,
101,
100,
109,
97,
120,
70,
54,
52,
109,
105,
110,
70,
54,
52,
97,
100,
100,
67,
104,
101,
99,
107,
101,
100,
76,
111,
119,
108,
101,
118,
101,
108,
115,
117,
98,
67,
104,
101,
99,
107,
101,
100,
76,
111,
119,
108,
101,
118,
101,
108,
109,
117,
108,
67,
104,
101,
99,
107,
101,
100,
76,
111,
119,
108,
101,
118,
101,
108,
109,
105,
110,
109,
97,
120,
98,
105,
116,
119,
105,
115,
101,
78,
111,
116,
105,
110,
116,
67,
97,
115,
116,
105,
115,
65,
112,
112,
114,
111,
120,
69,
113,
98,
121,
116,
101,
115,
84,
111,
85,
49,
54,
76,
111,
119,
108,
101,
118,
101,
108,
98,
121,
116,
101,
115,
84,
111,
85,
51,
50,
76,
111,
119,
108,
101,
118,
101,
108,
98,
121,
116,
101,
115,
84,
111,
85,
54,
52,
76,
111,
119,
108,
101,
118,
101,
108,
98,
121,
116,
101,
115,
84,
111,
85,
49,
50,
56,
76,
111,
119,
108,
101,
118,
101,
108,
100,
105,
118,
84,
114,
117,
110,
99,
85,
110,
99,
104,
101,
99,
107,
101,
100,
114,
101,
109,
85,
110,
99,
104,
101,
99,
107,
101,
100,
78,
117,
109,
73,
110,
116,
101,
103,
101,
114,
78,
117,
109,
70,
108,
111,
97,
116,
105,
110,
103,
80,
111,
105,
110,
116,
78,
117,
109,
73,
110,
116,
101,
103,
101,
114,
83,
105,
103,
110,
101,
100,
49,
50,
56,
78,
117,
109,
73,
110,
116,
101,
103,
101,
114,
83,
105,
103,
110,
101,
100,
54,
52,
78,
117,
109,
73,
110,
116,
101,
103,
101,
114,
83,
105,
103,
110,
101,
100,
51,
50,
78,
117,
109,
73,
110,
116,
101,
103,
101,
114,
83,
105,
103,
110,
101,
100,
49,
54,
73,
110,
116,
83,
105,
103,
110,
101,
100,
56,
78,
117,
109,
73,
110,
116,
101,
103,
101,
114,
85,
110,
115,
105,
103,
110,
101,
100,
49,
50,
56,
78,
117,
109,
73,
110,
116,
101,
103,
101,
114,
85,
110,
115,
105,
103,
110,
101,
100,
54,
52,
78,
117,
109,
73,
110,
116,
101,
103,
101,
114,
85,
110,
115,
105,
103,
110,
101,
100,
51,
50,
78,
117,
109,
73,
110,
116,
101,
103,
101,
114,
85,
110,
115,
105,
103,
110,
101,
100,
49,
54,
78,
117,
109,
73,
110,
116,
101,
103,
101,
114,
85,
110,
115,
105,
103,
110,
101,
100,
56,
78,
117,
109,
70,
108,
111,
97,
116,
105,
110,
103,
80,
111,
105,
110,
116,
66,
105,
110,
97,
114,
121,
54,
52,
78,
117,
109,
70,
108,
111,
97,
116,
105,
110,
103,
80,
111,
105,
110,
116,
66,
105,
110,
97,
114,
121,
51,
50,
78,
117,
109,
70,
108,
111,
97,
116,
105,
110,
103,
80,
111,
105,
110,
116,
68,
101,
99,
105,
109,
97,
108,
120,
121,
114,
116,
111,
108,
97,
116,
111,
108,
101,
113,
109,
101,
101,
116,
115,
84,
111,
108,
101,
114,
97,
110,
99,
101,
97,
98,
50,
49,
56,
50,
49,
57,
50,
50,
48,
50,
50,
50,
50,
50,
51,
50,
50,
52,
50,
50,
55,
50,
50,
56,
50,
50,
57,
50,
51,
50,
50,
51,
51,
50,
51,
52,
50,
51,
57,
50,
52,
48,
50,
52,
49,
50,
52,
54,
50,
52,
55,
50,
52,
56,
110,
114,
101,
115,
117,
108,
116,
50,
53,
51,
50,
53,
52,
50,
53,
53,
50,
53,
57,
50,
54,
48,
50,
54,
49,
50,
54,
53,
50,
54,
54,
50,
54,
55,
],
lengths: [
Interned(3),
Interned(4),
Interned(4),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Interned(2),
Interned(2),
Interned(7),
Interned(3),
Interned(3),
Interned(13),
Interned(6),
Interned(6),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Interned(4),
Interned(5),
Interned(4),
Interned(5),
Interned(6),
Interned(3),
Interned(3),
Interned(3),
Interned(6),
Interned(6),
Interned(5),
Interned(10),
Interned(10),
Interned(3),
Interned(10),
Interned(3),
Interned(10),
Interned(8),
Interned(15),
Interned(4),
Interned(11),
Interned(3),
Interned(10),
Interned(5),
Interned(7),
Interned(3),
Interned(7),
Interned(6),
Interned(5),
Interned(7),
Interned(10),
Interned(12),
Interned(4),
Interned(4),
Interned(4),
Interned(9),
Interned(8),
Interned(8),
Interned(8),
Interned(7),
Interned(11),
Interned(10),
Interned(10),
Interned(10),
Interned(9),
Interned(8),
Interned(8),
Interned(10),
Interned(10),
Interned(9),
Interned(11),
Interned(12),
Interned(14),
Interned(7),
Interned(10),
Interned(12),
Interned(7),
Interned(10),
Interned(12),
Interned(3),
Interned(4),
Interned(1),
Interned(2),
Interned(3),
Interned(12),
Interned(7),
Interned(3),
Interned(12),
Interned(7),
Interned(5),
Interned(10),
Interned(8),
Interned(20),
Interned(21),
Interned(5),
Interned(5),
Interned(5),
Interned(5),
Interned(5),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(7),
Interned(7),
Interned(7),
Interned(7),
Interned(4),
Interned(11),
Interned(5),
Interned(12),
Interned(5),
Interned(12),
Interned(5),
Interned(12),
Interned(6),
Interned(13),
Interned(4),
Interned(11),
Interned(5),
Interned(12),
Interned(5),
Interned(12),
Interned(5),
Interned(12),
Interned(6),
Interned(13),
Interned(7),
Interned(14),
Interned(5),
Interned(12),
Interned(5),
Interned(12),
Interned(6),
Interned(6),
Interned(18),
Interned(18),
Interned(18),
Interned(3),
Interned(3),
Interned(10),
Interned(7),
Interned(10),
Interned(18),
Interned(18),
Interned(18),
Interned(19),
Interned(17),
Interned(12),
Interned(3),
Interned(7),
Interned(3),
Interned(13),
Interned(3),
Interned(7),
Interned(9),
Interned(3),
Interned(7),
Interned(8),
Interned(3),
Interned(7),
Interned(8),
Interned(3),
Interned(7),
Interned(8),
Interned(3),
Interned(7),
Interned(3),
Interned(7),
Interned(11),
Interned(3),
Interned(7),
Interned(10),
Interned(3),
Interned(7),
Interned(10),
Interned(3),
Interned(7),
Interned(10),
Interned(3),
Interned(7),
Interned(9),
Interned(3),
Interned(13),
Interned(8),
Interned(3),
Interned(13),
Interned(8),
Interned(3),
Interned(13),
Interned(7),
Interned(1),
Interned(1),
Interned(4),
Interned(4),
Interned(2),
Interned(14),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Generated(3),
Generated(3),
Generated(3),
Interned(1),
Generated(3),
Generated(3),
Generated(3),
Interned(1),
Interned(1),
Generated(3),
Generated(3),
Generated(3),
Interned(1),
Interned(1),
Generated(3),
Generated(3),
Generated(3),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Generated(3),
Generated(3),
Generated(3),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Generated(3),
Generated(3),
Generated(3),
Interned(1),
Interned(1),
Interned(1),
Interned(6),
Generated(3),
Generated(3),
Generated(3),
Interned(1),
Interned(1),
Interned(6),
Generated(3),
Generated(3),
Generated(3),
Interned(1),
Interned(1),
Interned(6),
Generated(3),
Generated(3),
Generated(3),
],
offsets: [
0,
3,
7,
11,
14,
17,
20,
23,
26,
29,
31,
33,
40,
43,
46,
59,
65,
71,
74,
77,
80,
83,
86,
90,
95,
99,
104,
110,
113,
116,
119,
125,
131,
136,
146,
156,
159,
169,
172,
182,
190,
205,
209,
220,
223,
233,
238,
245,
248,
255,
261,
266,
273,
283,
295,
299,
303,
307,
316,
324,
332,
340,
347,
358,
368,
378,
388,
397,
405,
413,
423,
433,
442,
453,
465,
479,
486,
496,
508,
515,
525,
537,
540,
544,
545,
547,
550,
562,
569,
572,
584,
591,
596,
606,
614,
634,
655,
660,
665,
670,
675,
680,
686,
692,
698,
704,
710,
716,
722,
728,
734,
740,
746,
752,
759,
766,
773,
780,
784,
795,
800,
812,
817,
829,
834,
846,
852,
865,
869,
880,
885,
897,
902,
914,
919,
931,
937,
950,
957,
971,
976,
988,
993,
1005,
1011,
1017,
1035,
1053,
1071,
1074,
1077,
1087,
1094,
1104,
1122,
1140,
1158,
1177,
1194,
1206,
1209,
1216,
1219,
1232,
1235,
1242,
1251,
1254,
1261,
1269,
1272,
1279,
1287,
1290,
1297,
1305,
1308,
1315,
1318,
1325,
1336,
1339,
1346,
1356,
1359,
1366,
1376,
1379,
1386,
1396,
1399,
1406,
1415,
1418,
1431,
1439,
1442,
1455,
1463,
1466,
1479,
1486,
1487,
1488,
1492,
1496,
1498,
1486,
1486,
1486,
1486,
1512,
1513,
1512,
1513,
1512,
1513,
1486,
1514,
1517,
1520,
1486,
1523,
1526,
1529,
1512,
1513,
1532,
1535,
1538,
1512,
1513,
1541,
1544,
1547,
1512,
1513,
1512,
1513,
1550,
1553,
1556,
1512,
1513,
1512,
1513,
1559,
1562,
1565,
1568,
1512,
1513,
1569,
1575,
1578,
1581,
1512,
1513,
1569,
1584,
1587,
1590,
1512,
1513,
1569,
1593,
1596,
1599,
],
strings: [
"Num",
"I128",
"U128",
"I64",
"U64",
"I32",
"U32",
"I16",
"U16",
"I8",
"U8",
"Integer",
"F64",
"F32",
"FloatingPoint",
"maxF32",
"minF32",
"abs",
"neg",
"add",
"sub",
"mul",
"isLt",
"isLte",
"isGt",
"isGte",
"toFrac",
"sin",
"cos",
"tan",
"isZero",
"isEven",
"isOdd",
"isPositive",
"isNegative",
"rem",
"remChecked",
"div",
"divChecked",
"divTrunc",
"divTruncChecked",
"sqrt",
"sqrtChecked",
"log",
"logChecked",
"round",
"compare",
"pow",
"ceiling",
"powInt",
"floor",
"addWrap",
"addChecked",
"addSaturated",
"atan",
"acos",
"asin",
"Signed128",
"Signed64",
"Signed32",
"Signed16",
"Signed8",
"Unsigned128",
"Unsigned64",
"Unsigned32",
"Unsigned16",
"Unsigned8",
"Binary64",
"Binary32",
"bitwiseAnd",
"bitwiseXor",
"bitwiseOr",
"shiftLeftBy",
"shiftRightBy",
"shiftRightZfBy",
"subWrap",
"subChecked",
"subSaturated",
"mulWrap",
"mulChecked",
"mulSaturated",
"Int",
"Frac",
"e",
"pi",
"tau",
"isMultipleOf",
"Decimal",
"Dec",
"countOneBits",
"absDiff",
"isNaN",
"isInfinite",
"isFinite",
"countLeadingZeroBits",
"countTrailingZeroBits",
"toStr",
"minI8",
"maxI8",
"minU8",
"maxU8",
"minI16",
"maxI16",
"minU16",
"maxU16",
"minI32",
"maxI32",
"minU32",
"maxU32",
"minI64",
"maxI64",
"minU64",
"maxU64",
"minI128",
"maxI128",
"minU128",
"maxU128",
"toI8",
"toI8Checked",
"toI16",
"toI16Checked",
"toI32",
"toI32Checked",
"toI64",
"toI64Checked",
"toI128",
"toI128Checked",
"toU8",
"toU8Checked",
"toU16",
"toU16Checked",
"toU32",
"toU32Checked",
"toU64",
"toU64Checked",
"toU128",
"toU128Checked",
"divCeil",
"divCeilChecked",
"toF32",
"toF32Checked",
"toF64",
"toF64Checked",
"maxF64",
"minF64",
"addCheckedLowlevel",
"subCheckedLowlevel",
"mulCheckedLowlevel",
"min",
"max",
"bitwiseNot",
"intCast",
"isApproxEq",
"bytesToU16Lowlevel",
"bytesToU32Lowlevel",
"bytesToU64Lowlevel",
"bytesToU128Lowlevel",
"divTruncUnchecked",
"remUnchecked",
"Num",
"Integer",
"Num",
"FloatingPoint",
"Num",
"Integer",
"Signed128",
"Num",
"Integer",
"Signed64",
"Num",
"Integer",
"Signed32",
"Num",
"Integer",
"Signed16",
"Int",
"Signed8",
"Num",
"Integer",
"Unsigned128",
"Num",
"Integer",
"Unsigned64",
"Num",
"Integer",
"Unsigned32",
"Num",
"Integer",
"Unsigned16",
"Num",
"Integer",
"Unsigned8",
"Num",
"FloatingPoint",
"Binary64",
"Num",
"FloatingPoint",
"Binary32",
"Num",
"FloatingPoint",
"Decimal",
"x",
"y",
"rtol",
"atol",
"eq",
"meetsTolerance",
"x",
"x",
"x",
"x",
"a",
"b",
"a",
"b",
"a",
"b",
"x",
"218",
"219",
"220",
"x",
"222",
"223",
"224",
"a",
"b",
"227",
"228",
"229",
"a",
"b",
"232",
"233",
"234",
"a",
"b",
"a",
"b",
"239",
"240",
"241",
"a",
"b",
"a",
"b",
"246",
"247",
"248",
"n",
"a",
"b",
"result",
"253",
"254",
"255",
"a",
"b",
"result",
"259",
"260",
"261",
"a",
"b",
"result",
"265",
"266",
"267",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffed25ea10,
head: 000000,
bits: 268,
capacity: 320,
} [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
regions: [
@5228-5246,
@17260-17290,
@17449-17481,
@17291-17319,
@17482-17512,
@17320-17348,
@17513-17543,
@17349-17377,
@17544-17574,
@17431-17447,
@17575-17603,
@17236-17258,
@19085-19119,
@19444-19478,
@17650-17678,
@50191-50197,
@50153-50159,
@28380-28383,
@29876-29879,
@30607-30610,
@31355-31358,
@32110-32113,
@24429-24433,
@25136-25141,
@24797-24801,
@25479-25484,
@26886-26892,
@32557-32560,
@32580-32583,
@32603-32606,
@26299-26305,
@26472-26478,
@26652-26657,
@26768-26778,
@26860-26870,
@36870-36873,
@37044-37054,
@35419-35422,
@35510-35520,
@36220-36228,
@36409-36424,
@33758-33762,
@33840-33851,
@33962-33965,
@34044-34054,
@39372-39377,
@24053-24060,
@39564-39567,
@39420-39427,
@40042-40048,
@39396-39401,
@40761-40768,
@41419-41429,
@41129-41141,
@32675-32679,
@32651-32655,
@32627-32631,
@17074-17089,
@17090-17104,
@17105-17119,
@17120-17134,
@17135-17148,
@17150-17167,
@17168-17184,
@17185-17201,
@17202-17218,
@17219-17234,
@17619-17633,
@17634-17648,
@37417-37427,
@37644-37654,
@37797-37806,
@38416-38427,
@38802-38814,
@39279-39293,
@41612-41619,
@42279-42289,
@41984-41996,
@42472-42479,
@43019-43029,
@42723-42735,
@12895-12926,
@17034-17072,
@23431-23432,
@23530-23532,
@23626-23629,
@37261-37273,
@17605-17618,
@23363-23396,
@40733-40745,
@28877-28884,
@27068-27073,
@27300-27310,
@27486-27494,
@40289-40309,
@40544-40565,
@24006-24011,
@43546-43551,
@43889-43894,
@44249-44254,
@44433-44438,
@44790-44796,
@45145-45151,
@45513-45519,
@45705-45711,
@46073-46079,
@46465-46471,
@46835-46841,
@47031-47037,
@47446-47452,
@47863-47869,
@48242-48248,
@48484-48490,
@48942-48949,
@49413-49420,
@49817-49824,
@50089-50096,
@50467-50471,
@51171-51182,
@50486-50491,
@51218-51230,
@50507-50512,
@51267-51279,
@50528-50533,
@51316-51328,
@50549-50555,
@51365-51378,
@50572-50576,
@51416-51427,
@50591-50596,
@51463-51475,
@50612-50617,
@51512-51524,
@50633-50638,
@51561-51573,
@50654-50660,
@51610-51623,
@35614-35621,
@35707-35721,
@50838-50843,
@51661-51673,
@51020-51025,
@51710-51722,
@50275-50281,
@50228-50234,
@41550-41568,
@42410-42428,
@43150-43168,
@32285-32288,
@32494-32497,
@37991-38001,
@24027-24034,
@26019-26029,
…,
…,
…,
…,
@36598-36615,
@37223-37235,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
@26033-26034,
@26036-26037,
@26039-26076,
@26039-26076,
@26084-26086,
@26110-26124,
@26482-26483,
@26661-26662,
@26782-26783,
@26874-26875,
@28888-28889,
@28891-28892,
@32292-32293,
@32295-32296,
@32501-32502,
@32504-32505,
@33855-33856,
…,
…,
…,
@34058-34059,
…,
…,
…,
@35524-35525,
@35527-35528,
…,
…,
…,
@35725-35726,
@35728-35729,
…,
…,
…,
@36232-36233,
@36235-36236,
@36428-36429,
@36431-36432,
…,
…,
…,
@36877-36878,
@36880-36881,
@37058-37059,
@37061-37062,
…,
…,
…,
@38005-38006,
@41433-41434,
@41436-41437,
@41445-41451,
…,
…,
…,
@42293-42294,
@42296-42297,
@42305-42311,
…,
…,
…,
@43033-43034,
@43036-43037,
@43045-43051,
…,
…,
…,
],
home: Num,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`Num.Num`,
`Num.Int`,
`Num.Frac`,
`Num.Integer`,
`Num.FloatingPoint`,
`Num.I128`,
`Num.I64`,
`Num.I32`,
`Num.I16`,
`Num.I8`,
`Num.U128`,
`Num.U64`,
`Num.U32`,
`Num.U16`,
`Num.U8`,
`Num.Signed128`,
`Num.Signed64`,
`Num.Signed32`,
`Num.Signed16`,
`Num.Signed8`,
`Num.Unsigned128`,
`Num.Unsigned64`,
`Num.Unsigned32`,
`Num.Unsigned16`,
`Num.Unsigned8`,
`Num.Dec`,
`Num.F64`,
`Num.F32`,
`Num.Decimal`,
`Num.Binary32`,
`Num.Binary64`,
`Num.e`,
`Num.pi`,
`Num.tau`,
`Num.abs`,
`Num.absDiff`,
`Num.neg`,
`Num.add`,
`Num.sub`,
`Num.mul`,
`Num.min`,
`Num.max`,
`Num.isLt`,
`Num.isLte`,
`Num.isGt`,
`Num.isGte`,
`Num.isApproxEq`,
`Num.sin`,
`Num.cos`,
`Num.tan`,
`Num.atan`,
`Num.acos`,
`Num.asin`,
`Num.isZero`,
`Num.isEven`,
`Num.isOdd`,
`Num.toFrac`,
`Num.isPositive`,
`Num.isNegative`,
`Num.isNaN`,
`Num.isInfinite`,
`Num.isFinite`,
`Num.rem`,
`Num.remChecked`,
`Num.div`,
`Num.divChecked`,
`Num.sqrt`,
`Num.sqrtChecked`,
`Num.log`,
`Num.logChecked`,
`Num.round`,
`Num.ceiling`,
`Num.floor`,
`Num.compare`,
`Num.pow`,
`Num.powInt`,
`Num.countLeadingZeroBits`,
`Num.countTrailingZeroBits`,
`Num.countOneBits`,
`Num.addWrap`,
`Num.addChecked`,
`Num.addSaturated`,
`Num.bitwiseAnd`,
`Num.bitwiseXor`,
`Num.bitwiseOr`,
`Num.bitwiseNot`,
`Num.shiftLeftBy`,
`Num.shiftRightBy`,
`Num.shiftRightZfBy`,
`Num.subWrap`,
`Num.subChecked`,
`Num.subSaturated`,
`Num.mulWrap`,
`Num.mulSaturated`,
`Num.mulChecked`,
`Num.intCast`,
`Num.divCeil`,
`Num.divCeilChecked`,
`Num.divTrunc`,
`Num.divTruncChecked`,
`Num.toStr`,
`Num.isMultipleOf`,
`Num.minI8`,
`Num.maxI8`,
`Num.minU8`,
`Num.maxU8`,
`Num.minI16`,
`Num.maxI16`,
`Num.minU16`,
`Num.maxU16`,
`Num.minI32`,
`Num.maxI32`,
`Num.minU32`,
`Num.maxU32`,
`Num.minI64`,
`Num.maxI64`,
`Num.minU64`,
`Num.maxU64`,
`Num.minI128`,
`Num.maxI128`,
`Num.minU128`,
`Num.maxU128`,
`Num.minF32`,
`Num.maxF32`,
`Num.minF64`,
`Num.maxF64`,
`Num.toI8`,
`Num.toI8Checked`,
`Num.toI16`,
`Num.toI16Checked`,
`Num.toI32`,
`Num.toI32Checked`,
`Num.toI64`,
`Num.toI64Checked`,
`Num.toI128`,
`Num.toI128Checked`,
`Num.toU8`,
`Num.toU8Checked`,
`Num.toU16`,
`Num.toU16Checked`,
`Num.toU32`,
`Num.toU32Checked`,
`Num.toU64`,
`Num.toU64Checked`,
`Num.toU128`,
`Num.toU128Checked`,
`Num.toF32`,
`Num.toF32Checked`,
`Num.toF64`,
`Num.toF64Checked`,
],
},
},
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Creates a custom encoder from a given function.\n\n```\nexpect\n # Appends the byte 42\n customEncoder = Encode.custom (\\bytes, _fmt -> List.append bytes 42)\n\n actual = Encode.appendWith [] customEncoder Core.json\n expected = [42] # Expected result is a list with a single byte, 42\n\n actual == expected\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Appends the encoded representation of a value to an existing list of bytes.\n\n```\nexpect\n actual = Encode.append [] { foo: 43 } Core.json\n expected = Str.toUtf8 \"\"\"{\"foo\":43}\"\"\"\n\n actual == expected\n```\n",
)
docs>>
<<docs:
Some(
"Encodes a value to a list of bytes (`List U8`) according to the specified format.\n\n```\nexpect\n fooRec = { foo: 42 }\n\n actual = Encode.toBytes fooRec Core.json\n expected = Str.toUtf8 \"\"\"{\"foo\":42}\"\"\"\n\n actual == expected\n```\n",
)
docs>>
adding docs for "Encode.roc",
docs ModuleDocumentation {
name: "Encode",
entries: [
DocDef(
DocDef {
name: "Encoder",
symbol: `Encode.Encoder`,
type_vars: [
"fmt",
],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "Encoding",
symbol: `Encode.Encoding`,
type_vars: [],
type_annotation: Ability {
members: [
AbilityMember {
name: "toEncoder",
type_annotation: Function {
args: [
BoundVariable(
"val",
),
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"val",
[
Apply {
name: "Encoding",
parts: [],
},
],
),
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "EncoderFormatting",
symbol: `Encode.EncoderFormatting`,
type_vars: [],
type_annotation: Ability {
members: [
AbilityMember {
name: "u8",
type_annotation: Function {
args: [
Apply {
name: "U8",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u16",
type_annotation: Function {
args: [
Apply {
name: "U16",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u32",
type_annotation: Function {
args: [
Apply {
name: "U32",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u64",
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u128",
type_annotation: Function {
args: [
Apply {
name: "U128",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i8",
type_annotation: Function {
args: [
Apply {
name: "I8",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i16",
type_annotation: Function {
args: [
Apply {
name: "I16",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i32",
type_annotation: Function {
args: [
Apply {
name: "I32",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i64",
type_annotation: Function {
args: [
Apply {
name: "I64",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i128",
type_annotation: Function {
args: [
Apply {
name: "I128",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "f32",
type_annotation: Function {
args: [
Apply {
name: "F32",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "f64",
type_annotation: Function {
args: [
Apply {
name: "F64",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "dec",
type_annotation: Function {
args: [
Apply {
name: "Dec",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "bool",
type_annotation: Function {
args: [
Apply {
name: "Bool",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "string",
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "list",
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Function {
args: [
BoundVariable(
"elem",
),
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "record",
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Record {
fields: [
RecordField {
name: "key",
type_annotation: Apply {
name: "Str",
parts: [],
},
},
RecordField {
name: "value",
type_annotation: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
],
extension: NoTypeAnn,
},
],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "tuple",
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "tag",
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "List",
parts: [
Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
],
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "EncoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "custom",
symbol: `Encode.custom`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
BoundVariable(
"fmt",
),
],
output: Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
},
],
output: Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
},
implements: [
ImplementsClause {
name: "fmt",
abilities: [
Apply {
name: "EncoderFormatting",
parts: [],
},
],
},
],
},
docs: Some(
"Creates a custom encoder from a given function.\n\n```\nexpect\n # Appends the byte 42\n customEncoder = Encode.custom (\\bytes, _fmt -> List.append bytes 42)\n\n actual = Encode.appendWith [] customEncoder Core.json\n expected = [42] # Expected result is a list with a single byte, 42\n\n actual == expected\n```\n",
),
},
),
DocDef(
DocDef {
name: "appendWith",
symbol: `Encode.appendWith`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
Apply {
name: "Encoder",
parts: [
BoundVariable(
"fmt",
),
],
},
BoundVariable(
"fmt",
),
],
output: Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
},
implements: [
ImplementsClause {
name: "fmt",
abilities: [
Apply {
name: "EncoderFormatting",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "append",
symbol: `Encode.append`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
BoundVariable(
"val",
),
BoundVariable(
"fmt",
),
],
output: Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
},
implements: [
ImplementsClause {
name: "val",
abilities: [
Apply {
name: "Encoding",
parts: [],
},
],
},
ImplementsClause {
name: "fmt",
abilities: [
Apply {
name: "EncoderFormatting",
parts: [],
},
],
},
],
},
docs: Some(
"Appends the encoded representation of a value to an existing list of bytes.\n\n```\nexpect\n actual = Encode.append [] { foo: 43 } Core.json\n expected = Str.toUtf8 \"\"\"{\"foo\":43}\"\"\"\n\n actual == expected\n```\n",
),
},
),
DocDef(
DocDef {
name: "toBytes",
symbol: `Encode.toBytes`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"val",
),
BoundVariable(
"fmt",
),
],
output: Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
},
implements: [
ImplementsClause {
name: "val",
abilities: [
Apply {
name: "Encoding",
parts: [],
},
],
},
ImplementsClause {
name: "fmt",
abilities: [
Apply {
name: "EncoderFormatting",
parts: [],
},
],
},
],
},
docs: Some(
"Encodes a value to a list of bytes (`List U8`) according to the specified format.\n\n```\nexpect\n fooRec = { foo: 42 }\n\n actual = Encode.toBytes fooRec Core.json\n expected = Str.toUtf8 \"\"\"{\"foo\":42}\"\"\"\n\n actual == expected\n```\n",
),
},
),
],
scope: Scope {
aliases: VecMap {
keys: [
`Num.Binary32`,
`Num.F32`,
`Num.FloatingPoint`,
`Num.Unsigned16`,
`Num.U16`,
`Bool.Bool`,
`Num.U64`,
`Num.Binary64`,
`Num.Int`,
`Num.Signed128`,
`Num.Unsigned8`,
`Num.Frac`,
`Num.U32`,
`Num.Signed64`,
`Num.Signed8`,
`Num.I64`,
`Num.U8`,
`Num.I16`,
`Num.Unsigned128`,
`Num.I8`,
`Num.Num`,
`Num.Decimal`,
`Num.Unsigned32`,
`Num.Signed32`,
`Num.Integer`,
`Num.I128`,
`Num.U128`,
`Num.I32`,
`Num.Signed16`,
`Num.Unsigned64`,
`Num.F64`,
`Num.Dec`,
`Encode.Encoder`,
],
values: [
Alias {
region: @17634-17642,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19444-19447,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17650-17669,
type_variables: [
@17664-17669 AliasVar {
name: 'range',
var: 67,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <67>,
kind: Opaque,
},
Alias {
region: @17202-17212,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17544-17547,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @1780-1784,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: ['False', 'True'],
kind: Opaque,
},
Alias {
region: @17482-17485,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17619-17627,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @12895-12904,
type_variables: [
@12899-12904 AliasVar {
name: 'range',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` <64>[ but actually <64> ])[ but actually (Alias `Num.Integer` <64>[ but actually <64> ]) ]),
kind: Structural,
},
Alias {
region: @17074-17083,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17219-17228,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17034-17044,
type_variables: [
@17039-17044 AliasVar {
name: 'range',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` <65>[ but actually <65> ])[ but actually (Alias `Num.FloatingPoint` <65>[ but actually <65> ]) ]),
kind: Structural,
},
Alias {
region: @17513-17516,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17090-17098,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17135-17142,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17291-17294,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17575-17577,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17349-17352,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17150-17161,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17431-17433,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Int` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ]) ]) ]),
kind: Structural,
},
Alias {
region: @5228-5237,
type_variables: [
@5232-5237 AliasVar {
name: 'range',
var: 63,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <63>,
kind: Opaque,
},
Alias {
region: @17605-17612,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17185-17195,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17105-17113,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17236-17249,
type_variables: [
@17244-17249 AliasVar {
name: 'range',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <66>,
kind: Opaque,
},
Alias {
region: @17260-17264,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17449-17453,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17320-17323,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17120-17128,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17168-17178,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19085-19088,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @23363-23366,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @734-745,
type_variables: [
@742-745 AliasVar {
name: 'fmt',
var: 63,
opt_bound_abilities: Some(
AbilitySet(
[
`Encode.EncoderFormatting`,
],
),
),
},
],
lambda_set_variables: [
LambdaSet(
<64>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn((`List.List` @754-756 (DelayedAlias `Num.U8`)), <63> |<64>| -> (`List.List` @770-772 (DelayedAlias `Num.U8`))),
kind: Opaque,
},
],
},
abilities_store: IAbilitiesStore {
members_of_ability: {
`Bool.Eq`: [
`Bool.isEq`,
],
`Encode.Encoding`: [
`Encode.toEncoder`,
],
`Encode.EncoderFormatting`: [
`Encode.u8`,
`Encode.u16`,
`Encode.u32`,
`Encode.u64`,
`Encode.u128`,
`Encode.i8`,
`Encode.i16`,
`Encode.i32`,
`Encode.i64`,
`Encode.i128`,
`Encode.f32`,
`Encode.f64`,
`Encode.dec`,
`Encode.bool`,
`Encode.string`,
`Encode.list`,
`Encode.record`,
`Encode.tuple`,
`Encode.tag`,
],
},
specialization_to_root: {
`Bool.boolIsEq`: ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
},
},
ability_members: {
`Bool.isEq`: AbilityMemberData {
parent_ability: `Bool.Eq`,
region: @1635-1639,
typ: Imported,
},
`Encode.i128`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1576-1580,
typ: Local {
signature_var: 109,
signature: Fn((DelayedAlias `Num.I128`) |Uls(106:`Encode.i128`:1)| -> (DelayedAlias `Encode.Encoder` @1599-1602 OptAbleType { typ: <106>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(106:`Encode.i128`:2))),
variables: MemberVariables {
able_vars: [
106,
],
rigid_vars: [
107,
108,
],
flex_vars: [],
},
},
},
`Encode.u32`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1100-1103,
typ: Local {
signature_var: 81,
signature: Fn((DelayedAlias `Num.U32`) |Uls(78:`Encode.u32`:1)| -> (DelayedAlias `Encode.Encoder` @1121-1124 OptAbleType { typ: <78>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(78:`Encode.u32`:2))),
variables: MemberVariables {
able_vars: [
78,
],
rigid_vars: [
79,
80,
],
flex_vars: [],
},
},
},
`Encode.bool`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1850-1854,
typ: Local {
signature_var: 125,
signature: Fn((DelayedAlias `Bool.Bool`) |Uls(122:`Encode.bool`:1)| -> (DelayedAlias `Encode.Encoder` @1873-1876 OptAbleType { typ: <122>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(122:`Encode.bool`:2))),
variables: MemberVariables {
able_vars: [
122,
],
rigid_vars: [
123,
124,
],
flex_vars: [],
},
},
},
`Encode.u128`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1236-1240,
typ: Local {
signature_var: 89,
signature: Fn((DelayedAlias `Num.U128`) |Uls(86:`Encode.u128`:1)| -> (DelayedAlias `Encode.Encoder` @1259-1262 OptAbleType { typ: <86>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(86:`Encode.u128`:2))),
variables: MemberVariables {
able_vars: [
86,
],
rigid_vars: [
87,
88,
],
flex_vars: [],
},
},
},
`Encode.tag`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @2281-2284,
typ: Local {
signature_var: 151,
signature: Fn((`Str.Str`), (`List.List` @2298-2309 (DelayedAlias `Encode.Encoder` @2306-2309 OptAbleType { typ: <147>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(147:`Encode.tag`:2))) |Uls(147:`Encode.tag`:1)| -> (DelayedAlias `Encode.Encoder` @2322-2325 OptAbleType { typ: <147>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(147:`Encode.tag`:3))),
variables: MemberVariables {
able_vars: [
147,
],
rigid_vars: [
148,
149,
150,
],
flex_vars: [],
},
},
},
`Encode.list`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1991-1995,
typ: Local {
signature_var: 136,
signature: Fn((`List.List` @2003-2007 <131>), Fn(<131> |Uls(130:`Encode.list`:2)| -> (DelayedAlias `Encode.Encoder` @2026-2029 OptAbleType { typ: <130>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(130:`Encode.list`:3))) |Uls(130:`Encode.list`:1)| -> (DelayedAlias `Encode.Encoder` @2042-2045 OptAbleType { typ: <130>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(130:`Encode.list`:4))),
variables: MemberVariables {
able_vars: [
130,
],
rigid_vars: [
131,
132,
133,
134,
135,
],
flex_vars: [],
},
},
},
`Encode.toEncoder`: AbilityMemberData {
parent_ability: `Encode.Encoding`,
region: @837-846,
typ: Local {
signature_var: 69,
signature: Fn(<65> |Uls(65:`Encode.toEncoder`:1)| -> (DelayedAlias `Encode.Encoder` @864-867 OptAbleType { typ: <66>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(65:`Encode.toEncoder`:2))),
variables: MemberVariables {
able_vars: [
65,
66,
],
rigid_vars: [
67,
68,
],
flex_vars: [],
},
},
},
`Encode.string`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1920-1926,
typ: Local {
signature_var: 129,
signature: Fn((`Str.Str`) |Uls(126:`Encode.string`:1)| -> (DelayedAlias `Encode.Encoder` @1944-1947 OptAbleType { typ: <126>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(126:`Encode.string`:2))),
variables: MemberVariables {
able_vars: [
126,
],
rigid_vars: [
127,
128,
],
flex_vars: [],
},
},
},
`Encode.f32`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1646-1649,
typ: Local {
signature_var: 113,
signature: Fn((DelayedAlias `Num.F32`) |Uls(110:`Encode.f32`:1)| -> (DelayedAlias `Encode.Encoder` @1667-1670 OptAbleType { typ: <110>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(110:`Encode.f32`:2))),
variables: MemberVariables {
able_vars: [
110,
],
rigid_vars: [
111,
112,
],
flex_vars: [],
},
},
},
`Encode.f64`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1714-1717,
typ: Local {
signature_var: 117,
signature: Fn((DelayedAlias `Num.F64`) |Uls(114:`Encode.f64`:1)| -> (DelayedAlias `Encode.Encoder` @1735-1738 OptAbleType { typ: <114>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(114:`Encode.f64`:2))),
variables: MemberVariables {
able_vars: [
114,
],
rigid_vars: [
115,
116,
],
flex_vars: [],
},
},
},
`Encode.i64`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1508-1511,
typ: Local {
signature_var: 105,
signature: Fn((DelayedAlias `Num.I64`) |Uls(102:`Encode.i64`:1)| -> (DelayedAlias `Encode.Encoder` @1529-1532 OptAbleType { typ: <102>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(102:`Encode.i64`:2))),
variables: MemberVariables {
able_vars: [
102,
],
rigid_vars: [
103,
104,
],
flex_vars: [],
},
},
},
`Encode.i32`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1440-1443,
typ: Local {
signature_var: 101,
signature: Fn((DelayedAlias `Num.I32`) |Uls(98:`Encode.i32`:1)| -> (DelayedAlias `Encode.Encoder` @1461-1464 OptAbleType { typ: <98>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(98:`Encode.i32`:2))),
variables: MemberVariables {
able_vars: [
98,
],
rigid_vars: [
99,
100,
],
flex_vars: [],
},
},
},
`Encode.i8`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1306-1308,
typ: Local {
signature_var: 93,
signature: Fn((DelayedAlias `Num.I8`) |Uls(90:`Encode.i8`:1)| -> (DelayedAlias `Encode.Encoder` @1325-1328 OptAbleType { typ: <90>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(90:`Encode.i8`:2))),
variables: MemberVariables {
able_vars: [
90,
],
rigid_vars: [
91,
92,
],
flex_vars: [],
},
},
},
`Encode.dec`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1782-1785,
typ: Local {
signature_var: 121,
signature: Fn((DelayedAlias `Num.Dec`) |Uls(118:`Encode.dec`:1)| -> (DelayedAlias `Encode.Encoder` @1803-1806 OptAbleType { typ: <118>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(118:`Encode.dec`:2))),
variables: MemberVariables {
able_vars: [
118,
],
rigid_vars: [
119,
120,
],
flex_vars: [],
},
},
},
`Encode.record`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @2089-2095,
typ: Local {
signature_var: 141,
signature: Fn((`List.List` @2103-2137 { 'value' : RigidRequired((DelayedAlias `Encode.Encoder` @2132-2135 OptAbleType { typ: <137>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(137:`Encode.record`:2)))'key' : RigidRequired((`Str.Str`)), }) |Uls(137:`Encode.record`:1)| -> (DelayedAlias `Encode.Encoder` @2149-2152 OptAbleType { typ: <137>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(137:`Encode.record`:3))),
variables: MemberVariables {
able_vars: [
137,
],
rigid_vars: [
138,
139,
140,
],
flex_vars: [],
},
},
},
`Encode.tuple`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @2196-2201,
typ: Local {
signature_var: 146,
signature: Fn((`List.List` @2210-2221 (DelayedAlias `Encode.Encoder` @2218-2221 OptAbleType { typ: <142>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(142:`Encode.tuple`:2))) |Uls(142:`Encode.tuple`:1)| -> (DelayedAlias `Encode.Encoder` @2234-2237 OptAbleType { typ: <142>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(142:`Encode.tuple`:3))),
variables: MemberVariables {
able_vars: [
142,
],
rigid_vars: [
143,
144,
145,
],
flex_vars: [],
},
},
},
`Encode.i16`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1372-1375,
typ: Local {
signature_var: 97,
signature: Fn((DelayedAlias `Num.I16`) |Uls(94:`Encode.i16`:1)| -> (DelayedAlias `Encode.Encoder` @1393-1396 OptAbleType { typ: <94>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(94:`Encode.i16`:2))),
variables: MemberVariables {
able_vars: [
94,
],
rigid_vars: [
95,
96,
],
flex_vars: [],
},
},
},
`Encode.u16`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1032-1035,
typ: Local {
signature_var: 77,
signature: Fn((DelayedAlias `Num.U16`) |Uls(74:`Encode.u16`:1)| -> (DelayedAlias `Encode.Encoder` @1053-1056 OptAbleType { typ: <74>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(74:`Encode.u16`:2))),
variables: MemberVariables {
able_vars: [
74,
],
rigid_vars: [
75,
76,
],
flex_vars: [],
},
},
},
`Encode.u64`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1168-1171,
typ: Local {
signature_var: 85,
signature: Fn((DelayedAlias `Num.U64`) |Uls(82:`Encode.u64`:1)| -> (DelayedAlias `Encode.Encoder` @1189-1192 OptAbleType { typ: <82>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(82:`Encode.u64`:2))),
variables: MemberVariables {
able_vars: [
82,
],
rigid_vars: [
83,
84,
],
flex_vars: [],
},
},
},
`Encode.u8`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @966-968,
typ: Local {
signature_var: 73,
signature: Fn((DelayedAlias `Num.U8`) |Uls(70:`Encode.u8`:1)| -> (DelayedAlias `Encode.Encoder` @985-988 OptAbleType { typ: <70>, opt_abilities: Some(AbilitySet([`Encode.EncoderFormatting`])) } α@Uls(70:`Encode.u8`:2))),
variables: MemberVariables {
able_vars: [
70,
],
rigid_vars: [
71,
72,
],
flex_vars: [],
},
},
},
},
declared_implementations: {
ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
}: Impl(
`Bool.boolIsEq`,
),
},
specializations: {},
next_specialization_id: 3,
resolved_specializations: {},
},
home: Encode,
exposed_ident_count: 27,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "U8",
},
),
`Num.U8`,
@484-486,
),
(
Ident(
IdentStr {
string: "F64",
},
),
`Num.F64`,
@671-674,
),
(
Ident(
IdentStr {
string: "I128",
},
),
`Num.I128`,
@636-640,
),
(
Ident(
IdentStr {
string: "Dec",
},
),
`Num.Dec`,
@688-691,
),
(
Ident(
IdentStr {
string: "U64",
},
),
`Num.U64`,
@534-537,
),
(
Ident(
IdentStr {
string: "I64",
},
),
`Num.I64`,
@619-622,
),
(
Ident(
IdentStr {
string: "F32",
},
),
`Num.F32`,
@654-657,
),
(
Ident(
IdentStr {
string: "U16",
},
),
`Num.U16`,
@500-503,
),
(
Ident(
IdentStr {
string: "I32",
},
),
`Num.I32`,
@602-605,
),
(
Ident(
IdentStr {
string: "U32",
},
),
`Num.U32`,
@517-520,
),
(
Ident(
IdentStr {
string: "Bool",
},
),
`Bool.Bool`,
@719-723,
),
(
Ident(
IdentStr {
string: "I8",
},
),
`Num.I8`,
@569-571,
),
(
Ident(
IdentStr {
string: "I16",
},
),
`Num.I16`,
@585-588,
),
(
Ident(
IdentStr {
string: "U128",
},
),
`Num.U128`,
@551-555,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
69,
110,
99,
111,
100,
101,
114,
69,
110,
99,
111,
100,
105,
110,
103,
116,
111,
69,
110,
99,
111,
100,
101,
114,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
117,
56,
117,
49,
54,
117,
51,
50,
117,
54,
52,
117,
49,
50,
56,
105,
56,
105,
49,
54,
105,
51,
50,
105,
54,
52,
105,
49,
50,
56,
102,
51,
50,
102,
54,
52,
100,
101,
99,
98,
111,
111,
108,
115,
116,
114,
105,
110,
103,
108,
105,
115,
116,
114,
101,
99,
111,
114,
100,
116,
117,
112,
108,
101,
116,
97,
103,
99,
117,
115,
116,
111,
109,
97,
112,
112,
101,
110,
100,
87,
105,
116,
104,
97,
112,
112,
101,
110,
100,
116,
111,
66,
121,
116,
101,
115,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
76,
105,
115,
116,
85,
56,
76,
105,
115,
116,
85,
56,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
85,
56,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
85,
49,
54,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
85,
51,
50,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
85,
54,
52,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
85,
49,
50,
56,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
73,
56,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
73,
49,
54,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
73,
51,
50,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
73,
54,
52,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
73,
49,
50,
56,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
70,
51,
50,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
70,
54,
52,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
68,
101,
99,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
66,
111,
111,
108,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
83,
116,
114,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
69,
110,
99,
111,
100,
101,
114,
76,
105,
115,
116,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
76,
105,
115,
116,
83,
116,
114,
69,
110,
99,
111,
100,
101,
114,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
76,
105,
115,
116,
69,
110,
99,
111,
100,
101,
114,
69,
110,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
69,
110,
99,
111,
100,
101,
114,
76,
105,
115,
116,
69,
110,
99,
111,
100,
101,
114,
83,
116,
114,
101,
110,
99,
111,
100,
101,
114,
108,
115,
116,
100,
111,
69,
110,
99,
111,
100,
105,
110,
103,
102,
109,
116,
118,
97,
108,
],
lengths: [
Interned(7),
Interned(8),
Interned(9),
Interned(17),
Interned(2),
Interned(3),
Interned(3),
Interned(3),
Interned(4),
Interned(2),
Interned(3),
Interned(3),
Interned(3),
Interned(4),
Interned(3),
Interned(3),
Interned(3),
Interned(4),
Interned(6),
Interned(4),
Interned(6),
Interned(5),
Interned(3),
Interned(6),
Interned(10),
Interned(6),
Interned(7),
Interned(17),
Interned(4),
Interned(2),
Interned(4),
Interned(2),
Interned(17),
Interned(8),
Interned(7),
Interned(17),
Interned(7),
Interned(2),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(4),
Interned(17),
Interned(7),
Interned(2),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(4),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(4),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(7),
Interned(4),
Interned(17),
Interned(7),
Interned(4),
Interned(3),
Interned(7),
Interned(17),
Interned(7),
Interned(4),
Interned(7),
Interned(17),
Interned(7),
Interned(4),
Interned(7),
Interned(3),
Interned(7),
Interned(3),
Interned(10),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
],
offsets: [
0,
7,
15,
24,
41,
43,
46,
49,
52,
56,
58,
61,
64,
67,
71,
74,
77,
80,
84,
90,
94,
100,
105,
108,
114,
124,
130,
137,
154,
158,
160,
164,
166,
183,
191,
198,
215,
222,
224,
241,
248,
251,
268,
275,
278,
295,
302,
305,
322,
329,
333,
350,
357,
359,
376,
383,
386,
403,
410,
413,
430,
437,
440,
457,
464,
468,
485,
492,
495,
512,
519,
522,
539,
546,
549,
566,
573,
577,
594,
601,
604,
621,
628,
635,
639,
656,
663,
667,
670,
677,
694,
701,
705,
712,
729,
736,
740,
747,
750,
757,
760,
770,
757,
773,
770,
773,
770,
],
strings: [
"Encoder",
"Encoding",
"toEncoder",
"EncoderFormatting",
"u8",
"u16",
"u32",
"u64",
"u128",
"i8",
"i16",
"i32",
"i64",
"i128",
"f32",
"f64",
"dec",
"bool",
"string",
"list",
"record",
"tuple",
"tag",
"custom",
"appendWith",
"append",
"toBytes",
"EncoderFormatting",
"List",
"U8",
"List",
"U8",
"EncoderFormatting",
"Encoding",
"Encoder",
"EncoderFormatting",
"Encoder",
"U8",
"EncoderFormatting",
"Encoder",
"U16",
"EncoderFormatting",
"Encoder",
"U32",
"EncoderFormatting",
"Encoder",
"U64",
"EncoderFormatting",
"Encoder",
"U128",
"EncoderFormatting",
"Encoder",
"I8",
"EncoderFormatting",
"Encoder",
"I16",
"EncoderFormatting",
"Encoder",
"I32",
"EncoderFormatting",
"Encoder",
"I64",
"EncoderFormatting",
"Encoder",
"I128",
"EncoderFormatting",
"Encoder",
"F32",
"EncoderFormatting",
"Encoder",
"F64",
"EncoderFormatting",
"Encoder",
"Dec",
"EncoderFormatting",
"Encoder",
"Bool",
"EncoderFormatting",
"Encoder",
"Str",
"EncoderFormatting",
"Encoder",
"Encoder",
"List",
"EncoderFormatting",
"Encoder",
"List",
"Str",
"Encoder",
"EncoderFormatting",
"Encoder",
"List",
"Encoder",
"EncoderFormatting",
"Encoder",
"List",
"Encoder",
"Str",
"encoder",
"lst",
"doEncoding",
"fmt",
"lst",
"val",
"fmt",
"val",
"fmt",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffec5e3d50,
head: 000000,
bits: 107,
capacity: 128,
} [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
regions: [
@734-811,
@813-821,
@837-846,
@933-950,
@966-968,
@1032-1035,
@1100-1103,
@1168-1171,
@1236-1240,
@1306-1308,
@1372-1375,
@1440-1443,
@1508-1511,
@1576-1580,
@1646-1649,
@1714-1717,
@1782-1785,
@1850-1854,
@1920-1926,
@1991-1995,
@2089-2095,
@2196-2201,
@2281-2284,
@2805-2811,
@2933-2943,
@3338-3344,
@3761-3768,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
@2815-2822,
@2947-2950,
@2961-2971,
@2973-2976,
@3348-3351,
@3353-3356,
@3358-3361,
@3772-3775,
@3777-3780,
],
home: Encode,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`Encode.Encoder`,
`Encode.Encoding`,
`Encode.toEncoder`,
`Encode.EncoderFormatting`,
`Encode.u8`,
`Encode.u16`,
`Encode.u32`,
`Encode.u64`,
`Encode.u128`,
`Encode.i8`,
`Encode.i16`,
`Encode.i32`,
`Encode.i64`,
`Encode.i128`,
`Encode.f32`,
`Encode.f64`,
`Encode.dec`,
`Encode.bool`,
`Encode.string`,
`Encode.list`,
`Encode.record`,
`Encode.tag`,
`Encode.tuple`,
`Encode.custom`,
`Encode.appendWith`,
`Encode.append`,
`Encode.toBytes`,
],
},
},
<<docs:
Some(
" Check if the list is empty.\n```\nList.isEmpty [1, 2, 3]\n\nList.isEmpty []\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns an element from a list at the given index.\n\nReturns `Err OutOfBounds` if the given index exceeds the List's length\n```\nexpect List.get [100, 200, 300] 1 == Ok 200\nexpect List.get [100, 200, 300] 5 == Err OutOfBounds\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Replaces the element at the given index with a replacement.\n```\nList.set [\"a\", \"b\", \"c\"] 1 \"B\"\n```\nIf the given index is outside the bounds of the list, returns the original\nlist unmodified.\n\nTo drop the element at a given index, instead of replacing it, see [List.dropAt].\n",
)
docs>>
<<docs:
Some(
"Updates the element at the given index with the given function.\n```\nList.update [1, 2, 3] 1 (\\x -> x + 1)\n```\nIf the given index is outside the bounds of the list, returns the original\nlist unmodified.\n\nTo replace the element at a given index, instead of updating based on the current value,\nsee [List.set] and [List.replace]\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Add a single element to the end of a list.\n```\nList.append [1, 2, 3] 4\n\n[0, 1, 2]\n |> List.append 3\n```\n",
)
docs>>
<<docs:
Some(
"If the given [Result] is `Ok`, add it to the end of a list.\nOtherwise, return the list unmodified.\n\n```\nList.appendIfOk [1, 2, 3] (Ok 4)\n\n[0, 1, 2]\n |> List.appendIfOk (Err 3)\n```\n",
)
docs>>
<<docs:
Some(
"Writes the element after the current last element unconditionally.\nIn other words, it is assumed that\n\n- the list is owned (i.e. can be updated in-place\n- the list has at least one element of spare capacity\n",
)
docs>>
<<docs:
Some(
"Add a single element to the beginning of a list.\n```\nList.prepend [1, 2, 3] 0\n\n[2, 3, 4]\n |> List.prepend 1\n```\n",
)
docs>>
<<docs:
Some(
"If the given [Result] is `Ok`, add it to the beginning of a list.\nOtherwise, return the list unmodified.\n\n```\nList.prepend [1, 2, 3] (Ok 0)\n\n[2, 3, 4]\n |> List.prepend (Err 1)\n```\n",
)
docs>>
<<docs:
Some(
"Returns the length of the list - the number of elements it contains.\n\nOne [List] can store up to 2,147,483,648 elements (just over 2 billion), which\nis exactly equal to the highest valid #I32 value. This means the #U32 this function\nreturns can always be safely converted to an #I32 without losing any data.\n",
)
docs>>
<<docs:
Some(
"Create a list with space for at least capacity elements\n",
)
docs>>
<<docs:
Some(
"Enlarge the list for at least capacity additional elements\n",
)
docs>>
<<docs:
Some(
"Shrink the memory footprint of a list such that it's capacity and length are equal.\nNote: This will also convert seamless slices to regular lists.\n",
)
docs>>
<<docs:
Some(
"Put two lists together.\n```\nList.concat [1, 2, 3] [4, 5]\n\n[0, 1, 2]\n |> List.concat [3, 4]\n```\n",
)
docs>>
<<docs:
Some(
"Returns the last element in the list, or `ListWasEmpty` if it was empty.\n```\nexpect List.last [1, 2, 3] == Ok 3\nexpect List.last [] == Err ListWasEmpty\n```\n",
)
docs>>
<<docs:
Some(
"A list with a single element in it.\n\nThis is useful in pipelines, like so:\n```\nwebsites =\n Str.concat domain \".com\"\n |> List.single\n```\n",
)
docs>>
<<docs:
Some(
"Returns a list with the given length, where every element is the given value.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns the list with its elements reversed.\n```\nexpect List.reverse [1, 2, 3] == [3, 2, 1]\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Join the given lists together into one list.\n```\nexpect List.join [[1], [2, 3], [], [4, 5]] == [1, 2, 3, 4, 5]\nexpect List.join [[], []] == []\nexpect List.join [] == []\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Build a value using each element in the list.\n\nStarting with a given `state` value, this walks through each element in the\nlist from first to last, running a given `step` function on that element\nwhich updates the `state`. It returns the final `state` at the end.\n\nYou can use it in a pipeline:\n```\n[2, 4, 8]\n |> List.walk 0 Num.add\n```\nThis returns 14 because:\n* `state` starts at 0\n* Each `step` runs `Num.add state elem`, and the return value becomes the new `state`.\n\nHere is a table of how `state` changes as [List.walk] walks over the elements\n`[2, 4, 8]` using [Num.add] as its `step` function to determine the next `state`.\n\nstate | elem | Num.add state elem\n:---: | :---: | :----------------:\n0 | |\n0 | 2 | 2\n2 | 4 | 6\n6 | 8 | 14\n\nThe following returns -6:\n```\n[1, 2, 3]\n |> List.walk 0 Num.sub\n```\nNote that in other languages, `walk` is sometimes called `reduce`,\n`fold`, `foldLeft`, or `foldl`.\n",
)
docs>>
<<docs:
Some(
"internal helper\n",
)
docs>>
<<docs:
Some(
"Like [walk], but at each step the function also receives the index of the current element.\n",
)
docs>>
<<docs:
Some(
"internal helper\n",
)
docs>>
<<docs:
Some(
"Like [walkUntil], but at each step the function also receives the index of the current element.\n",
)
docs>>
<<docs:
Some(
"internal helper\n",
)
docs>>
<<docs:
Some(
"Note that in other languages, `walkBackwards` is sometimes called `reduceRight`,\n`fold`, `foldRight`, or `foldr`.\n",
)
docs>>
<<docs:
Some(
"internal helper\n",
)
docs>>
<<docs:
Some(
"Same as [List.walk], except you can stop walking early.\n\n## Performance Details\n\nCompared to [List.walk], this can potentially visit fewer elements (which can\nimprove performance) at the cost of making each step take longer.\nHowever, the added cost to each step is extremely small, and can easily\nbe outweighed if it results in skipping even a small number of elements.\n\nAs such, it is typically better for performance to use this over [List.walk]\nif returning `Break` earlier than the last element is expected to be common.\n",
)
docs>>
<<docs:
Some(
"Same as [List.walkUntil], but does it from the end of the list instead.\n",
)
docs>>
<<docs:
Some(
"Walks to the end of the list from a specified starting index\n",
)
docs>>
<<docs:
Some(
"A combination of [List.walkFrom] and [List.walkUntil]\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Run the given predicate on each element of the list, returning `Bool.true` if\nany of the elements satisfy it.\n",
)
docs>>
<<docs:
Some(
"Run the given predicate on each element of the list, returning `Bool.true` if\nall of the elements satisfy it.\n",
)
docs>>
<<docs:
Some(
"Run the given function on each element of a list, and return all the\nelements for which the function returned `Bool.true`.\n```\nList.keepIf [1, 2, 3, 4] (\\num -> num > 2)\n```\n## Performance Details\n\n[List.keepIf] always returns a list that takes up exactly the same amount\nof memory as the original, even if its length decreases. This is because it\ncan't know in advance exactly how much space it will need, and if it guesses a\nlength that's too low, it would have to re-allocate.\n\n(If you want to do an operation like this which reduces the memory footprint\nof the resulting list, you can do two passes over the list with [List.walk] - one\nto calculate the precise new size, and another to populate the new list.)\n\nIf given a unique list, [List.keepIf] will mutate it in place to assemble the appropriate list.\nIf that happens, this function will not allocate any new memory on the heap.\nIf all elements in the list end up being kept, Roc will return the original\nlist unaltered.\n\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Run the given function on each element of a list, and return all the\nelements for which the function returned `Bool.false`.\n```\nList.dropIf [1, 2, 3, 4] (\\num -> num > 2)\n```\n## Performance Details\n\n`List.dropIf` has the same performance characteristics as [List.keepIf].\nSee its documentation for details on those characteristics!\n",
)
docs>>
<<docs:
Some(
"Run the given function on each element of a list, and return the\nnumber of elements for which the function returned `Bool.true`.\n```\nexpect List.countIf [1, -2, -3] Num.isNegative == 2\nexpect List.countIf [1, 2, 3] (\\num -> num > 1 ) == 2\n```\n",
)
docs>>
<<docs:
Some(
"This works like [List.map], except only the transformed values that are\nwrapped in `Ok` are kept. Any that are wrapped in `Err` are dropped.\n```\nexpect List.keepOks [\"1\", \"Two\", \"23\", \"Bird\"] Str.toI32 == [1, 23]\n\nexpect List.keepOks [[\"a\", \"b\"], [], [\"c\", \"d\", \"e\"], [] ] List.first == [\"a\", \"c\"]\n\nfn = \\str -> if Str.isEmpty str then Err StrWasEmpty else Ok str\nexpect List.keepOks [\"\", \"a\", \"bc\", \"\", \"d\", \"ef\", \"\"] fn == [\"a\", \"bc\", \"d\", \"ef\"]\n```\n",
)
docs>>
<<docs:
Some(
"This works like [List.map], except only the transformed values that are\nwrapped in `Err` are kept. Any that are wrapped in `Ok` are dropped.\n```\nList.keepErrs [[\"a\", \"b\"], [], [], [\"c\", \"d\", \"e\"]] List.last\n\nfn = \\str -> if Str.isEmpty str then Err StrWasEmpty else Ok (Str.len str)\n\nList.keepErrs [\"\", \"a\", \"bc\", \"\", \"d\", \"ef\", \"\"]\n```\n",
)
docs>>
<<docs:
Some(
"Convert each element in the list to something new, by calling a conversion\nfunction on each of them. Then return a new list of the converted values.\n```\nexpect List.map [1, 2, 3] (\\num -> num + 1) == [2, 3, 4]\n\nexpect List.map [\"\", \"a\", \"bc\"] Str.isEmpty == [Bool.true, Bool.false, Bool.false]\n```\n",
)
docs>>
<<docs:
Some(
"Run a transformation function on the first element of each list,\nand use that as the first element in the returned list.\nRepeat until a list runs out of elements.\n\nSome languages have a function named `zip`, which does something similar to\ncalling [List.map2] passing two lists and `Pair`:\n```\nzipped = List.map2 [\"a\", \"b\", \"c\"] [1, 2, 3] Pair\n```\n",
)
docs>>
<<docs:
Some(
"Run a transformation function on the first element of each list,\nand use that as the first element in the returned list.\nRepeat until a list runs out of elements.\n",
)
docs>>
<<docs:
Some(
"Run a transformation function on the first element of each list,\nand use that as the first element in the returned list.\nRepeat until a list runs out of elements.\n",
)
docs>>
<<docs:
Some(
"This works like [List.map], except it also passes the index\nof the element to the conversion function.\n```\nexpect List.mapWithIndex [10, 20, 30] (\\num, index -> num + index) == [10, 21, 32]\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns a list of all the integers between `start` and `end`.\n\nTo include the `start` and `end` integers themselves, use `At` like so:\n```\nList.range { start: At 2, end: At 5 } # returns [2, 3, 4, 5]\n```\nTo exclude them, use `After` and `Before`, like so:\n```\nList.range { start: After 2, end: Before 5 } # returns [3, 4]\n```\nYou can have the list end at a certain length rather than a certain integer:\n```\nList.range { start: At 6, end: Length 4 } # returns [6, 7, 8, 9]\n```\nIf `step` is specified, each integer increases by that much. (`step: 1` is the default.)\n```\nList.range { start: After 0, end: Before 9, step: 3 } # returns [3, 6]\n```\nList.range will also generate a reversed list if step is negative or end comes before start:\n```\nList.range { start: At 5, end: At 2 } # returns [5, 4, 3, 2]\n```\nAll of these options are compatible with the others. For example, you can use `At` or `After`\nwith `start` regardless of what `end` and `step` are set to.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Sort with a custom comparison function\n",
)
docs>>
<<docs:
Some(
"Sorts a list of numbers in ascending order (lowest to highest).\n\nTo sort in descending order (highest to lowest), use [List.sortDesc] instead.\n",
)
docs>>
<<docs:
Some(
"Sorts a list of numbers in descending order (highest to lowest).\n\nTo sort in ascending order (lowest to highest), use [List.sortAsc] instead.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns the first element in the list, or `ListWasEmpty` if it was empty.\n",
)
docs>>
<<docs:
Some(
"Returns the given number of elements from the beginning of the list.\n```\nList.takeFirst [1, 2, 3, 4, 5, 6, 7, 8] 4\n```\nIf there are fewer elements in the list than the requested number,\nreturns the entire list.\n```\nList.takeFirst [1, 2] 5\n```\nTo *remove* elements from the beginning of the list, use `List.takeLast`.\n\nTo remove elements from both the beginning and end of the list,\nuse `List.sublist`.\n\nTo split the list into two lists, use `List.split`.\n\n",
)
docs>>
<<docs:
Some(
"Returns the given number of elements from the end of the list.\n```\nList.takeLast [1, 2, 3, 4, 5, 6, 7, 8] 4\n```\nIf there are fewer elements in the list than the requested number,\nreturns the entire list.\n```\nList.takeLast [1, 2] 5\n```\nTo *remove* elements from the end of the list, use `List.takeFirst`.\n\nTo remove elements from both the beginning and end of the list,\nuse `List.sublist`.\n\nTo split the list into two lists, use `List.split`.\n\n",
)
docs>>
<<docs:
Some(
"Drops n elements from the beginning of the list.\n",
)
docs>>
<<docs:
Some(
"Drops n elements from the end of the list.\n",
)
docs>>
<<docs:
Some(
"Drops the element at the given index from the list.\n\nThis has no effect if the given index is outside the bounds of the list.\n\nTo replace the element at a given index, instead of dropping it, see [List.set].\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Like [List.map], except the transformation function wraps the return value\nin a list. At the end, all the lists get joined together into one list.\n\nYou may know a similar function named `concatMap` in other languages.\n",
)
docs>>
<<docs:
Some(
"Returns the first element of the list satisfying a predicate function.\nIf no satisfying element is found, an `Err NotFound` is returned.\n",
)
docs>>
<<docs:
Some(
"Returns the last element of the list satisfying a predicate function.\nIf no satisfying element is found, an `Err NotFound` is returned.\n",
)
docs>>
<<docs:
Some(
"Returns the index at which the first element in the list\nsatisfying a predicate function can be found.\nIf no satisfying element is found, an `Err NotFound` is returned.\n",
)
docs>>
<<docs:
Some(
"Returns the last index at which the first element in the list\nsatisfying a predicate function can be found.\nIf no satisfying element is found, an `Err NotFound` is returned.\n",
)
docs>>
<<docs:
Some(
"Returns a subsection of the given list, beginning at the `start` index and\nincluding a total of `len` elements.\n\nIf `start` is outside the bounds of the given list, returns the empty list.\n```\nList.sublist [1, 2, 3] { start: 4, len: 0 }\n```\nIf more elements are requested than exist in the list, returns as many as it can.\n```\nList.sublist [1, 2, 3, 4, 5] { start: 2, len: 10 }\n```\n> If you want a sublist which goes all the way to the end of the list, no\n> matter how long the list is, `List.takeLast` can do that more efficiently.\n\nSome languages have a function called **`slice`** which works similarly to this.\n",
)
docs>>
<<docs:
Some(
"low-level slicing operation that does no bounds checking\n",
)
docs>>
<<docs:
Some(
"Intersperses `sep` between the elements of `list`\n```\nList.intersperse [1, 2, 3] 9 # [1, 9, 2, 9, 3]\n```\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` if the first list starts with the second list.\n\nIf the second list is empty, this always returns `Bool.true`; every list\nis considered to \"start with\" an empty list.\n\nIf the first list is empty, this only returns `Bool.true` if the second list is empty.\n",
)
docs>>
<<docs:
Some(
"Returns `Bool.true` if the first list ends with the second list.\n\nIf the second list is empty, this always returns `Bool.true`; every list\nis considered to \"end with\" an empty list.\n\nIf the first list is empty, this only returns `Bool.true` if the second list is empty.\n",
)
docs>>
<<docs:
Some(
"Splits the list into two lists, around the given index.\n\nThe returned lists are labeled `before` and `others`. The `before` list will\ncontain all the elements whose index in the original list was **less than**\nthan the given index, # and the `others` list will be all the others. (This\nmeans if you give an index of 0, the `before` list will be empty and the\n`others` list will have the same elements as the original list.)\n",
)
docs>>
<<docs:
Some(
"Returns the elements before the first occurrence of a delimiter, as well as the\nremaining elements after that occurrence. If the delimiter is not found, returns `Err`.\n```\nList.splitFirst [Foo, Z, Bar, Z, Baz] Z == Ok { before: [Foo], after: [Bar, Z, Baz] }\n```\n",
)
docs>>
<<docs:
Some(
"Returns the elements before the last occurrence of a delimiter, as well as the\nremaining elements after that occurrence. If the delimiter is not found, returns `Err`.\n```\nList.splitLast [Foo, Z, Bar, Z, Baz] Z == Ok { before: [Foo, Z, Bar], after: [Baz] }\n```\n",
)
docs>>
<<docs:
Some(
"Splits the list into many chunks, each of which is length of the given chunk\nsize. The last chunk will be shorter if the list does not evenly divide by the\nchunk size. If the provided list is empty or if the chunk size is 0 then the\nresult is an empty list.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Like [List.map], except the transformation function returns a [Result].\nIf that function ever returns `Err`, [mapTry] immediately returns that `Err`.\nIf it returns `Ok` for every element, [mapTry] returns `Ok` with the transformed list.\n",
)
docs>>
<<docs:
Some(
"Same as [List.walk], except you can stop walking early by returning `Err`.\n\n## Performance Details\n\nCompared to [List.walk], this can potentially visit fewer elements (which can\nimprove performance) at the cost of making each step take longer.\nHowever, the added cost to each step is extremely small, and can easily\nbe outweighed if it results in skipping even a small number of elements.\n\nAs such, it is typically better for performance to use this over [List.walk]\nif returning `Break` earlier than the last element is expected to be common.\n",
)
docs>>
<<docs:
Some(
"internal helper\n",
)
docs>>
<<docs:
Some(
"Primitive for iterating over a List, being able to decide at every element whether to continue\n",
)
docs>>
<<docs:
Some(
"internal helper\n",
)
docs>>
<<docs:
Some(
"Primitive for iterating over a List from back to front, being able to decide at every\nelement whether to continue\n",
)
docs>>
<<docs:
Some(
"internal helper\n",
)
docs>>
adding docs for "List.roc",
docs ModuleDocumentation {
name: "List",
entries: [
DocDef(
DocDef {
name: "isEmpty",
symbol: `List.isEmpty`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
" Check if the list is empty.\n```\nList.isEmpty [1, 2, 3]\n\nList.isEmpty []\n```\n",
),
},
),
DocDef(
DocDef {
name: "getUnsafe",
symbol: `List.getUnsafe`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
docs: None,
},
),
DocDef(
DocDef {
name: "get",
symbol: `List.get`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"a",
),
TagUnion {
tags: [
Tag {
name: "OutOfBounds",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Returns an element from a list at the given index.\n\nReturns `Err OutOfBounds` if the given index exceeds the List's length\n```\nexpect List.get [100, 200, 300] 1 == Ok 200\nexpect List.get [100, 200, 300] 5 == Err OutOfBounds\n```\n",
),
},
),
DocDef(
DocDef {
name: "replaceUnsafe",
symbol: `List.replaceUnsafe`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U64",
parts: [],
},
BoundVariable(
"a",
),
],
output: Record {
fields: [
RecordField {
name: "list",
type_annotation: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
RecordField {
name: "value",
type_annotation: BoundVariable(
"a",
),
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "replace",
symbol: `List.replace`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U64",
parts: [],
},
BoundVariable(
"a",
),
],
output: Record {
fields: [
RecordField {
name: "list",
type_annotation: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
RecordField {
name: "value",
type_annotation: BoundVariable(
"a",
),
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "set",
symbol: `List.set`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U64",
parts: [],
},
BoundVariable(
"a",
),
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Replaces the element at the given index with a replacement.\n```\nList.set [\"a\", \"b\", \"c\"] 1 \"B\"\n```\nIf the given index is outside the bounds of the list, returns the original\nlist unmodified.\n\nTo drop the element at a given index, instead of replacing it, see [List.dropAt].\n",
),
},
),
DocDef(
DocDef {
name: "update",
symbol: `List.update`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U64",
parts: [],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: BoundVariable(
"a",
),
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Updates the element at the given index with the given function.\n```\nList.update [1, 2, 3] 1 (\\x -> x + 1)\n```\nIf the given index is outside the bounds of the list, returns the original\nlist unmodified.\n\nTo replace the element at a given index, instead of updating based on the current value,\nsee [List.set] and [List.replace]\n",
),
},
),
DocDef(
DocDef {
name: "append",
symbol: `List.append`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
BoundVariable(
"a",
),
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Add a single element to the end of a list.\n```\nList.append [1, 2, 3] 4\n\n[0, 1, 2]\n |> List.append 3\n```\n",
),
},
),
DocDef(
DocDef {
name: "appendIfOk",
symbol: `List.appendIfOk`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Result",
parts: [
BoundVariable(
"a",
),
Wildcard,
],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"If the given [Result] is `Ok`, add it to the end of a list.\nOtherwise, return the list unmodified.\n\n```\nList.appendIfOk [1, 2, 3] (Ok 4)\n\n[0, 1, 2]\n |> List.appendIfOk (Err 3)\n```\n",
),
},
),
DocDef(
DocDef {
name: "appendUnsafe",
symbol: `List.appendUnsafe`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
BoundVariable(
"a",
),
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Writes the element after the current last element unconditionally.\nIn other words, it is assumed that\n\n- the list is owned (i.e. can be updated in-place\n- the list has at least one element of spare capacity\n",
),
},
),
DocDef(
DocDef {
name: "prepend",
symbol: `List.prepend`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
BoundVariable(
"a",
),
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Add a single element to the beginning of a list.\n```\nList.prepend [1, 2, 3] 0\n\n[2, 3, 4]\n |> List.prepend 1\n```\n",
),
},
),
DocDef(
DocDef {
name: "prependIfOk",
symbol: `List.prependIfOk`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "Result",
parts: [
BoundVariable(
"a",
),
Wildcard,
],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"If the given [Result] is `Ok`, add it to the beginning of a list.\nOtherwise, return the list unmodified.\n\n```\nList.prepend [1, 2, 3] (Ok 0)\n\n[2, 3, 4]\n |> List.prepend (Err 1)\n```\n",
),
},
),
DocDef(
DocDef {
name: "len",
symbol: `List.len`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: Some(
"Returns the length of the list - the number of elements it contains.\n\nOne [List] can store up to 2,147,483,648 elements (just over 2 billion), which\nis exactly equal to the highest valid #I32 value. This means the #U32 this function\nreturns can always be safely converted to an #I32 without losing any data.\n",
),
},
),
DocDef(
DocDef {
name: "withCapacity",
symbol: `List.withCapacity`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
Wildcard,
],
},
},
docs: Some(
"Create a list with space for at least capacity elements\n",
),
},
),
DocDef(
DocDef {
name: "reserve",
symbol: `List.reserve`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Enlarge the list for at least capacity additional elements\n",
),
},
),
DocDef(
DocDef {
name: "releaseExcessCapacity",
symbol: `List.releaseExcessCapacity`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Shrink the memory footprint of a list such that it's capacity and length are equal.\nNote: This will also convert seamless slices to regular lists.\n",
),
},
),
DocDef(
DocDef {
name: "concat",
symbol: `List.concat`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Put two lists together.\n```\nList.concat [1, 2, 3] [4, 5]\n\n[0, 1, 2]\n |> List.concat [3, 4]\n```\n",
),
},
),
DocDef(
DocDef {
name: "last",
symbol: `List.last`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"a",
),
TagUnion {
tags: [
Tag {
name: "ListWasEmpty",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Returns the last element in the list, or `ListWasEmpty` if it was empty.\n```\nexpect List.last [1, 2, 3] == Ok 3\nexpect List.last [] == Err ListWasEmpty\n```\n",
),
},
),
DocDef(
DocDef {
name: "single",
symbol: `List.single`,
type_vars: [],
type_annotation: Function {
args: [
BoundVariable(
"a",
),
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"A list with a single element in it.\n\nThis is useful in pipelines, like so:\n```\nwebsites =\n Str.concat domain \".com\"\n |> List.single\n```\n",
),
},
),
DocDef(
DocDef {
name: "repeat",
symbol: `List.repeat`,
type_vars: [],
type_annotation: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Returns a list with the given length, where every element is the given value.\n",
),
},
),
DocDef(
DocDef {
name: "repeatHelp",
symbol: `List.IdentId(89)`,
type_vars: [],
type_annotation: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "U64",
parts: [],
},
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "reverse",
symbol: `List.reverse`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Returns the list with its elements reversed.\n```\nexpect List.reverse [1, 2, 3] == [3, 2, 1]\n```\n",
),
},
),
DocDef(
DocDef {
name: "clone",
symbol: `List.clone`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "join",
symbol: `List.join`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Join the given lists together into one list.\n```\nexpect List.join [[1], [2, 3], [], [4, 5]] == [1, 2, 3, 4, 5]\nexpect List.join [[], []] == []\nexpect List.join [] == []\n```\n",
),
},
),
DocDef(
DocDef {
name: "contains",
symbol: `List.contains`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
BoundVariable(
"a",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
implements: [
ImplementsClause {
name: "a",
abilities: [
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "walk",
symbol: `List.walk`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"elem",
),
],
output: BoundVariable(
"state",
),
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Build a value using each element in the list.\n\nStarting with a given `state` value, this walks through each element in the\nlist from first to last, running a given `step` function on that element\nwhich updates the `state`. It returns the final `state` at the end.\n\nYou can use it in a pipeline:\n```\n[2, 4, 8]\n |> List.walk 0 Num.add\n```\nThis returns 14 because:\n* `state` starts at 0\n* Each `step` runs `Num.add state elem`, and the return value becomes the new `state`.\n\nHere is a table of how `state` changes as [List.walk] walks over the elements\n`[2, 4, 8]` using [Num.add] as its `step` function to determine the next `state`.\n\nstate | elem | Num.add state elem\n:---: | :---: | :----------------:\n0 | |\n0 | 2 | 2\n2 | 4 | 6\n6 | 8 | 14\n\nThe following returns -6:\n```\n[1, 2, 3]\n |> List.walk 0 Num.sub\n```\nNote that in other languages, `walk` is sometimes called `reduce`,\n`fold`, `foldLeft`, or `foldl`.\n",
),
},
),
DocDef(
DocDef {
name: "walkHelp",
symbol: `List.IdentId(91)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"s",
),
Function {
args: [
BoundVariable(
"s",
),
BoundVariable(
"elem",
),
],
output: BoundVariable(
"s",
),
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"s",
),
},
docs: Some(
"internal helper\n",
),
},
),
DocDef(
DocDef {
name: "walkWithIndex",
symbol: `List.walkWithIndex`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"elem",
),
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"state",
),
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Like [walk], but at each step the function also receives the index of the current element.\n",
),
},
),
DocDef(
DocDef {
name: "walkWithIndexHelp",
symbol: `List.IdentId(92)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"s",
),
Function {
args: [
BoundVariable(
"s",
),
BoundVariable(
"elem",
),
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"s",
),
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"s",
),
},
docs: Some(
"internal helper\n",
),
},
),
DocDef(
DocDef {
name: "walkWithIndexUntil",
symbol: `List.walkWithIndexUntil`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"elem",
),
Apply {
name: "U64",
parts: [],
},
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"state",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"state",
),
],
},
],
extension: NoTypeAnn,
},
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Like [walkUntil], but at each step the function also receives the index of the current element.\n",
),
},
),
DocDef(
DocDef {
name: "walkWithIndexUntilHelp",
symbol: `List.IdentId(93)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"s",
),
Function {
args: [
BoundVariable(
"s",
),
BoundVariable(
"elem",
),
Apply {
name: "U64",
parts: [],
},
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"s",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"b",
),
],
},
],
extension: NoTypeAnn,
},
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"s",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"b",
),
],
},
],
extension: NoTypeAnn,
},
},
docs: Some(
"internal helper\n",
),
},
),
DocDef(
DocDef {
name: "walkBackwards",
symbol: `List.walkBackwards`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"elem",
),
],
output: BoundVariable(
"state",
),
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Note that in other languages, `walkBackwards` is sometimes called `reduceRight`,\n`fold`, `foldRight`, or `foldr`.\n",
),
},
),
DocDef(
DocDef {
name: "walkBackwardsHelp",
symbol: `List.IdentId(94)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"elem",
),
],
output: BoundVariable(
"state",
),
},
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"internal helper\n",
),
},
),
DocDef(
DocDef {
name: "walkUntil",
symbol: `List.walkUntil`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"elem",
),
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"state",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"state",
),
],
},
],
extension: NoTypeAnn,
},
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Same as [List.walk], except you can stop walking early.\n\n## Performance Details\n\nCompared to [List.walk], this can potentially visit fewer elements (which can\nimprove performance) at the cost of making each step take longer.\nHowever, the added cost to each step is extremely small, and can easily\nbe outweighed if it results in skipping even a small number of elements.\n\nAs such, it is typically better for performance to use this over [List.walk]\nif returning `Break` earlier than the last element is expected to be common.\n",
),
},
),
DocDef(
DocDef {
name: "walkBackwardsUntil",
symbol: `List.walkBackwardsUntil`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"elem",
),
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"state",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"state",
),
],
},
],
extension: NoTypeAnn,
},
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Same as [List.walkUntil], but does it from the end of the list instead.\n",
),
},
),
DocDef(
DocDef {
name: "walkFrom",
symbol: `List.walkFrom`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Apply {
name: "U64",
parts: [],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"elem",
),
],
output: BoundVariable(
"state",
),
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Walks to the end of the list from a specified starting index\n",
),
},
),
DocDef(
DocDef {
name: "walkFromUntil",
symbol: `List.walkFromUntil`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Apply {
name: "U64",
parts: [],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"elem",
),
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"state",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"state",
),
],
},
],
extension: NoTypeAnn,
},
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"A combination of [List.walkFrom] and [List.walkUntil]\n",
),
},
),
DocDef(
DocDef {
name: "sum",
symbol: `List.sum`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "product",
symbol: `List.product`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "any",
symbol: `List.any`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Run the given predicate on each element of the list, returning `Bool.true` if\nany of the elements satisfy it.\n",
),
},
),
DocDef(
DocDef {
name: "all",
symbol: `List.all`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Run the given predicate on each element of the list, returning `Bool.true` if\nall of the elements satisfy it.\n",
),
},
),
DocDef(
DocDef {
name: "keepIf",
symbol: `List.keepIf`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Run the given function on each element of a list, and return all the\nelements for which the function returned `Bool.true`.\n```\nList.keepIf [1, 2, 3, 4] (\\num -> num > 2)\n```\n## Performance Details\n\n[List.keepIf] always returns a list that takes up exactly the same amount\nof memory as the original, even if its length decreases. This is because it\ncan't know in advance exactly how much space it will need, and if it guesses a\nlength that's too low, it would have to re-allocate.\n\n(If you want to do an operation like this which reduces the memory footprint\nof the resulting list, you can do two passes over the list with [List.walk] - one\nto calculate the precise new size, and another to populate the new list.)\n\nIf given a unique list, [List.keepIf] will mutate it in place to assemble the appropriate list.\nIf that happens, this function will not allocate any new memory on the heap.\nIf all elements in the list end up being kept, Roc will return the original\nlist unaltered.\n\n",
),
},
),
DocDef(
DocDef {
name: "keepIfHelp",
symbol: `List.IdentId(95)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dropIf",
symbol: `List.dropIf`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Run the given function on each element of a list, and return all the\nelements for which the function returned `Bool.false`.\n```\nList.dropIf [1, 2, 3, 4] (\\num -> num > 2)\n```\n## Performance Details\n\n`List.dropIf` has the same performance characteristics as [List.keepIf].\nSee its documentation for details on those characteristics!\n",
),
},
),
DocDef(
DocDef {
name: "countIf",
symbol: `List.countIf`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: Some(
"Run the given function on each element of a list, and return the\nnumber of elements for which the function returned `Bool.true`.\n```\nexpect List.countIf [1, -2, -3] Num.isNegative == 2\nexpect List.countIf [1, 2, 3] (\\num -> num > 1 ) == 2\n```\n",
),
},
),
DocDef(
DocDef {
name: "keepOks",
symbol: `List.keepOks`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"before",
),
],
},
Function {
args: [
BoundVariable(
"before",
),
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"after",
),
Wildcard,
],
},
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"after",
),
],
},
},
docs: Some(
"This works like [List.map], except only the transformed values that are\nwrapped in `Ok` are kept. Any that are wrapped in `Err` are dropped.\n```\nexpect List.keepOks [\"1\", \"Two\", \"23\", \"Bird\"] Str.toI32 == [1, 23]\n\nexpect List.keepOks [[\"a\", \"b\"], [], [\"c\", \"d\", \"e\"], [] ] List.first == [\"a\", \"c\"]\n\nfn = \\str -> if Str.isEmpty str then Err StrWasEmpty else Ok str\nexpect List.keepOks [\"\", \"a\", \"bc\", \"\", \"d\", \"ef\", \"\"] fn == [\"a\", \"bc\", \"d\", \"ef\"]\n```\n",
),
},
),
DocDef(
DocDef {
name: "keepErrs",
symbol: `List.keepErrs`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"before",
),
],
},
Function {
args: [
BoundVariable(
"before",
),
],
output: Apply {
name: "Result",
parts: [
Wildcard,
BoundVariable(
"after",
),
],
},
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"after",
),
],
},
},
docs: Some(
"This works like [List.map], except only the transformed values that are\nwrapped in `Err` are kept. Any that are wrapped in `Ok` are dropped.\n```\nList.keepErrs [[\"a\", \"b\"], [], [], [\"c\", \"d\", \"e\"]] List.last\n\nfn = \\str -> if Str.isEmpty str then Err StrWasEmpty else Ok (Str.len str)\n\nList.keepErrs [\"\", \"a\", \"bc\", \"\", \"d\", \"ef\", \"\"]\n```\n",
),
},
),
DocDef(
DocDef {
name: "map",
symbol: `List.map`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: BoundVariable(
"b",
),
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"b",
),
],
},
},
docs: Some(
"Convert each element in the list to something new, by calling a conversion\nfunction on each of them. Then return a new list of the converted values.\n```\nexpect List.map [1, 2, 3] (\\num -> num + 1) == [2, 3, 4]\n\nexpect List.map [\"\", \"a\", \"bc\"] Str.isEmpty == [Bool.true, Bool.false, Bool.false]\n```\n",
),
},
),
DocDef(
DocDef {
name: "map2",
symbol: `List.map2`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "List",
parts: [
BoundVariable(
"b",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
BoundVariable(
"b",
),
],
output: BoundVariable(
"c",
),
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"c",
),
],
},
},
docs: Some(
"Run a transformation function on the first element of each list,\nand use that as the first element in the returned list.\nRepeat until a list runs out of elements.\n\nSome languages have a function named `zip`, which does something similar to\ncalling [List.map2] passing two lists and `Pair`:\n```\nzipped = List.map2 [\"a\", \"b\", \"c\"] [1, 2, 3] Pair\n```\n",
),
},
),
DocDef(
DocDef {
name: "map3",
symbol: `List.map3`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "List",
parts: [
BoundVariable(
"b",
),
],
},
Apply {
name: "List",
parts: [
BoundVariable(
"c",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
BoundVariable(
"b",
),
BoundVariable(
"c",
),
],
output: BoundVariable(
"d",
),
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"d",
),
],
},
},
docs: Some(
"Run a transformation function on the first element of each list,\nand use that as the first element in the returned list.\nRepeat until a list runs out of elements.\n",
),
},
),
DocDef(
DocDef {
name: "map4",
symbol: `List.map4`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "List",
parts: [
BoundVariable(
"b",
),
],
},
Apply {
name: "List",
parts: [
BoundVariable(
"c",
),
],
},
Apply {
name: "List",
parts: [
BoundVariable(
"d",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
BoundVariable(
"b",
),
BoundVariable(
"c",
),
BoundVariable(
"d",
),
],
output: BoundVariable(
"e",
),
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"e",
),
],
},
},
docs: Some(
"Run a transformation function on the first element of each list,\nand use that as the first element in the returned list.\nRepeat until a list runs out of elements.\n",
),
},
),
DocDef(
DocDef {
name: "mapWithIndex",
symbol: `List.mapWithIndex`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"b",
),
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"b",
),
],
},
},
docs: Some(
"This works like [List.map], except it also passes the index\nof the element to the conversion function.\n```\nexpect List.mapWithIndex [10, 20, 30] (\\num, index -> num + index) == [10, 21, 32]\n```\n",
),
},
),
DocDef(
DocDef {
name: "mapWithIndexHelp",
symbol: `List.IdentId(96)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "List",
parts: [
BoundVariable(
"b",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"b",
),
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"b",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "range",
symbol: `List.range`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: Some(
"Returns a list of all the integers between `start` and `end`.\n\nTo include the `start` and `end` integers themselves, use `At` like so:\n```\nList.range { start: At 2, end: At 5 } # returns [2, 3, 4, 5]\n```\nTo exclude them, use `After` and `Before`, like so:\n```\nList.range { start: After 2, end: Before 5 } # returns [3, 4]\n```\nYou can have the list end at a certain length rather than a certain integer:\n```\nList.range { start: At 6, end: Length 4 } # returns [6, 7, 8, 9]\n```\nIf `step` is specified, each integer increases by that much. (`step: 1` is the default.)\n```\nList.range { start: After 0, end: Before 9, step: 3 } # returns [3, 6]\n```\nList.range will also generate a reversed list if step is negative or end comes before start:\n```\nList.range { start: At 5, end: At 2 } # returns [5, 4, 3, 2]\n```\nAll of these options are compatible with the others. For example, you can use `At` or `After`\nwith `start` regardless of what `end` and `step` are set to.\n",
),
},
),
DocDef(
DocDef {
name: "sortWith",
symbol: `List.sortWith`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
BoundVariable(
"a",
),
],
output: TagUnion {
tags: [
Tag {
name: "LT",
values: [],
},
Tag {
name: "EQ",
values: [],
},
Tag {
name: "GT",
values: [],
},
],
extension: NoTypeAnn,
},
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: Some(
"Sort with a custom comparison function\n",
),
},
),
DocDef(
DocDef {
name: "sortAsc",
symbol: `List.sortAsc`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
},
],
output: Apply {
name: "List",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
},
},
docs: Some(
"Sorts a list of numbers in ascending order (lowest to highest).\n\nTo sort in descending order (highest to lowest), use [List.sortDesc] instead.\n",
),
},
),
DocDef(
DocDef {
name: "sortDesc",
symbol: `List.sortDesc`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
},
],
output: Apply {
name: "List",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
},
},
docs: Some(
"Sorts a list of numbers in descending order (highest to lowest).\n\nTo sort in ascending order (lowest to highest), use [List.sortAsc] instead.\n",
),
},
),
DocDef(
DocDef {
name: "swap",
symbol: `List.swap`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "first",
symbol: `List.first`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"a",
),
TagUnion {
tags: [
Tag {
name: "ListWasEmpty",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Returns the first element in the list, or `ListWasEmpty` if it was empty.\n",
),
},
),
DocDef(
DocDef {
name: "takeFirst",
symbol: `List.takeFirst`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
docs: Some(
"Returns the given number of elements from the beginning of the list.\n```\nList.takeFirst [1, 2, 3, 4, 5, 6, 7, 8] 4\n```\nIf there are fewer elements in the list than the requested number,\nreturns the entire list.\n```\nList.takeFirst [1, 2] 5\n```\nTo *remove* elements from the beginning of the list, use `List.takeLast`.\n\nTo remove elements from both the beginning and end of the list,\nuse `List.sublist`.\n\nTo split the list into two lists, use `List.split`.\n\n",
),
},
),
DocDef(
DocDef {
name: "takeLast",
symbol: `List.takeLast`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
docs: Some(
"Returns the given number of elements from the end of the list.\n```\nList.takeLast [1, 2, 3, 4, 5, 6, 7, 8] 4\n```\nIf there are fewer elements in the list than the requested number,\nreturns the entire list.\n```\nList.takeLast [1, 2] 5\n```\nTo *remove* elements from the end of the list, use `List.takeFirst`.\n\nTo remove elements from both the beginning and end of the list,\nuse `List.sublist`.\n\nTo split the list into two lists, use `List.split`.\n\n",
),
},
),
DocDef(
DocDef {
name: "dropFirst",
symbol: `List.dropFirst`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
docs: Some(
"Drops n elements from the beginning of the list.\n",
),
},
),
DocDef(
DocDef {
name: "dropLast",
symbol: `List.dropLast`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
docs: Some(
"Drops n elements from the end of the list.\n",
),
},
),
DocDef(
DocDef {
name: "dropAt",
symbol: `List.dropAt`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
docs: Some(
"Drops the element at the given index from the list.\n\nThis has no effect if the given index is outside the bounds of the list.\n\nTo replace the element at a given index, instead of dropping it, see [List.set].\n",
),
},
),
DocDef(
DocDef {
name: "min",
symbol: `List.min`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
TagUnion {
tags: [
Tag {
name: "ListWasEmpty",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "minHelp",
symbol: `List.IdentId(99)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "max",
symbol: `List.max`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
TagUnion {
tags: [
Tag {
name: "ListWasEmpty",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "maxHelp",
symbol: `List.IdentId(100)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
},
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
],
output: Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "joinMap",
symbol: `List.joinMap`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"b",
),
],
},
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"b",
),
],
},
},
docs: Some(
"Like [List.map], except the transformation function wraps the return value\nin a list. At the end, all the lists get joined together into one list.\n\nYou may know a similar function named `concatMap` in other languages.\n",
),
},
),
DocDef(
DocDef {
name: "findFirst",
symbol: `List.findFirst`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Function {
args: [
BoundVariable(
"elem",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"elem",
),
TagUnion {
tags: [
Tag {
name: "NotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Returns the first element of the list satisfying a predicate function.\nIf no satisfying element is found, an `Err NotFound` is returned.\n",
),
},
),
DocDef(
DocDef {
name: "findLast",
symbol: `List.findLast`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Function {
args: [
BoundVariable(
"elem",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"elem",
),
TagUnion {
tags: [
Tag {
name: "NotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Returns the last element of the list satisfying a predicate function.\nIf no satisfying element is found, an `Err NotFound` is returned.\n",
),
},
),
DocDef(
DocDef {
name: "findFirstIndex",
symbol: `List.findFirstIndex`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Function {
args: [
BoundVariable(
"elem",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "U64",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "NotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Returns the index at which the first element in the list\nsatisfying a predicate function can be found.\nIf no satisfying element is found, an `Err NotFound` is returned.\n",
),
},
),
DocDef(
DocDef {
name: "findLastIndex",
symbol: `List.findLastIndex`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Function {
args: [
BoundVariable(
"elem",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "U64",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "NotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Returns the last index at which the first element in the list\nsatisfying a predicate function can be found.\nIf no satisfying element is found, an `Err NotFound` is returned.\n",
),
},
),
DocDef(
DocDef {
name: "sublist",
symbol: `List.sublist`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Record {
fields: [
RecordField {
name: "start",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "len",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
],
extension: NoTypeAnn,
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
docs: Some(
"Returns a subsection of the given list, beginning at the `start` index and\nincluding a total of `len` elements.\n\nIf `start` is outside the bounds of the given list, returns the empty list.\n```\nList.sublist [1, 2, 3] { start: 4, len: 0 }\n```\nIf more elements are requested than exist in the list, returns as many as it can.\n```\nList.sublist [1, 2, 3, 4, 5] { start: 2, len: 10 }\n```\n> If you want a sublist which goes all the way to the end of the list, no\n> matter how long the list is, `List.takeLast` can do that more efficiently.\n\nSome languages have a function called **`slice`** which works similarly to this.\n",
),
},
),
DocDef(
DocDef {
name: "sublistLowlevel",
symbol: `List.sublistLowlevel`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
docs: Some(
"low-level slicing operation that does no bounds checking\n",
),
},
),
DocDef(
DocDef {
name: "intersperse",
symbol: `List.intersperse`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"elem",
),
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
docs: Some(
"Intersperses `sep` between the elements of `list`\n```\nList.intersperse [1, 2, 3] 9 # [1, 9, 2, 9, 3]\n```\n",
),
},
),
DocDef(
DocDef {
name: "startsWith",
symbol: `List.startsWith`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
implements: [
ImplementsClause {
name: "elem",
abilities: [
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: Some(
"Returns `Bool.true` if the first list starts with the second list.\n\nIf the second list is empty, this always returns `Bool.true`; every list\nis considered to \"start with\" an empty list.\n\nIf the first list is empty, this only returns `Bool.true` if the second list is empty.\n",
),
},
),
DocDef(
DocDef {
name: "endsWith",
symbol: `List.endsWith`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
implements: [
ImplementsClause {
name: "elem",
abilities: [
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: Some(
"Returns `Bool.true` if the first list ends with the second list.\n\nIf the second list is empty, this always returns `Bool.true`; every list\nis considered to \"end with\" an empty list.\n\nIf the first list is empty, this only returns `Bool.true` if the second list is empty.\n",
),
},
),
DocDef(
DocDef {
name: "split",
symbol: `List.split`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Record {
fields: [
RecordField {
name: "before",
type_annotation: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
RecordField {
name: "others",
type_annotation: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
],
extension: NoTypeAnn,
},
},
docs: Some(
"Splits the list into two lists, around the given index.\n\nThe returned lists are labeled `before` and `others`. The `before` list will\ncontain all the elements whose index in the original list was **less than**\nthan the given index, # and the `others` list will be all the others. (This\nmeans if you give an index of 0, the `before` list will be empty and the\n`others` list will have the same elements as the original list.)\n",
),
},
),
DocDef(
DocDef {
name: "splitFirst",
symbol: `List.splitFirst`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"elem",
),
],
output: Apply {
name: "Result",
parts: [
Record {
fields: [
RecordField {
name: "before",
type_annotation: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
RecordField {
name: "after",
type_annotation: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
],
extension: NoTypeAnn,
},
TagUnion {
tags: [
Tag {
name: "NotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
implements: [
ImplementsClause {
name: "elem",
abilities: [
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: Some(
"Returns the elements before the first occurrence of a delimiter, as well as the\nremaining elements after that occurrence. If the delimiter is not found, returns `Err`.\n```\nList.splitFirst [Foo, Z, Bar, Z, Baz] Z == Ok { before: [Foo], after: [Bar, Z, Baz] }\n```\n",
),
},
),
DocDef(
DocDef {
name: "splitLast",
symbol: `List.splitLast`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"elem",
),
],
output: Apply {
name: "Result",
parts: [
Record {
fields: [
RecordField {
name: "before",
type_annotation: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
RecordField {
name: "after",
type_annotation: Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
},
],
extension: NoTypeAnn,
},
TagUnion {
tags: [
Tag {
name: "NotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
implements: [
ImplementsClause {
name: "elem",
abilities: [
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: Some(
"Returns the elements before the last occurrence of a delimiter, as well as the\nremaining elements after that occurrence. If the delimiter is not found, returns `Err`.\n```\nList.splitLast [Foo, Z, Bar, Z, Baz] Z == Ok { before: [Foo, Z, Bar], after: [Baz] }\n```\n",
),
},
),
DocDef(
DocDef {
name: "chunksOf",
symbol: `List.chunksOf`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
],
},
},
docs: Some(
"Splits the list into many chunks, each of which is length of the given chunk\nsize. The last chunk will be shorter if the list does not evenly divide by the\nchunk size. If the provided list is empty or if the chunk size is 0 then the\nresult is an empty list.\n",
),
},
),
DocDef(
DocDef {
name: "chunksOfHelp",
symbol: `List.IdentId(101)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "List",
parts: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
],
},
],
output: Apply {
name: "List",
parts: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "mapTry",
symbol: `List.mapTry`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
Function {
args: [
BoundVariable(
"elem",
),
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"ok",
),
BoundVariable(
"err",
),
],
},
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "List",
parts: [
BoundVariable(
"ok",
),
],
},
BoundVariable(
"err",
),
],
},
},
docs: Some(
"Like [List.map], except the transformation function returns a [Result].\nIf that function ever returns `Err`, [mapTry] immediately returns that `Err`.\nIf it returns `Ok` for every element, [mapTry] returns `Ok` with the transformed list.\n",
),
},
),
DocDef(
DocDef {
name: "walkTry",
symbol: `List.walkTry`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"elem",
),
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"state",
),
BoundVariable(
"err",
),
],
},
},
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"state",
),
BoundVariable(
"err",
),
],
},
},
docs: Some(
"Same as [List.walk], except you can stop walking early by returning `Err`.\n\n## Performance Details\n\nCompared to [List.walk], this can potentially visit fewer elements (which can\nimprove performance) at the cost of making each step take longer.\nHowever, the added cost to each step is extremely small, and can easily\nbe outweighed if it results in skipping even a small number of elements.\n\nAs such, it is typically better for performance to use this over [List.walk]\nif returning `Break` earlier than the last element is expected to be common.\n",
),
},
),
DocDef(
DocDef {
name: "walkTryHelp",
symbol: `List.IdentId(102)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"elem",
),
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"state",
),
BoundVariable(
"err",
),
],
},
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"state",
),
BoundVariable(
"err",
),
],
},
},
docs: Some(
"internal helper\n",
),
},
),
DocDef(
DocDef {
name: "iterate",
symbol: `List.IdentId(103)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"s",
),
Function {
args: [
BoundVariable(
"s",
),
BoundVariable(
"elem",
),
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"s",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"b",
),
],
},
],
extension: NoTypeAnn,
},
},
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"s",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"b",
),
],
},
],
extension: NoTypeAnn,
},
},
docs: Some(
"Primitive for iterating over a List, being able to decide at every element whether to continue\n",
),
},
),
DocDef(
DocDef {
name: "iterHelp",
symbol: `List.iterHelp`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"s",
),
Function {
args: [
BoundVariable(
"s",
),
BoundVariable(
"elem",
),
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"s",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"b",
),
],
},
],
extension: NoTypeAnn,
},
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"s",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"b",
),
],
},
],
extension: NoTypeAnn,
},
},
docs: Some(
"internal helper\n",
),
},
),
DocDef(
DocDef {
name: "iterateBackwards",
symbol: `List.IdentId(104)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"s",
),
Function {
args: [
BoundVariable(
"s",
),
BoundVariable(
"elem",
),
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"s",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"b",
),
],
},
],
extension: NoTypeAnn,
},
},
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"s",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"b",
),
],
},
],
extension: NoTypeAnn,
},
},
docs: Some(
"Primitive for iterating over a List from back to front, being able to decide at every\nelement whether to continue\n",
),
},
),
DocDef(
DocDef {
name: "iterBackwardsHelp",
symbol: `List.IdentId(105)`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"s",
),
Function {
args: [
BoundVariable(
"s",
),
BoundVariable(
"elem",
),
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"s",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"b",
),
],
},
],
extension: NoTypeAnn,
},
},
Apply {
name: "U64",
parts: [],
},
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"s",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"b",
),
],
},
],
extension: NoTypeAnn,
},
},
docs: Some(
"internal helper\n",
),
},
),
],
scope: Scope {
aliases: VecMap {
keys: [
`Num.Binary32`,
`Num.F32`,
`Num.FloatingPoint`,
`Num.Unsigned16`,
`Num.U16`,
`Bool.Bool`,
`Num.U64`,
`Num.Binary64`,
`Num.Int`,
`Num.Signed128`,
`Num.Unsigned8`,
`Num.Frac`,
`Num.U32`,
`Num.Signed64`,
`Num.Signed8`,
`Num.I64`,
`Num.U8`,
`Num.I16`,
`Result.Result`,
`Num.Unsigned128`,
`Num.I8`,
`Num.Num`,
`Num.Decimal`,
`Num.Unsigned32`,
`Num.Signed32`,
`Num.Integer`,
`Num.I128`,
`Num.U128`,
`Num.I32`,
`Num.Signed16`,
`Num.Unsigned64`,
`Num.F64`,
`Num.Dec`,
],
values: [
Alias {
region: @17634-17642,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19444-19447,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17650-17669,
type_variables: [
@17664-17669 AliasVar {
name: 'range',
var: 67,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <67>,
kind: Opaque,
},
Alias {
region: @17202-17212,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17544-17547,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @1780-1784,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: ['False', 'True'],
kind: Opaque,
},
Alias {
region: @17482-17485,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17619-17627,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @12895-12904,
type_variables: [
@12899-12904 AliasVar {
name: 'range',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` <64>[ but actually <64> ])[ but actually (Alias `Num.Integer` <64>[ but actually <64> ]) ]),
kind: Structural,
},
Alias {
region: @17074-17083,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17219-17228,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17034-17044,
type_variables: [
@17039-17044 AliasVar {
name: 'range',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` <65>[ but actually <65> ])[ but actually (Alias `Num.FloatingPoint` <65>[ but actually <65> ]) ]),
kind: Structural,
},
Alias {
region: @17513-17516,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17090-17098,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17135-17142,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17291-17294,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17575-17577,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17349-17352,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @241-254,
type_variables: [
@248-250 AliasVar {
name: 'ok',
var: 64,
opt_bound_abilities: None,
},
@251-254 AliasVar {
name: 'err',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['Err' <65>, 'Ok' <64>]<63>,
kind: Structural,
},
Alias {
region: @17150-17161,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17431-17433,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Int` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ]) ]) ]),
kind: Structural,
},
Alias {
region: @5228-5237,
type_variables: [
@5232-5237 AliasVar {
name: 'range',
var: 63,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <63>,
kind: Opaque,
},
Alias {
region: @17605-17612,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17185-17195,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17105-17113,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17236-17249,
type_variables: [
@17244-17249 AliasVar {
name: 'range',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <66>,
kind: Opaque,
},
Alias {
region: @17260-17264,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17449-17453,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17320-17323,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17120-17128,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17168-17178,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19085-19088,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @23363-23366,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ]) ]),
kind: Structural,
},
],
},
abilities_store: IAbilitiesStore {
members_of_ability: {
`Bool.Eq`: [
`Bool.isEq`,
],
},
specialization_to_root: {
`Bool.boolIsEq`: ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
},
},
ability_members: {
`Bool.isEq`: AbilityMemberData {
parent_ability: `Bool.Eq`,
region: @1635-1639,
typ: Imported,
},
},
declared_implementations: {
ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
}: Impl(
`Bool.boolIsEq`,
),
},
specializations: {},
next_specialization_id: 27,
resolved_specializations: {},
},
home: List,
exposed_ident_count: 89,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "Result",
},
),
`Result.Result`,
@1325-1331,
),
(
Ident(
IdentStr {
string: "Eq",
},
),
`Bool.Eq`,
@1302-1304,
),
(
Ident(
IdentStr {
string: "Int",
},
),
`Num.Int`,
@1359-1362,
),
(
Ident(
IdentStr {
string: "U64",
},
),
`Num.U64`,
@1349-1352,
),
(
Ident(
IdentStr {
string: "Bool",
},
),
`Bool.Bool`,
@1296-1300,
),
(
Ident(
IdentStr {
string: "Num",
},
),
`Num.Num`,
@1354-1357,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
76,
105,
115,
116,
105,
115,
69,
109,
112,
116,
121,
103,
101,
116,
115,
101,
116,
97,
112,
112,
101,
110,
100,
109,
97,
112,
108,
101,
110,
119,
97,
108,
107,
66,
97,
99,
107,
119,
97,
114,
100,
115,
99,
111,
110,
99,
97,
116,
102,
105,
114,
115,
116,
115,
105,
110,
103,
108,
101,
114,
101,
112,
101,
97,
116,
114,
101,
118,
101,
114,
115,
101,
112,
114,
101,
112,
101,
110,
100,
106,
111,
105,
110,
107,
101,
101,
112,
73,
102,
99,
111,
110,
116,
97,
105,
110,
115,
115,
117,
109,
119,
97,
108,
107,
108,
97,
115,
116,
107,
101,
101,
112,
79,
107,
115,
107,
101,
101,
112,
69,
114,
114,
115,
109,
97,
112,
87,
105,
116,
104,
73,
110,
100,
101,
120,
109,
97,
112,
50,
109,
97,
112,
51,
112,
114,
111,
100,
117,
99,
116,
119,
97,
108,
107,
85,
110,
116,
105,
108,
114,
97,
110,
103,
101,
115,
111,
114,
116,
87,
105,
116,
104,
99,
104,
117,
110,
107,
115,
79,
102,
115,
119,
97,
112,
100,
114,
111,
112,
65,
116,
100,
114,
111,
112,
76,
97,
115,
116,
109,
105,
110,
35,
109,
105,
110,
108,
116,
109,
97,
120,
35,
109,
97,
120,
71,
116,
109,
97,
112,
52,
100,
114,
111,
112,
70,
105,
114,
115,
116,
106,
111,
105,
110,
77,
97,
112,
35,
106,
111,
105,
110,
77,
97,
112,
67,
111,
110,
99,
97,
116,
97,
110,
121,
116,
97,
107,
101,
70,
105,
114,
115,
116,
116,
97,
107,
101,
76,
97,
115,
116,
102,
105,
110,
100,
70,
105,
114,
115,
116,
102,
105,
110,
100,
76,
97,
115,
116,
102,
105,
110,
100,
70,
105,
114,
115,
116,
73,
110,
100,
101,
120,
102,
105,
110,
100,
76,
97,
115,
116,
73,
110,
100,
101,
120,
35,
102,
105,
110,
100,
95,
114,
101,
115,
117,
108,
116,
115,
117,
98,
108,
105,
115,
116,
105,
110,
116,
101,
114,
115,
112,
101,
114,
115,
101,
35,
105,
110,
116,
101,
114,
115,
112,
101,
114,
115,
101,
67,
108,
111,
115,
115,
112,
108,
105,
116,
115,
112,
108,
105,
116,
70,
105,
114,
115,
116,
115,
112,
108,
105,
116,
76,
97,
115,
116,
35,
115,
112,
108,
105,
116,
67,
108,
111,
115,
97,
108,
108,
100,
114,
111,
112,
73,
102,
35,
100,
114,
111,
112,
73,
102,
80,
114,
101,
100,
115,
111,
114,
116,
65,
115,
99,
115,
111,
114,
116,
68,
101,
115,
99,
35,
115,
111,
114,
116,
68,
101,
115,
99,
67,
111,
109,
112,
97,
114,
101,
115,
116,
97,
114,
116,
115,
87,
105,
116,
104,
101,
110,
100,
115,
87,
105,
116,
104,
114,
101,
112,
108,
97,
99,
101,
35,
105,
115,
85,
110,
105,
113,
117,
101,
103,
101,
116,
85,
110,
115,
97,
102,
101,
114,
101,
112,
108,
97,
99,
101,
85,
110,
115,
97,
102,
101,
119,
105,
116,
104,
67,
97,
112,
97,
99,
105,
116,
121,
117,
110,
114,
101,
97,
99,
104,
97,
98,
108,
101,
114,
101,
115,
101,
114,
118,
101,
97,
112,
112,
101,
110,
100,
85,
110,
115,
97,
102,
101,
115,
117,
98,
108,
105,
115,
116,
76,
111,
119,
108,
101,
118,
101,
108,
99,
97,
112,
97,
99,
105,
116,
121,
109,
97,
112,
84,
114,
121,
119,
97,
108,
107,
84,
114,
121,
119,
97,
108,
107,
66,
97,
99,
107,
119,
97,
114,
100,
115,
85,
110,
116,
105,
108,
99,
111,
117,
110,
116,
73,
102,
119,
97,
108,
107,
70,
114,
111,
109,
119,
97,
108,
107,
70,
114,
111,
109,
85,
110,
116,
105,
108,
105,
116,
101,
114,
72,
101,
108,
112,
114,
101,
108,
101,
97,
115,
101,
69,
120,
99,
101,
115,
115,
67,
97,
112,
97,
99,
105,
116,
121,
117,
112,
100,
97,
116,
101,
119,
97,
108,
107,
87,
105,
116,
104,
73,
110,
100,
101,
120,
97,
112,
112,
101,
110,
100,
73,
102,
79,
107,
112,
114,
101,
112,
101,
110,
100,
73,
102,
79,
107,
119,
97,
108,
107,
87,
105,
116,
104,
73,
110,
100,
101,
120,
85,
110,
116,
105,
108,
99,
108,
111,
110,
101,
108,
101,
110,
85,
115,
105,
122,
101,
114,
101,
112,
101,
97,
116,
72,
101,
108,
112,
114,
101,
118,
101,
114,
115,
101,
72,
101,
108,
112,
119,
97,
108,
107,
72,
101,
108,
112,
119,
97,
108,
107,
87,
105,
116,
104,
73,
110,
100,
101,
120,
72,
101,
108,
112,
119,
97,
108,
107,
87,
105,
116,
104,
73,
110,
100,
101,
120,
85,
110,
116,
105,
108,
72,
101,
108,
112,
119,
97,
108,
107,
66,
97,
99,
107,
119,
97,
114,
100,
115,
72,
101,
108,
112,
107,
101,
101,
112,
73,
102,
72,
101,
108,
112,
109,
97,
112,
87,
105,
116,
104,
73,
110,
100,
101,
120,
72,
101,
108,
112,
114,
97,
110,
103,
101,
72,
101,
108,
112,
114,
97,
110,
103,
101,
76,
101,
110,
103,
116,
104,
72,
101,
108,
112,
109,
105,
110,
72,
101,
108,
112,
109,
97,
120,
72,
101,
108,
112,
99,
104,
117,
110,
107,
115,
79,
102,
72,
101,
108,
112,
119,
97,
108,
107,
84,
114,
121,
72,
101,
108,
112,
105,
116,
101,
114,
97,
116,
101,
105,
116,
101,
114,
97,
116,
101,
66,
97,
99,
107,
119,
97,
114,
100,
115,
105,
116,
101,
114,
66,
97,
99,
107,
119,
97,
114,
100,
115,
72,
101,
108,
112,
108,
105,
115,
116,
105,
110,
100,
101,
120,
49,
48,
57,
49,
49,
48,
49,
49,
49,
110,
101,
119,
86,
97,
108,
117,
101,
118,
97,
108,
117,
101,
102,
117,
110,
99,
101,
108,
101,
109,
101,
110,
116,
114,
101,
115,
117,
108,
116,
101,
108,
101,
109,
118,
49,
51,
51,
49,
51,
52,
49,
51,
53,
120,
99,
111,
117,
110,
116,
97,
99,
99,
117,
109,
101,
110,
100,
108,
101,
102,
116,
114,
105,
103,
104,
116,
108,
105,
115,
116,
115,
116,
111,
116,
97,
108,
76,
101,
110,
103,
116,
104,
49,
52,
57,
115,
116,
97,
116,
101,
49,
53,
50,
110,
101,
101,
100,
108,
101,
49,
53,
55,
105,
110,
105,
116,
102,
108,
101,
110,
103,
116,
104,
110,
101,
120,
116,
83,
116,
97,
116,
101,
110,
101,
119,
98,
49,
56,
57,
49,
57,
48,
105,
110,
100,
101,
120,
80,
108,
117,
115,
79,
110,
101,
105,
110,
105,
116,
105,
97,
108,
115,
116,
101,
112,
99,
117,
114,
114,
101,
110,
116,
83,
116,
97,
116,
101,
50,
49,
55,
112,
114,
101,
100,
105,
99,
97,
116,
101,
108,
111,
111,
112,
101,
114,
50,
51,
49,
50,
51,
50,
50,
51,
55,
50,
51,
56,
107,
101,
112,
116,
50,
52,
57,
101,
119,
97,
108,
107,
83,
116,
97,
116,
101,
116,
111,
82,
101,
115,
117,
108,
116,
119,
97,
108,
107,
101,
114,
107,
101,
101,
112,
115,
114,
99,
100,
101,
115,
116,
109,
97,
112,
112,
101,
100,
69,
108,
101,
109,
110,
101,
119,
68,
101,
115,
116,
115,
116,
97,
114,
116,
99,
97,
108,
99,
78,
101,
120,
116,
115,
116,
101,
112,
73,
115,
80,
111,
115,
105,
116,
105,
118,
101,
105,
110,
99,
108,
117,
115,
105,
118,
101,
83,
116,
97,
114,
116,
50,
56,
54,
121,
120,
121,
120,
121,
120,
121,
50,
57,
53,
105,
50,
57,
55,
50,
57,
57,
51,
48,
49,
51,
48,
52,
97,
116,
105,
115,
86,
97,
108,
105,
100,
51,
48,
56,
51,
49,
48,
98,
101,
102,
111,
114,
101,
51,
49,
52,
51,
49,
54,
108,
118,
97,
108,
114,
101,
109,
97,
105,
110,
105,
110,
103,
51,
51,
49,
97,
51,
51,
54,
51,
51,
55,
51,
51,
56,
111,
117,
116,
112,
117,
116,
76,
101,
110,
103,
116,
104,
110,
51,
53,
49,
51,
53,
50,
51,
53,
51,
51,
53,
54,
98,
101,
115,
116,
83,
111,
70,
97,
114,
99,
117,
114,
114,
101,
110,
116,
51,
54,
49,
51,
54,
50,
51,
54,
51,
51,
54,
54,
109,
97,
112,
112,
101,
114,
51,
55,
49,
112,
114,
101,
100,
99,
97,
108,
108,
98,
97,
99,
107,
51,
55,
56,
51,
55,
57,
51,
56,
48,
51,
56,
49,
102,
111,
117,
110,
100,
51,
56,
51,
51,
56,
56,
51,
56,
57,
51,
57,
48,
51,
57,
49,
51,
57,
51,
109,
97,
116,
99,
104,
101,
114,
102,
111,
117,
110,
100,
73,
110,
100,
101,
120,
51,
57,
55,
52,
48,
48,
52,
48,
49,
52,
48,
51,
52,
48,
52,
52,
48,
53,
109,
97,
116,
99,
104,
101,
115,
52,
48,
57,
112,
114,
101,
118,
73,
110,
100,
101,
120,
97,
110,
115,
119,
101,
114,
52,
49,
51,
52,
49,
52,
52,
49,
54,
52,
49,
55,
52,
49,
56,
99,
111,
110,
102,
105,
103,
115,
101,
112,
110,
101,
119,
76,
105,
115,
116,
52,
50,
53,
97,
99,
99,
112,
114,
101,
102,
105,
120,
115,
117,
102,
102,
105,
120,
101,
108,
101,
109,
101,
110,
116,
115,
117,
115,
101,
114,
83,
112,
108,
105,
116,
73,
110,
100,
101,
120,
115,
112,
108,
105,
116,
73,
110,
100,
101,
120,
111,
116,
104,
101,
114,
115,
100,
101,
108,
105,
109,
105,
116,
101,
114,
52,
52,
50,
97,
102,
116,
101,
114,
52,
52,
55,
52,
52,
56,
52,
52,
57,
52,
53,
50,
52,
53,
55,
52,
53,
56,
52,
53,
57,
99,
104,
117,
110,
107,
83,
105,
122,
101,
99,
104,
117,
110,
107,
67,
97,
112,
97,
99,
105,
116,
121,
108,
105,
115,
116,
82,
101,
115,
116,
99,
104,
117,
110,
107,
115,
52,
55,
48,
52,
55,
51,
111,
107,
52,
56,
53,
52,
56,
54,
52,
57,
55,
52,
57,
56,
53,
48,
57,
53,
49,
48,
103,
111,
116,
119,
97,
110,
116,
53,
49,
52,
53,
49,
56,
53,
50,
51,
53,
50,
53,
53,
50,
55,
53,
50,
57,
53,
51,
48,
53,
51,
49,
53,
51,
50,
53,
51,
51,
53,
51,
52,
53,
51,
53,
53,
51,
54,
53,
51,
55,
53,
51,
56,
53,
51,
57,
53,
52,
48,
53,
52,
49,
53,
52,
50,
53,
52,
51,
53,
52,
52,
53,
52,
53,
53,
52,
54,
53,
52,
55,
53,
52,
56,
53,
52,
57,
53,
53,
48,
53,
53,
49,
53,
53,
50,
53,
53,
51,
53,
53,
52,
53,
53,
53,
53,
53,
54,
53,
53,
55,
53,
53,
56,
53,
53,
57,
53,
54,
48,
53,
54,
49,
53,
54,
50,
53,
54,
51,
53,
54,
52,
53,
54,
53,
53,
54,
54,
53,
54,
55,
53,
54,
56,
53,
54,
57,
53,
55,
48,
],
lengths: [
Interned(4),
Interned(7),
Interned(3),
Interned(3),
Interned(6),
Interned(3),
Interned(3),
Interned(13),
Interned(6),
Interned(5),
Interned(6),
Interned(6),
Interned(7),
Interned(7),
Interned(4),
Interned(6),
Interned(8),
Interned(3),
Interned(4),
Interned(4),
Interned(7),
Interned(8),
Interned(12),
Interned(4),
Interned(4),
Interned(7),
Interned(9),
Interned(5),
Interned(8),
Interned(8),
Interned(4),
Interned(6),
Interned(8),
Interned(3),
Interned(6),
Interned(3),
Interned(6),
Interned(4),
Interned(9),
Interned(7),
Interned(14),
Interned(3),
Interned(9),
Interned(8),
Interned(9),
Interned(8),
Interned(14),
Interned(13),
Interned(12),
Interned(7),
Interned(11),
Interned(16),
Interned(5),
Interned(10),
Interned(9),
Interned(10),
Interned(3),
Interned(6),
Interned(11),
Interned(7),
Interned(8),
Interned(16),
Interned(10),
Interned(8),
Interned(7),
Interned(9),
Interned(9),
Interned(13),
Interned(12),
Interned(11),
Interned(7),
Interned(12),
Interned(15),
Interned(8),
Interned(6),
Interned(7),
Interned(18),
Interned(7),
Interned(8),
Interned(13),
Interned(8),
Interned(21),
Interned(6),
Interned(13),
Interned(10),
Interned(11),
Interned(18),
Interned(5),
Interned(8),
Interned(10),
Interned(11),
Interned(8),
Interned(17),
Interned(22),
Interned(17),
Interned(10),
Interned(16),
Interned(9),
Interned(15),
Interned(7),
Interned(7),
Interned(12),
Interned(11),
Interned(7),
Interned(16),
Interned(17),
Interned(4),
Interned(4),
Interned(5),
Generated(3),
Generated(3),
Generated(3),
Interned(4),
Interned(5),
Interned(8),
Interned(4),
Interned(5),
Interned(5),
Interned(4),
Interned(5),
Interned(4),
Interned(5),
Interned(8),
Interned(4),
Interned(7),
Interned(4),
Interned(6),
Interned(4),
Interned(4),
Interned(6),
Interned(4),
Interned(4),
Interned(1),
Generated(3),
Generated(3),
Generated(3),
Interned(1),
Interned(5),
Interned(5),
Interned(5),
Interned(5),
Interned(5),
Interned(4),
Interned(3),
Interned(4),
Interned(4),
Interned(5),
Interned(5),
Interned(11),
Generated(3),
Interned(5),
Interned(4),
Generated(3),
Interned(5),
Interned(4),
Interned(4),
Interned(6),
Generated(3),
Interned(1),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(5),
Interned(1),
Interned(5),
Interned(6),
Interned(9),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(5),
Interned(1),
Interned(5),
Interned(6),
Interned(9),
Interned(4),
Interned(5),
Interned(1),
Interned(3),
Interned(3),
Interned(4),
Interned(5),
Interned(1),
Interned(5),
Interned(6),
Interned(9),
Interned(1),
Generated(3),
Generated(3),
Interned(4),
Interned(5),
Interned(4),
Interned(4),
Interned(5),
Interned(1),
Interned(12),
Interned(5),
Interned(9),
Interned(4),
Interned(7),
Interned(4),
Interned(3),
Interned(3),
Interned(4),
Interned(7),
Interned(4),
Interned(3),
Interned(3),
Interned(4),
Interned(5),
Interned(5),
Interned(4),
Interned(4),
Interned(12),
Interned(7),
Generated(3),
Interned(3),
Interned(4),
Interned(5),
Interned(5),
Interned(4),
Interned(3),
Interned(3),
Interned(4),
Interned(4),
Interned(4),
Interned(9),
Interned(6),
Interned(7),
Generated(3),
Generated(3),
Interned(4),
Interned(9),
Interned(6),
Interned(7),
Generated(3),
Generated(3),
Interned(4),
Interned(9),
Interned(6),
Interned(4),
Interned(9),
Interned(4),
Interned(5),
Interned(6),
Interned(4),
Interned(9),
Generated(3),
Interned(1),
Interned(4),
Interned(9),
Interned(9),
Interned(5),
Interned(4),
Interned(4),
Interned(8),
Interned(6),
Interned(5),
Interned(7),
Interned(4),
Interned(4),
Interned(8),
Interned(6),
Interned(5),
Interned(7),
Interned(4),
Interned(3),
Interned(4),
Interned(6),
Interned(4),
Interned(3),
Interned(4),
Interned(4),
Interned(5),
Interned(6),
Interned(4),
Interned(10),
Interned(7),
Interned(5),
Interned(3),
Interned(4),
Interned(8),
Interned(14),
Interned(14),
Generated(3),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Generated(3),
Interned(1),
Generated(3),
Interned(1),
Generated(3),
Interned(1),
Generated(3),
Interned(1),
Interned(1),
Generated(3),
Interned(1),
Interned(2),
Interned(7),
Generated(3),
Interned(1),
Generated(3),
Interned(1),
Interned(6),
Interned(7),
Generated(3),
Interned(1),
Generated(3),
Interned(1),
Interned(1),
Interned(5),
Interned(1),
Interned(8),
Interned(7),
Interned(3),
Interned(5),
Interned(1),
Interned(9),
Interned(8),
Interned(3),
Interned(4),
Interned(4),
Generated(3),
Interned(1),
Interned(1),
Interned(4),
Interned(1),
Generated(3),
Generated(3),
Generated(3),
Interned(4),
Interned(12),
Interned(4),
Interned(12),
Interned(4),
Interned(1),
Interned(9),
Interned(4),
Interned(1),
Interned(9),
Interned(4),
Interned(7),
Generated(3),
Generated(3),
Generated(3),
Interned(4),
Interned(7),
Generated(3),
Interned(9),
Interned(7),
Interned(4),
Interned(7),
Generated(3),
Generated(3),
Generated(3),
Interned(4),
Interned(7),
Generated(3),
Interned(9),
Interned(7),
Interned(4),
Interned(6),
Generated(3),
Interned(5),
Interned(4),
Interned(4),
Interned(4),
Interned(8),
Interned(4),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Interned(5),
Generated(3),
Interned(4),
Interned(4),
Interned(8),
Interned(4),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Interned(5),
Generated(3),
Interned(4),
Interned(7),
Interned(10),
Generated(3),
Interned(5),
Interned(4),
Generated(3),
Generated(3),
Interned(5),
Generated(3),
Generated(3),
Generated(3),
Interned(4),
Interned(7),
Interned(10),
Generated(3),
Interned(9),
Interned(4),
Interned(6),
Generated(3),
Generated(3),
Interned(5),
Generated(3),
Generated(3),
Generated(3),
Interned(4),
Interned(6),
Interned(4),
Interned(3),
Interned(4),
Interned(7),
Generated(3),
Interned(3),
Interned(4),
Interned(4),
Interned(6),
Interned(4),
Interned(6),
Interned(6),
Interned(5),
Interned(8),
Interned(14),
Interned(6),
Interned(10),
Interned(6),
Interned(6),
Interned(4),
Interned(9),
Generated(3),
Interned(4),
Interned(5),
Interned(6),
Interned(5),
Generated(3),
Generated(3),
Generated(3),
Interned(4),
Interned(9),
Generated(3),
Interned(4),
Interned(5),
Interned(6),
Interned(5),
Generated(3),
Generated(3),
Generated(3),
Interned(4),
Interned(9),
Interned(13),
Interned(8),
Interned(9),
Interned(6),
Interned(6),
Interned(6),
Interned(4),
Interned(8),
Generated(3),
Interned(5),
Interned(4),
Generated(3),
Interned(2),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(5),
Interned(1),
Interned(5),
Interned(6),
Interned(9),
Interned(1),
Generated(3),
Generated(3),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(5),
Interned(1),
Interned(5),
Interned(6),
Interned(9),
Interned(1),
Generated(3),
Generated(3),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(5),
Interned(1),
Interned(9),
Interned(5),
Interned(9),
Interned(1),
Generated(3),
Generated(3),
Interned(4),
Interned(3),
Interned(4),
Generated(3),
Interned(1),
Interned(4),
Interned(3),
Generated(3),
Interned(1),
Interned(4),
Interned(3),
Interned(4),
Generated(3),
Interned(1),
Generated(3),
Interned(1),
Generated(3),
Interned(1),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
],
offsets: [
0,
4,
11,
14,
17,
23,
26,
29,
42,
48,
53,
59,
65,
72,
79,
83,
89,
97,
100,
104,
108,
115,
123,
135,
139,
143,
150,
159,
164,
172,
180,
184,
190,
198,
201,
207,
210,
216,
220,
229,
236,
250,
253,
262,
270,
279,
287,
301,
314,
326,
333,
344,
360,
365,
375,
384,
394,
397,
403,
414,
421,
429,
445,
455,
463,
470,
479,
488,
501,
513,
524,
531,
543,
558,
566,
572,
579,
597,
604,
612,
625,
633,
654,
660,
673,
683,
694,
712,
717,
725,
735,
746,
754,
771,
793,
810,
820,
836,
845,
860,
867,
874,
886,
897,
904,
920,
937,
937,
941,
946,
949,
952,
937,
941,
955,
937,
941,
963,
937,
941,
968,
963,
955,
937,
972,
937,
979,
985,
937,
979,
985,
937,
989,
990,
993,
996,
999,
963,
1000,
963,
1000,
1005,
937,
1010,
937,
1013,
1017,
1022,
1027,
1038,
1041,
937,
1046,
1041,
937,
937,
1049,
1055,
999,
937,
1058,
968,
937,
1041,
1062,
941,
1063,
1069,
937,
1058,
968,
937,
1041,
1062,
941,
1063,
1069,
937,
1041,
1062,
1078,
1078,
937,
1041,
1062,
941,
1063,
1069,
1081,
1082,
1085,
937,
1041,
968,
937,
1041,
1062,
1088,
941,
1069,
937,
1100,
1107,
1078,
1078,
937,
1100,
968,
1078,
1078,
937,
941,
1041,
968,
1107,
1111,
972,
1123,
1078,
937,
941,
1041,
968,
1078,
1078,
937,
937,
937,
1126,
1135,
972,
1141,
1144,
937,
1126,
1135,
972,
1147,
1150,
937,
1126,
1063,
937,
1126,
1153,
941,
1063,
937,
1126,
1157,
1160,
937,
1126,
1161,
1041,
985,
937,
1170,
1178,
1005,
972,
1184,
937,
1170,
1178,
1005,
972,
1184,
1188,
968,
1063,
1191,
1188,
1191,
968,
941,
1063,
985,
1195,
1205,
1212,
1010,
1107,
1217,
1225,
1239,
1253,
999,
1256,
1257,
1258,
1259,
1260,
1261,
1262,
1263,
1266,
1267,
1266,
1270,
1266,
1273,
1266,
1261,
1276,
1261,
1279,
1281,
1288,
1266,
1291,
1266,
1294,
1281,
1300,
1266,
1303,
1266,
1306,
1005,
1266,
1217,
1281,
1307,
1005,
1266,
1310,
1217,
1307,
937,
937,
1319,
1322,
1081,
937,
989,
1323,
1326,
1329,
937,
1332,
937,
1332,
937,
1344,
1310,
937,
1344,
1310,
937,
1100,
1345,
1348,
1351,
937,
1100,
1354,
1357,
1366,
937,
1100,
1373,
1376,
1379,
937,
1100,
1382,
1357,
1366,
937,
1385,
1391,
1041,
985,
937,
1394,
1398,
985,
1406,
1409,
1412,
1415,
1418,
1423,
937,
1394,
1398,
985,
1426,
1429,
1432,
1435,
1418,
1438,
937,
1441,
1448,
1458,
941,
985,
1461,
1464,
941,
1467,
1470,
1473,
937,
1476,
1448,
1483,
1486,
985,
1495,
1501,
1504,
941,
1507,
1510,
1513,
937,
1516,
937,
1522,
1058,
1525,
1532,
1535,
985,
937,
1538,
937,
1544,
1063,
1212,
1550,
1558,
1063,
1572,
1294,
1582,
937,
1588,
1597,
985,
941,
1294,
1600,
1605,
1608,
1611,
937,
1588,
1614,
985,
941,
1294,
1600,
1617,
1620,
1623,
937,
1626,
1635,
1648,
1626,
1656,
1294,
1582,
937,
1170,
1662,
1041,
985,
1665,
1668,
937,
1058,
968,
937,
1041,
1062,
941,
1063,
1069,
1081,
1670,
1673,
937,
1058,
968,
937,
1041,
1062,
941,
1063,
1069,
1081,
1676,
1679,
937,
1058,
968,
937,
1041,
1062,
1486,
941,
1069,
1081,
1682,
1685,
937,
1688,
1691,
1695,
1261,
937,
1688,
1698,
1261,
937,
1688,
1691,
1701,
1261,
1704,
1261,
1707,
1261,
1710,
1713,
1716,
1719,
1722,
1725,
1728,
1731,
1734,
1737,
1740,
1743,
1746,
1749,
1752,
1755,
1758,
1761,
1764,
1767,
1770,
1773,
1776,
1779,
1782,
1785,
1788,
1791,
1794,
1797,
1800,
1803,
1806,
1809,
1812,
1815,
1818,
1821,
1824,
1827,
1830,
1833,
],
strings: [
"List",
"isEmpty",
"get",
"set",
"append",
"map",
"len",
"walkBackwards",
"concat",
"first",
"single",
"repeat",
"reverse",
"prepend",
"join",
"keepIf",
"contains",
"sum",
"walk",
"last",
"keepOks",
"keepErrs",
"mapWithIndex",
"map2",
"map3",
"product",
"walkUntil",
"range",
"sortWith",
"chunksOf",
"swap",
"dropAt",
"dropLast",
"min",
"#minlt",
"max",
"#maxGt",
"map4",
"dropFirst",
"joinMap",
"#joinMapConcat",
"any",
"takeFirst",
"takeLast",
"findFirst",
"findLast",
"findFirstIndex",
"findLastIndex",
"#find_result",
"sublist",
"intersperse",
"#intersperseClos",
"split",
"splitFirst",
"splitLast",
"#splitClos",
"all",
"dropIf",
"#dropIfPred",
"sortAsc",
"sortDesc",
"#sortDescCompare",
"startsWith",
"endsWith",
"replace",
"#isUnique",
"getUnsafe",
"replaceUnsafe",
"withCapacity",
"unreachable",
"reserve",
"appendUnsafe",
"sublistLowlevel",
"capacity",
"mapTry",
"walkTry",
"walkBackwardsUntil",
"countIf",
"walkFrom",
"walkFromUntil",
"iterHelp",
"releaseExcessCapacity",
"update",
"walkWithIndex",
"appendIfOk",
"prependIfOk",
"walkWithIndexUntil",
"clone",
"lenUsize",
"repeatHelp",
"reverseHelp",
"walkHelp",
"walkWithIndexHelp",
"walkWithIndexUntilHelp",
"walkBackwardsHelp",
"keepIfHelp",
"mapWithIndexHelp",
"rangeHelp",
"rangeLengthHelp",
"minHelp",
"maxHelp",
"chunksOfHelp",
"walkTryHelp",
"iterate",
"iterateBackwards",
"iterBackwardsHelp",
"list",
"list",
"index",
"109",
"110",
"111",
"list",
"index",
"newValue",
"list",
"index",
"value",
"list",
"index",
"func",
"value",
"newValue",
"list",
"element",
"list",
"result",
"elem",
"list",
"result",
"elem",
"list",
"v",
"133",
"134",
"135",
"x",
"value",
"count",
"value",
"count",
"accum",
"list",
"end",
"list",
"left",
"right",
"lists",
"totalLength",
"149",
"state",
"list",
"152",
"state",
"list",
"list",
"needle",
"157",
"x",
"list",
"init",
"func",
"list",
"state",
"f",
"index",
"length",
"nextState",
"list",
"init",
"func",
"list",
"state",
"f",
"index",
"length",
"nextState",
"list",
"state",
"f",
"new",
"new",
"list",
"state",
"f",
"index",
"length",
"nextState",
"b",
"189",
"190",
"list",
"state",
"func",
"list",
"state",
"f",
"indexPlusOne",
"index",
"nextState",
"list",
"initial",
"step",
"new",
"new",
"list",
"initial",
"func",
"new",
"new",
"list",
"index",
"state",
"func",
"step",
"currentState",
"element",
"217",
"new",
"list",
"index",
"state",
"func",
"new",
"new",
"list",
"list",
"list",
"predicate",
"looper",
"element",
"231",
"232",
"list",
"predicate",
"looper",
"element",
"237",
"238",
"list",
"predicate",
"length",
"list",
"predicate",
"kept",
"index",
"length",
"list",
"predicate",
"249",
"e",
"list",
"predicate",
"walkState",
"state",
"elem",
"list",
"toResult",
"walker",
"accum",
"element",
"keep",
"list",
"toResult",
"walker",
"accum",
"element",
"keep",
"src",
"func",
"length",
"dest",
"src",
"dest",
"func",
"index",
"length",
"elem",
"mappedElem",
"newDest",
"start",
"end",
"step",
"calcNext",
"stepIsPositive",
"inclusiveStart",
"286",
"x",
"y",
"x",
"y",
"x",
"y",
"x",
"y",
"295",
"i",
"297",
"i",
"299",
"i",
"301",
"i",
"x",
"304",
"x",
"at",
"isValid",
"308",
"i",
"310",
"i",
"before",
"isValid",
"314",
"i",
"316",
"i",
"l",
"accum",
"i",
"calcNext",
"isValid",
"val",
"accum",
"i",
"remaining",
"calcNext",
"val",
"list",
"list",
"331",
"a",
"b",
"list",
"v",
"336",
"337",
"338",
"list",
"outputLength",
"list",
"outputLength",
"list",
"n",
"remaining",
"list",
"n",
"remaining",
"list",
"initial",
"351",
"352",
"353",
"list",
"initial",
"356",
"bestSoFar",
"current",
"list",
"initial",
"361",
"362",
"363",
"list",
"initial",
"366",
"bestSoFar",
"current",
"list",
"mapper",
"371",
"state",
"elem",
"list",
"pred",
"callback",
"elem",
"378",
"379",
"380",
"381",
"found",
"383",
"list",
"pred",
"callback",
"elem",
"388",
"389",
"390",
"391",
"found",
"393",
"list",
"matcher",
"foundIndex",
"397",
"index",
"elem",
"400",
"401",
"index",
"403",
"404",
"405",
"list",
"matches",
"foundIndex",
"409",
"prevIndex",
"elem",
"answer",
"413",
"414",
"index",
"416",
"417",
"418",
"list",
"config",
"list",
"sep",
"init",
"newList",
"425",
"acc",
"elem",
"list",
"prefix",
"list",
"suffix",
"length",
"start",
"elements",
"userSplitIndex",
"length",
"splitIndex",
"before",
"others",
"list",
"delimiter",
"442",
"elem",
"index",
"before",
"after",
"447",
"448",
"449",
"list",
"delimiter",
"452",
"elem",
"index",
"before",
"after",
"457",
"458",
"459",
"list",
"chunkSize",
"chunkCapacity",
"listRest",
"chunkSize",
"chunks",
"before",
"others",
"list",
"toResult",
"470",
"state",
"elem",
"473",
"ok",
"list",
"init",
"func",
"list",
"state",
"f",
"index",
"length",
"nextState",
"b",
"485",
"486",
"list",
"init",
"func",
"list",
"state",
"f",
"index",
"length",
"nextState",
"b",
"497",
"498",
"list",
"init",
"func",
"list",
"state",
"f",
"prevIndex",
"index",
"nextState",
"b",
"509",
"510",
"list",
"got",
"want",
"514",
"x",
"list",
"got",
"518",
"x",
"list",
"got",
"want",
"523",
"x",
"525",
"x",
"527",
"x",
"529",
"530",
"531",
"532",
"533",
"534",
"535",
"536",
"537",
"538",
"539",
"540",
"541",
"542",
"543",
"544",
"545",
"546",
"547",
"548",
"549",
"550",
"551",
"552",
"553",
"554",
"555",
"556",
"557",
"558",
"559",
"560",
"561",
"562",
"563",
"564",
"565",
"566",
"567",
"568",
"569",
"570",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffecf420f0,
head: 000000,
bits: 571,
capacity: 576,
} [
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
0,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
0,
1,
1,
1,
0,
1,
1,
0,
1,
1,
0,
1,
1,
1,
0,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
regions: [
…,
@8388-8395,
@8890-8893,
@9766-9769,
@11105-11111,
@25784-25787,
@12661-12664,
@18265-18278,
@13179-13185,
@33047-33052,
@13751-13757,
@13878-13884,
@14293-14300,
@11947-11954,
@14888-14892,
@22527-22533,
@15145-15153,
@20516-20519,
@16308-16312,
@13426-13430,
@24568-24575,
@25230-25238,
@26963-26975,
@26192-26196,
@26410-26414,
@20593-20600,
@19339-19348,
@28519-28524,
@32342-32350,
@43657-43665,
@32893-32897,
@35057-35063,
@34726-34734,
@35147-35150,
…,
@35570-35573,
…,
@26639-26643,
@34531-34540,
@36212-36219,
…,
@20792-20795,
@33689-33698,
@34306-34314,
@36517-36526,
@36974-36982,
@37480-37494,
@38019-38032,
…,
@39081-39088,
@39434-39445,
…,
@41473-41478,
@42194-42204,
@42967-42976,
…,
@21195-21198,
@23455-23461,
…,
@32585-32592,
@32826-32834,
…,
@40067-40077,
@40655-40663,
@9277-9284,
…,
@8568-8577,
@9156-9169,
@12741-12753,
…,
@12833-12840,
@11776-11788,
@39218-39233,
@39466-39474,
@44493-44499,
@45289-45296,
@19642-19660,
@23835-23842,
@19923-19931,
@20325-20338,
@46126-46134,
@13019-13040,
@10230-10236,
@16838-16851,
@11447-11457,
@12229-12240,
@17458-17476,
@14640-14645,
…,
@13996-14006,
@14399-14410,
@16457-16465,
@17019-17036,
@17751-17773,
@18447-18464,
@22684-22694,
@27177-27193,
@30291-30300,
@30764-30779,
@35348-35355,
@35771-35778,
@43948-43960,
@45485-45496,
@45934-45941,
@46616-46632,
@46828-46845,
@8399-8403,
@8897-8901,
@8903-8908,
…,
…,
…,
@9288-9292,
@9294-9299,
@9301-9309,
@9773-9777,
@9779-9784,
@9786-9791,
@10240-10244,
@10246-10251,
@10253-10257,
@10336-10341,
@10357-10365,
@11115-11119,
@11121-11128,
@11461-11465,
@11467-11473,
@11507-11511,
@12244-12248,
@12250-12256,
@12290-12294,
@13434-13438,
@13516-13517,
…,
…,
…,
@13761-13762,
@13888-13893,
@13895-13900,
@14010-14015,
@14017-14022,
@14024-14029,
@14304-14308,
@14316-14319,
@14414-14418,
@14420-14424,
@14426-14431,
@14896-14901,
@14909-14920,
…,
@14951-14956,
@14958-14962,
…,
@15055-15060,
@15062-15066,
@15157-15161,
@15163-15169,
…,
@15193-15194,
@16316-16320,
@16322-16326,
@16328-16332,
@16469-16473,
@16475-16480,
@16482-16483,
@16485-16490,
@16492-16498,
@16537-16546,
@16855-16859,
@16861-16865,
@16867-16871,
@17040-17044,
@17046-17051,
@17053-17054,
@17056-17061,
@17063-17069,
@17108-17117,
@17480-17484,
@17486-17491,
@17493-17494,
@17581-17584,
@17606-17609,
@17777-17781,
@17783-17788,
@17790-17791,
@17793-17798,
@17800-17806,
@17916-17925,
@18033-18034,
…,
…,
@18282-18286,
@18288-18293,
@18295-18299,
@18468-18472,
@18474-18479,
@18481-18482,
@18484-18496,
@18561-18566,
@18604-18613,
@19352-19356,
@19358-19365,
@19367-19371,
@19435-19438,
@19460-19463,
@19664-19668,
@19670-19677,
@19679-19683,
@19756-19759,
@19781-19784,
@19935-19939,
@19941-19946,
@19948-19953,
@19955-19959,
@20009-20013,
@20017-20029,
@20031-20038,
…,
@20161-20164,
@20342-20346,
@20348-20353,
@20355-20360,
@20362-20366,
@20451-20454,
@20476-20479,
@20523-20527,
@20604-20608,
@20799-20803,
@20805-20814,
@20822-20828,
@20836-20843,
…,
…,
@21202-21206,
@21208-21217,
@21225-21231,
@21239-21246,
…,
…,
@22537-22541,
@22543-22552,
@22560-22566,
@22698-22702,
@22704-22713,
@22715-22719,
@22721-22726,
@22728-22734,
@23465-23469,
@23471-23480,
…,
@23507-23508,
@23846-23850,
@23852-23861,
@23869-23878,
@23882-23887,
@23889-23893,
@24579-24583,
@24585-24593,
@24601-24607,
@24611-24616,
@24618-24625,
@24677-24681,
@25242-25246,
@25248-25256,
@25264-25270,
@25274-25279,
@25281-25288,
@25371-25375,
@26979-26982,
@26984-26988,
@26996-27002,
@27017-27021,
@27197-27200,
@27202-27206,
@27208-27212,
@27214-27219,
@27221-27227,
@27266-27270,
@27301-27311,
@27338-27345,
@28528-28552,
@28528-28552,
@28528-28552,
@28560-28588,
@28560-28588,
@29517-29531,
…,
@28671-28672,
@28678-28679,
@28689-28690,
@28700-28701,
@28714-28715,
@28721-28722,
@28735-28736,
@28746-28747,
…,
@28851-28852,
…,
@29047-29048,
…,
@29276-29277,
…,
@29428-29429,
@29571-29572,
…,
@29599-29600,
@29643-29645,
@29661-29668,
…,
@29731-29732,
…,
@29786-29787,
@29921-29927,
@29943-29950,
…,
@30013-30014,
…,
@30071-30072,
@30209-30210,
@30304-30309,
@30311-30312,
@30314-30322,
@30324-30331,
@30360-30363,
@30783-30788,
@30790-30791,
@30793-30802,
@30804-30812,
@30899-30902,
@32596-32600,
@32838-32842,
…,
@32867-32868,
@32870-32871,
@33056-33060,
@33103-33104,
…,
…,
…,
@33702-33706,
@33708-33720,
@34318-34322,
@34324-34336,
@34544-34548,
@34550-34551,
@34559-34568,
@34738-34742,
@34744-34745,
@34753-34762,
@35154-35158,
@35201-35208,
…,
…,
…,
@35359-35363,
@35365-35372,
…,
@35404-35413,
@35415-35422,
@35577-35581,
@35624-35631,
…,
…,
…,
@35782-35786,
@35788-35795,
…,
@35827-35836,
@35838-35845,
@36223-36227,
@36229-36235,
…,
@36262-36267,
@36269-36273,
@36530-36534,
@36536-36540,
@36548-36556,
@36563-36567,
…,
…,
…,
…,
@36750-36755,
…,
@36986-36990,
@36992-36996,
@37004-37012,
@37019-37023,
…,
…,
…,
…,
@37215-37220,
…,
@37498-37502,
@37504-37511,
@37519-37529,
…,
@37553-37558,
@37560-37564,
…,
…,
@37715-37720,
…,
…,
…,
@38036-38040,
@38042-38049,
@38057-38067,
…,
@38114-38123,
@38125-38129,
@38141-38147,
…,
…,
@38308-38313,
…,
…,
…,
@39092-39096,
@39098-39104,
@39449-39453,
@39455-39458,
@39499-39503,
@39537-39544,
…,
@39576-39579,
@39581-39585,
@40081-40085,
@40087-40093,
@40667-40671,
@40673-40679,
@40826-40832,
@40855-40860,
@41482-41490,
@41492-41506,
@41514-41520,
@41545-41555,
@41621-41627,
@41686-41692,
@42208-42212,
@42214-42223,
…,
@42263-42267,
@42304-42309,
@42325-42331,
@42389-42394,
…,
…,
…,
@42980-42984,
@42986-42995,
…,
@43034-43038,
@43075-43080,
@43096-43102,
@43160-43165,
…,
…,
…,
@43669-43673,
@43675-43684,
@43764-43777,
@43964-43972,
@43974-43983,
@43985-43991,
@44061-44079,
@44061-44079,
@44503-44507,
@44509-44517,
…,
@44542-44547,
@44549-44553,
…,
@44593-44595,
@45300-45304,
@45306-45310,
@45312-45316,
@45500-45504,
@45506-45511,
@45513-45514,
@45516-45521,
@45523-45529,
@45627-45636,
@45714-45715,
…,
…,
@45945-45949,
@45951-45955,
@45957-45961,
@46138-46142,
@46144-46149,
@46151-46152,
@46154-46159,
@46161-46167,
@46271-46280,
@46357-46358,
…,
…,
@46636-46640,
@46642-46646,
@46648-46652,
@46849-46853,
@46855-46860,
@46862-46863,
@46865-46874,
@46912-46917,
@47018-47027,
@47090-47091,
…,
…,
@10495-10499,
@10516-10519,
@10555-10559,
…,
@10538-10539,
@10644-10648,
@10665-10668,
…,
@10687-10688,
@10763-10767,
@10784-10787,
@10912-10916,
…,
@10825-10826,
…,
@10860-10861,
…,
@10895-10896,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
],
home: List,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`List.isEmpty`,
`List.get`,
`List.set`,
`List.replace`,
`List.update`,
`List.append`,
`List.appendIfOk`,
`List.prepend`,
`List.prependIfOk`,
`List.map`,
`List.len`,
`List.withCapacity`,
`List.walkBackwards`,
`List.concat`,
`List.first`,
`List.single`,
`List.repeat`,
`List.reverse`,
`List.join`,
`List.keepIf`,
`List.contains`,
`List.sum`,
`List.walk`,
`List.last`,
`List.keepOks`,
`List.keepErrs`,
`List.mapWithIndex`,
`List.map2`,
`List.map3`,
`List.product`,
`List.walkWithIndex`,
`List.walkUntil`,
`List.walkWithIndexUntil`,
`List.walkFrom`,
`List.walkFromUntil`,
`List.range`,
`List.sortWith`,
`List.swap`,
`List.dropAt`,
`List.min`,
`List.max`,
`List.map4`,
`List.mapTry`,
`List.walkTry`,
`List.joinMap`,
`List.any`,
`List.takeFirst`,
`List.takeLast`,
`List.dropFirst`,
`List.dropLast`,
`List.findFirst`,
`List.findLast`,
`List.findFirstIndex`,
`List.findLastIndex`,
`List.sublist`,
`List.intersperse`,
`List.split`,
`List.splitFirst`,
`List.splitLast`,
`List.startsWith`,
`List.endsWith`,
`List.all`,
`List.dropIf`,
`List.sortAsc`,
`List.sortDesc`,
`List.reserve`,
`List.releaseExcessCapacity`,
`List.walkBackwardsUntil`,
`List.countIf`,
`List.chunksOf`,
],
},
},
<<docs:
Some(
"Error types when decoding a `List U8` of utf-8 bytes using a [Decoder]\n",
)
docs>>
<<docs:
Some(
"Return type of a [Decoder].\n\nThis can be useful when creating a [custom](#custom) decoder or when\nusing [fromBytesPartial](#fromBytesPartial). For example writing unit tests,\nsuch as;\n```\nexpect\n input = \"\\\"hello\\\", \" |> Str.toUtf8\n actual = Decode.fromBytesPartial input Json.json\n expected = Ok \"hello\"\n\n actual.result == expected\n```\n",
)
docs>>
<<docs:
Some(
"Decodes a `List U8` of utf-8 bytes where `val` is the type of the decoded\nvalue, and `fmt` is a [Decoder] which implements the [DecoderFormatting]\nability\n",
)
docs>>
<<docs:
Some(
"Definition of the [Decoding] ability\n",
)
docs>>
<<docs:
Some(
"Definition of the [DecoderFormatting] ability\n",
)
docs>>
<<docs:
Some(
"Build a custom [Decoder] function. For example the implementation of\n`decodeBool` could be defined as follows;\n\n```\ndecodeBool = Decode.custom \\bytes, @Json {} ->\n when bytes is\n ['f', 'a', 'l', 's', 'e', ..] -> { result: Ok Bool.false, rest: List.dropFirst bytes 5 }\n ['t', 'r', 'u', 'e', ..] -> { result: Ok Bool.true, rest: List.dropFirst bytes 4 }\n _ -> { result: Err TooShort, rest: bytes }\n```\n",
)
docs>>
<<docs:
Some(
"Decode a `List U8` utf-8 bytes using a specific [Decoder] function\n",
)
docs>>
<<docs:
Some(
"Decode a `List U8` utf-8 bytes and return a [DecodeResult](#DecodeResult)\n```\nexpect\n input = \"\\\"hello\\\", \" |> Str.toUtf8\n actual = Decode.fromBytesPartial input Json.json\n expected = Ok \"hello\"\n\n actual.result == expected\n```\n",
)
docs>>
<<docs:
Some(
"Decode a `List U8` utf-8 bytes and return a [Result] with no leftover bytes\nexpected. If successful returns `Ok val`, however, if there are bytes\nremaining returns `Err Leftover (List U8)`.\n```\nexpect\n input = \"\\\"hello\\\", \" |> Str.toUtf8\n actual = Decode.fromBytes input Json.json\n expected = Ok \"hello\"\n\n actual == expected\n```\n",
)
docs>>
<<docs:
Some(
"Transform the `val` of a [DecodeResult]\n",
)
docs>>
adding docs for "Decode.roc",
docs ModuleDocumentation {
name: "Decode",
entries: [
DocDef(
DocDef {
name: "DecodeError",
symbol: `Decode.DecodeError`,
type_vars: [],
type_annotation: TagUnion {
tags: [
Tag {
name: "TooShort",
values: [],
},
],
extension: NoTypeAnn,
},
docs: Some(
"Error types when decoding a `List U8` of utf-8 bytes using a [Decoder]\n",
),
},
),
DocDef(
DocDef {
name: "DecodeResult",
symbol: `Decode.DecodeResult`,
type_vars: [
"val",
],
type_annotation: NoTypeAnn,
docs: Some(
"Return type of a [Decoder].\n\nThis can be useful when creating a [custom](#custom) decoder or when\nusing [fromBytesPartial](#fromBytesPartial). For example writing unit tests,\nsuch as;\n```\nexpect\n input = \"\\\"hello\\\", \" |> Str.toUtf8\n actual = Decode.fromBytesPartial input Json.json\n expected = Ok \"hello\"\n\n actual.result == expected\n```\n",
),
},
),
DocDef(
DocDef {
name: "Decoder",
symbol: `Decode.Decoder`,
type_vars: [
"val",
"fmt",
],
type_annotation: NoTypeAnn,
docs: Some(
"Decodes a `List U8` of utf-8 bytes where `val` is the type of the decoded\nvalue, and `fmt` is a [Decoder] which implements the [DecoderFormatting]\nability\n",
),
},
),
DocDef(
DocDef {
name: "Decoding",
symbol: `Decode.Decoding`,
type_vars: [],
type_annotation: Ability {
members: [
AbilityMember {
name: "decoder",
type_annotation: Apply {
name: "Decoder",
parts: [
BoundVariable(
"val",
),
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"val",
[
Apply {
name: "Decoding",
parts: [],
},
],
),
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
],
},
docs: Some(
"Definition of the [Decoding] ability\n",
),
},
),
DocDef(
DocDef {
name: "DecoderFormatting",
symbol: `Decode.DecoderFormatting`,
type_vars: [],
type_annotation: Ability {
members: [
AbilityMember {
name: "u8",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "U8",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u16",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "U16",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u32",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "U32",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u64",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "U64",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u128",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "U128",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i8",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "I8",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i16",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "I16",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i32",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "I32",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i64",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "I64",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i128",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "I128",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "f32",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "F32",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "f64",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "F64",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "dec",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "Dec",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "bool",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "Bool",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "string",
type_annotation: Apply {
name: "Decoder",
parts: [
Apply {
name: "Str",
parts: [],
},
BoundVariable(
"fmt",
),
],
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "list",
type_annotation: Function {
args: [
Apply {
name: "Decoder",
parts: [
BoundVariable(
"elem",
),
BoundVariable(
"fmt",
),
],
},
],
output: Apply {
name: "Decoder",
parts: [
Apply {
name: "List",
parts: [
BoundVariable(
"elem",
),
],
},
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "record",
type_annotation: Function {
args: [
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
Apply {
name: "Str",
parts: [],
},
],
output: TagUnion {
tags: [
Tag {
name: "Keep",
values: [
Apply {
name: "Decoder",
parts: [
BoundVariable(
"state",
),
BoundVariable(
"fmt",
),
],
},
],
},
Tag {
name: "Skip",
values: [],
},
],
extension: NoTypeAnn,
},
},
Function {
args: [
BoundVariable(
"state",
),
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"val",
),
Apply {
name: "DecodeError",
parts: [],
},
],
},
},
],
output: Apply {
name: "Decoder",
parts: [
BoundVariable(
"val",
),
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: Some(
"`record state stepField finalizer` decodes a record field-by-field.\n\n`stepField` returns a decoder for the given field in the record, or\n`Skip` if the field is not a part of the decoded record.\n\n`finalizer` should produce the record value from the decoded `state`.\n",
),
},
AbilityMember {
name: "tuple",
type_annotation: Function {
args: [
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
Apply {
name: "U64",
parts: [],
},
],
output: TagUnion {
tags: [
Tag {
name: "Next",
values: [
Apply {
name: "Decoder",
parts: [
BoundVariable(
"state",
),
BoundVariable(
"fmt",
),
],
},
],
},
Tag {
name: "TooLong",
values: [],
},
],
extension: NoTypeAnn,
},
},
Function {
args: [
BoundVariable(
"state",
),
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"val",
),
Apply {
name: "DecodeError",
parts: [],
},
],
},
},
],
output: Apply {
name: "Decoder",
parts: [
BoundVariable(
"val",
),
BoundVariable(
"fmt",
),
],
},
},
able_variables: [
(
"fmt",
[
Apply {
name: "DecoderFormatting",
parts: [],
},
],
),
],
docs: Some(
"`tuple state stepElem finalizer` decodes a tuple element-by-element.\n\n`stepElem` returns a decoder for the nth index in the tuple, or\n`TooLong` if the index is larger than the expected size of the tuple. The\nindex passed to `stepElem` is 0-indexed.\n\n`finalizer` should produce the tuple value from the decoded `state`.\n",
),
},
],
},
docs: Some(
"Definition of the [DecoderFormatting] ability\n",
),
},
),
DocDef(
DocDef {
name: "custom",
symbol: `Decode.custom`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
BoundVariable(
"fmt",
),
],
output: Apply {
name: "DecodeResult",
parts: [
BoundVariable(
"val",
),
],
},
},
],
output: Apply {
name: "Decoder",
parts: [
BoundVariable(
"val",
),
BoundVariable(
"fmt",
),
],
},
},
implements: [
ImplementsClause {
name: "fmt",
abilities: [
Apply {
name: "DecoderFormatting",
parts: [],
},
],
},
],
},
docs: Some(
"Build a custom [Decoder] function. For example the implementation of\n`decodeBool` could be defined as follows;\n\n```\ndecodeBool = Decode.custom \\bytes, @Json {} ->\n when bytes is\n ['f', 'a', 'l', 's', 'e', ..] -> { result: Ok Bool.false, rest: List.dropFirst bytes 5 }\n ['t', 'r', 'u', 'e', ..] -> { result: Ok Bool.true, rest: List.dropFirst bytes 4 }\n _ -> { result: Err TooShort, rest: bytes }\n```\n",
),
},
),
DocDef(
DocDef {
name: "decodeWith",
symbol: `Decode.decodeWith`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
Apply {
name: "Decoder",
parts: [
BoundVariable(
"val",
),
BoundVariable(
"fmt",
),
],
},
BoundVariable(
"fmt",
),
],
output: Apply {
name: "DecodeResult",
parts: [
BoundVariable(
"val",
),
],
},
},
implements: [
ImplementsClause {
name: "fmt",
abilities: [
Apply {
name: "DecoderFormatting",
parts: [],
},
],
},
],
},
docs: Some(
"Decode a `List U8` utf-8 bytes using a specific [Decoder] function\n",
),
},
),
DocDef(
DocDef {
name: "fromBytesPartial",
symbol: `Decode.fromBytesPartial`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
BoundVariable(
"fmt",
),
],
output: Apply {
name: "DecodeResult",
parts: [
BoundVariable(
"val",
),
],
},
},
implements: [
ImplementsClause {
name: "val",
abilities: [
Apply {
name: "Decoding",
parts: [],
},
],
},
ImplementsClause {
name: "fmt",
abilities: [
Apply {
name: "DecoderFormatting",
parts: [],
},
],
},
],
},
docs: Some(
"Decode a `List U8` utf-8 bytes and return a [DecodeResult](#DecodeResult)\n```\nexpect\n input = \"\\\"hello\\\", \" |> Str.toUtf8\n actual = Decode.fromBytesPartial input Json.json\n expected = Ok \"hello\"\n\n actual.result == expected\n```\n",
),
},
),
DocDef(
DocDef {
name: "fromBytes",
symbol: `Decode.fromBytes`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
BoundVariable(
"fmt",
),
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"val",
),
TagUnion {
tags: [
Tag {
name: "Leftover",
values: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
],
},
],
extension: Apply {
name: "DecodeError",
parts: [],
},
},
],
},
},
implements: [
ImplementsClause {
name: "val",
abilities: [
Apply {
name: "Decoding",
parts: [],
},
],
},
ImplementsClause {
name: "fmt",
abilities: [
Apply {
name: "DecoderFormatting",
parts: [],
},
],
},
],
},
docs: Some(
"Decode a `List U8` utf-8 bytes and return a [Result] with no leftover bytes\nexpected. If successful returns `Ok val`, however, if there are bytes\nremaining returns `Err Leftover (List U8)`.\n```\nexpect\n input = \"\\\"hello\\\", \" |> Str.toUtf8\n actual = Decode.fromBytes input Json.json\n expected = Ok \"hello\"\n\n actual == expected\n```\n",
),
},
),
DocDef(
DocDef {
name: "mapResult",
symbol: `Decode.mapResult`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "DecodeResult",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: BoundVariable(
"b",
),
},
],
output: Apply {
name: "DecodeResult",
parts: [
BoundVariable(
"b",
),
],
},
},
docs: Some(
"Transform the `val` of a [DecodeResult]\n",
),
},
),
],
scope: Scope {
aliases: VecMap {
keys: [
`Num.Binary32`,
`Num.F32`,
`Num.FloatingPoint`,
`Num.Unsigned16`,
`Num.U16`,
`Bool.Bool`,
`Num.U64`,
`Num.Binary64`,
`Num.Int`,
`Num.Signed128`,
`Num.Unsigned8`,
`Num.Frac`,
`Num.U32`,
`Num.Signed64`,
`Num.Signed8`,
`Num.I64`,
`Num.U8`,
`Num.I16`,
`Result.Result`,
`Num.Unsigned128`,
`Num.I8`,
`Num.Num`,
`Num.Decimal`,
`Num.Unsigned32`,
`Num.Signed32`,
`Num.Integer`,
`Num.I128`,
`Num.U128`,
`Num.I32`,
`Num.Signed16`,
`Num.Unsigned64`,
`Num.F64`,
`Num.Dec`,
`Decode.DecodeError`,
`Decode.DecodeResult`,
`Decode.Decoder`,
],
values: [
Alias {
region: @17634-17642,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19444-19447,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17650-17669,
type_variables: [
@17664-17669 AliasVar {
name: 'range',
var: 67,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <67>,
kind: Opaque,
},
Alias {
region: @17202-17212,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17544-17547,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @1780-1784,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: ['False', 'True'],
kind: Opaque,
},
Alias {
region: @17482-17485,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17619-17627,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @12895-12904,
type_variables: [
@12899-12904 AliasVar {
name: 'range',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` <64>[ but actually <64> ])[ but actually (Alias `Num.Integer` <64>[ but actually <64> ]) ]),
kind: Structural,
},
Alias {
region: @17074-17083,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17219-17228,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17034-17044,
type_variables: [
@17039-17044 AliasVar {
name: 'range',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` <65>[ but actually <65> ])[ but actually (Alias `Num.FloatingPoint` <65>[ but actually <65> ]) ]),
kind: Structural,
},
Alias {
region: @17513-17516,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17090-17098,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17135-17142,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17291-17294,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17575-17577,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17349-17352,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @241-254,
type_variables: [
@248-250 AliasVar {
name: 'ok',
var: 64,
opt_bound_abilities: None,
},
@251-254 AliasVar {
name: 'err',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['Err' <65>, 'Ok' <64>]<63>,
kind: Structural,
},
Alias {
region: @17150-17161,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17431-17433,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Int` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ]) ]) ]),
kind: Structural,
},
Alias {
region: @5228-5237,
type_variables: [
@5232-5237 AliasVar {
name: 'range',
var: 63,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <63>,
kind: Opaque,
},
Alias {
region: @17605-17612,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17185-17195,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17105-17113,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17236-17249,
type_variables: [
@17244-17249 AliasVar {
name: 'range',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <66>,
kind: Opaque,
},
Alias {
region: @17260-17264,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17449-17453,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17320-17323,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17120-17128,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17168-17178,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19085-19088,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @23363-23366,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @908-919,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['TooShort']<63>,
kind: Structural,
},
Alias {
region: @1320-1336,
type_variables: [
@1333-1336 AliasVar {
name: 'val',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [
65,
69,
],
recursion_variables: {},
typ: { 'result' : RigidRequired((DelayedAlias `Result.Result` @1357-1360 OptAbleType { typ: <64>, opt_abilities: None } @1361-1372 OptAbleType { typ: (Alias `Decode.DecodeError`[ but actually ['TooShort']<69> ]), opt_abilities: None } `0@<65>))'rest' : RigidRequired((`List.List` @1386-1388 (DelayedAlias `Num.U8`))), },
kind: Structural,
},
Alias {
region: @1556-1571,
type_variables: [
@1564-1567 AliasVar {
name: 'val',
var: 67,
opt_bound_abilities: None,
},
@1568-1571 AliasVar {
name: 'fmt',
var: 66,
opt_bound_abilities: Some(
AbilitySet(
[
`Decode.DecoderFormatting`,
],
),
),
},
],
lambda_set_variables: [
LambdaSet(
<68>,
),
],
infer_ext_in_output_variables: [
70,
71,
],
recursion_variables: {},
typ: Fn((`List.List` @1580-1582 (DelayedAlias `Num.U8`)), <66> |<68>| -> (Alias `Decode.DecodeResult` <67>[ but actually { 'result' : RigidRequired((DelayedAlias `Result.Result` @1357-1360 OptAbleType { typ: <67>, opt_abilities: None } @1361-1372 OptAbleType { typ: (Alias `Decode.DecodeError`[ but actually ['TooShort']<71> ]), opt_abilities: None } `0@<70>))'rest' : RigidRequired((`List.List` @1386-1388 (DelayedAlias `Num.U8`))), } ])),
kind: Opaque,
},
],
},
abilities_store: IAbilitiesStore {
members_of_ability: {
`Decode.Decoding`: [
`Decode.decoder`,
],
`Bool.Eq`: [
`Bool.isEq`,
],
`Decode.DecoderFormatting`: [
`Decode.u8`,
`Decode.u16`,
`Decode.u32`,
`Decode.u64`,
`Decode.u128`,
`Decode.i8`,
`Decode.i16`,
`Decode.i32`,
`Decode.i64`,
`Decode.i128`,
`Decode.f32`,
`Decode.f64`,
`Decode.dec`,
`Decode.bool`,
`Decode.string`,
`Decode.list`,
`Decode.record`,
`Decode.tuple`,
],
},
specialization_to_root: {
`Bool.boolIsEq`: ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
},
},
ability_members: {
`Decode.i16`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2273-2276,
typ: Local {
signature_var: 112,
signature: (DelayedAlias `Decode.Decoder` @2287-2290 OptAbleType { typ: (DelayedAlias `Num.I16`), opt_abilities: None } @2291-2294 OptAbleType { typ: <108>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(108:`Decode.i16`:1) `0@<110> `1@<111>),
variables: MemberVariables {
able_vars: [
108,
],
rigid_vars: [
109,
],
flex_vars: [],
},
},
},
`Decode.bool`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2730-2734,
typ: Local {
signature_var: 147,
signature: (DelayedAlias `Decode.Decoder` @2745-2749 OptAbleType { typ: (DelayedAlias `Bool.Bool`), opt_abilities: None } @2750-2753 OptAbleType { typ: <143>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(143:`Decode.bool`:1) `0@<145> `1@<146>),
variables: MemberVariables {
able_vars: [
143,
],
rigid_vars: [
144,
],
flex_vars: [],
},
},
},
`Bool.isEq`: AbilityMemberData {
parent_ability: `Bool.Eq`,
region: @1635-1639,
typ: Imported,
},
`Decode.dec`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2665-2668,
typ: Local {
signature_var: 142,
signature: (DelayedAlias `Decode.Decoder` @2679-2682 OptAbleType { typ: (DelayedAlias `Num.Dec`), opt_abilities: None } @2683-2686 OptAbleType { typ: <138>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(138:`Decode.dec`:1) `0@<140> `1@<141>),
variables: MemberVariables {
able_vars: [
138,
],
rigid_vars: [
139,
],
flex_vars: [],
},
},
},
`Decode.u32`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2013-2016,
typ: Local {
signature_var: 92,
signature: (DelayedAlias `Decode.Decoder` @2027-2030 OptAbleType { typ: (DelayedAlias `Num.U32`), opt_abilities: None } @2031-2034 OptAbleType { typ: <88>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(88:`Decode.u32`:1) `0@<90> `1@<91>),
variables: MemberVariables {
able_vars: [
88,
],
rigid_vars: [
89,
],
flex_vars: [],
},
},
},
`Decode.f64`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2600-2603,
typ: Local {
signature_var: 137,
signature: (DelayedAlias `Decode.Decoder` @2614-2617 OptAbleType { typ: (DelayedAlias `Num.F64`), opt_abilities: None } @2618-2621 OptAbleType { typ: <133>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(133:`Decode.f64`:1) `0@<135> `1@<136>),
variables: MemberVariables {
able_vars: [
133,
],
rigid_vars: [
134,
],
flex_vars: [],
},
},
},
`Decode.i128`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2468-2472,
typ: Local {
signature_var: 127,
signature: (DelayedAlias `Decode.Decoder` @2483-2487 OptAbleType { typ: (DelayedAlias `Num.I128`), opt_abilities: None } @2488-2491 OptAbleType { typ: <123>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(123:`Decode.i128`:1) `0@<125> `1@<126>),
variables: MemberVariables {
able_vars: [
123,
],
rigid_vars: [
124,
],
flex_vars: [],
},
},
},
`Decode.list`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2865-2869,
typ: Local {
signature_var: 160,
signature: Fn((DelayedAlias `Decode.Decoder` @2880-2884 OptAbleType { typ: <154>, opt_abilities: None } @2885-2888 OptAbleType { typ: <153>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(153:`Decode.list`:2) `0@[] `1@[]) |Uls(153:`Decode.list`:1)| -> (DelayedAlias `Decode.Decoder` @2901-2910 OptAbleType { typ: (`List.List` @2906-2910 <154>), opt_abilities: None } @2912-2915 OptAbleType { typ: <153>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(153:`Decode.list`:3) `0@<157> `1@<158>)),
variables: MemberVariables {
able_vars: [
153,
],
rigid_vars: [
154,
155,
156,
159,
],
flex_vars: [],
},
},
},
`Decode.tuple`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @3794-3799,
typ: Local {
signature_var: 192,
signature: Fn(<178>, Fn(<178>, (DelayedAlias `Num.U64`) |Uls(177:`Decode.tuple`:2)| -> ['Next' (DelayedAlias `Decode.Decoder` @3839-3844 OptAbleType { typ: <178>, opt_abilities: None } @3845-3848 OptAbleType { typ: <177>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(177:`Decode.tuple`:3) `0@<181> `1@<182>), 'TooLong']<179>), Fn(<178> |Uls(177:`Decode.tuple`:4)| -> (DelayedAlias `Result.Result` @3879-3882 OptAbleType { typ: <184>, opt_abilities: None } @3883-3894 OptAbleType { typ: (DelayedAlias `Decode.DecodeError` `0@<185>), opt_abilities: None } `0@<186>)) |Uls(177:`Decode.tuple`:1)| -> (DelayedAlias `Decode.Decoder` @3907-3910 OptAbleType { typ: <184>, opt_abilities: None } @3911-3914 OptAbleType { typ: <177>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(177:`Decode.tuple`:5) `0@<189> `1@<190>)),
variables: MemberVariables {
able_vars: [
177,
],
rigid_vars: [
178,
184,
180,
183,
187,
188,
191,
],
flex_vars: [],
},
},
},
`Decode.u128`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2143-2147,
typ: Local {
signature_var: 102,
signature: (DelayedAlias `Decode.Decoder` @2158-2162 OptAbleType { typ: (DelayedAlias `Num.U128`), opt_abilities: None } @2163-2166 OptAbleType { typ: <98>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(98:`Decode.u128`:1) `0@<100> `1@<101>),
variables: MemberVariables {
able_vars: [
98,
],
rigid_vars: [
99,
],
flex_vars: [],
},
},
},
`Decode.string`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2797-2803,
typ: Local {
signature_var: 152,
signature: (DelayedAlias `Decode.Decoder` @2814-2817 OptAbleType { typ: (`Str.Str`), opt_abilities: None } @2818-2821 OptAbleType { typ: <148>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(148:`Decode.string`:1) `0@<150> `1@<151>),
variables: MemberVariables {
able_vars: [
148,
],
rigid_vars: [
149,
],
flex_vars: [],
},
},
},
`Decode.i8`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2210-2212,
typ: Local {
signature_var: 107,
signature: (DelayedAlias `Decode.Decoder` @2223-2225 OptAbleType { typ: (DelayedAlias `Num.I8`), opt_abilities: None } @2226-2229 OptAbleType { typ: <103>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(103:`Decode.i8`:1) `0@<105> `1@<106>),
variables: MemberVariables {
able_vars: [
103,
],
rigid_vars: [
104,
],
flex_vars: [],
},
},
},
`Decode.decoder`: AbilityMemberData {
parent_ability: `Decode.Decoding`,
region: @1712-1719,
typ: Local {
signature_var: 77,
signature: (DelayedAlias `Decode.Decoder` @1730-1733 OptAbleType { typ: <72>, opt_abilities: None } @1734-1737 OptAbleType { typ: <73>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(72:`Decode.decoder`:1) `0@<75> `1@<76>),
variables: MemberVariables {
able_vars: [
72,
73,
],
rigid_vars: [
74,
],
flex_vars: [],
},
},
},
`Decode.f32`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2535-2538,
typ: Local {
signature_var: 132,
signature: (DelayedAlias `Decode.Decoder` @2549-2552 OptAbleType { typ: (DelayedAlias `Num.F32`), opt_abilities: None } @2553-2556 OptAbleType { typ: <128>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(128:`Decode.f32`:1) `0@<130> `1@<131>),
variables: MemberVariables {
able_vars: [
128,
],
rigid_vars: [
129,
],
flex_vars: [],
},
},
},
`Decode.record`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @3265-3271,
typ: Local {
signature_var: 176,
signature: Fn(<162>, Fn(<162>, (`Str.Str`) |Uls(161:`Decode.record`:2)| -> ['Keep' (DelayedAlias `Decode.Decoder` @3311-3316 OptAbleType { typ: <162>, opt_abilities: None } @3317-3320 OptAbleType { typ: <161>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(161:`Decode.record`:3) `0@<165> `1@<166>), 'Skip']<163>), Fn(<162> |Uls(161:`Decode.record`:4)| -> (DelayedAlias `Result.Result` @3348-3351 OptAbleType { typ: <168>, opt_abilities: None } @3352-3363 OptAbleType { typ: (DelayedAlias `Decode.DecodeError` `0@<169>), opt_abilities: None } `0@<170>)) |Uls(161:`Decode.record`:1)| -> (DelayedAlias `Decode.Decoder` @3376-3379 OptAbleType { typ: <168>, opt_abilities: None } @3380-3383 OptAbleType { typ: <161>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(161:`Decode.record`:5) `0@<173> `1@<174>)),
variables: MemberVariables {
able_vars: [
161,
],
rigid_vars: [
162,
168,
164,
167,
171,
172,
175,
],
flex_vars: [],
},
},
},
`Decode.u64`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2078-2081,
typ: Local {
signature_var: 97,
signature: (DelayedAlias `Decode.Decoder` @2092-2095 OptAbleType { typ: (DelayedAlias `Num.U64`), opt_abilities: None } @2096-2099 OptAbleType { typ: <93>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(93:`Decode.u64`:1) `0@<95> `1@<96>),
variables: MemberVariables {
able_vars: [
93,
],
rigid_vars: [
94,
],
flex_vars: [],
},
},
},
`Decode.i32`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2338-2341,
typ: Local {
signature_var: 117,
signature: (DelayedAlias `Decode.Decoder` @2352-2355 OptAbleType { typ: (DelayedAlias `Num.I32`), opt_abilities: None } @2356-2359 OptAbleType { typ: <113>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(113:`Decode.i32`:1) `0@<115> `1@<116>),
variables: MemberVariables {
able_vars: [
113,
],
rigid_vars: [
114,
],
flex_vars: [],
},
},
},
`Decode.u8`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @1885-1887,
typ: Local {
signature_var: 82,
signature: (DelayedAlias `Decode.Decoder` @1898-1900 OptAbleType { typ: (DelayedAlias `Num.U8`), opt_abilities: None } @1901-1904 OptAbleType { typ: <78>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(78:`Decode.u8`:1) `0@<80> `1@<81>),
variables: MemberVariables {
able_vars: [
78,
],
rigid_vars: [
79,
],
flex_vars: [],
},
},
},
`Decode.u16`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @1948-1951,
typ: Local {
signature_var: 87,
signature: (DelayedAlias `Decode.Decoder` @1962-1965 OptAbleType { typ: (DelayedAlias `Num.U16`), opt_abilities: None } @1966-1969 OptAbleType { typ: <83>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(83:`Decode.u16`:1) `0@<85> `1@<86>),
variables: MemberVariables {
able_vars: [
83,
],
rigid_vars: [
84,
],
flex_vars: [],
},
},
},
`Decode.i64`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2403-2406,
typ: Local {
signature_var: 122,
signature: (DelayedAlias `Decode.Decoder` @2417-2420 OptAbleType { typ: (DelayedAlias `Num.I64`), opt_abilities: None } @2421-2424 OptAbleType { typ: <118>, opt_abilities: Some(AbilitySet([`Decode.DecoderFormatting`])) } α@Uls(118:`Decode.i64`:1) `0@<120> `1@<121>),
variables: MemberVariables {
able_vars: [
118,
],
rigid_vars: [
119,
],
flex_vars: [],
},
},
},
},
declared_implementations: {
ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
}: Impl(
`Bool.boolIsEq`,
),
},
specializations: {},
next_specialization_id: 2,
resolved_specializations: {},
},
home: Decode,
exposed_ident_count: 29,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "U8",
},
),
`Num.U8`,
@584-586,
),
(
Ident(
IdentStr {
string: "Result",
},
),
`Result.Result`,
@548-554,
),
(
Ident(
IdentStr {
string: "I8",
},
),
`Num.I8`,
@669-671,
),
(
Ident(
IdentStr {
string: "I128",
},
),
`Num.I128`,
@736-740,
),
(
Ident(
IdentStr {
string: "Dec",
},
),
`Num.Dec`,
@788-791,
),
(
Ident(
IdentStr {
string: "U64",
},
),
`Num.U64`,
@634-637,
),
(
Ident(
IdentStr {
string: "I64",
},
),
`Num.I64`,
@719-722,
),
(
Ident(
IdentStr {
string: "U16",
},
),
`Num.U16`,
@600-603,
),
(
Ident(
IdentStr {
string: "Bool",
},
),
`Bool.Bool`,
@819-823,
),
(
Ident(
IdentStr {
string: "U128",
},
),
`Num.U128`,
@651-655,
),
(
Ident(
IdentStr {
string: "F64",
},
),
`Num.F64`,
@771-774,
),
(
Ident(
IdentStr {
string: "I32",
},
),
`Num.I32`,
@702-705,
),
(
Ident(
IdentStr {
string: "I16",
},
),
`Num.I16`,
@685-688,
),
(
Ident(
IdentStr {
string: "F32",
},
),
`Num.F32`,
@754-757,
),
(
Ident(
IdentStr {
string: "U32",
},
),
`Num.U32`,
@617-620,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
68,
101,
99,
111,
100,
101,
69,
114,
114,
111,
114,
68,
101,
99,
111,
100,
101,
82,
101,
115,
117,
108,
116,
68,
101,
99,
111,
100,
101,
114,
68,
101,
99,
111,
100,
105,
110,
103,
100,
101,
99,
111,
100,
101,
114,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
117,
56,
117,
49,
54,
117,
51,
50,
117,
54,
52,
117,
49,
50,
56,
105,
56,
105,
49,
54,
105,
51,
50,
105,
54,
52,
105,
49,
50,
56,
102,
51,
50,
102,
54,
52,
100,
101,
99,
98,
111,
111,
108,
115,
116,
114,
105,
110,
103,
108,
105,
115,
116,
114,
101,
99,
111,
114,
100,
116,
117,
112,
108,
101,
99,
117,
115,
116,
111,
109,
100,
101,
99,
111,
100,
101,
87,
105,
116,
104,
102,
114,
111,
109,
66,
121,
116,
101,
115,
80,
97,
114,
116,
105,
97,
108,
102,
114,
111,
109,
66,
121,
116,
101,
115,
109,
97,
112,
82,
101,
115,
117,
108,
116,
82,
101,
115,
117,
108,
116,
68,
101,
99,
111,
100,
101,
69,
114,
114,
111,
114,
76,
105,
115,
116,
85,
56,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
82,
101,
115,
117,
108,
116,
76,
105,
115,
116,
85,
56,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
85,
56,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
85,
49,
54,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
85,
51,
50,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
85,
54,
52,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
85,
49,
50,
56,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
73,
56,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
73,
49,
54,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
73,
51,
50,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
73,
54,
52,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
73,
49,
50,
56,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
70,
51,
50,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
70,
54,
52,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
68,
101,
99,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
66,
111,
111,
108,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
83,
116,
114,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
76,
105,
115,
116,
68,
101,
99,
111,
100,
101,
114,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
82,
101,
115,
117,
108,
116,
68,
101,
99,
111,
100,
101,
69,
114,
114,
111,
114,
68,
101,
99,
111,
100,
101,
114,
83,
116,
114,
68,
101,
99,
111,
100,
101,
114,
70,
111,
114,
109,
97,
116,
116,
105,
110,
103,
68,
101,
99,
111,
100,
101,
114,
82,
101,
115,
117,
108,
116,
68,
101,
99,
111,
100,
101,
69,
114,
114,
111,
114,
68,
101,
99,
111,
100,
101,
114,
85,
54,
52,
100,
101,
99,
111,
100,
101,
98,
121,
116,
101,
115,
102,
109,
116,
114,
101,
115,
117,
108,
116,
114,
101,
115,
116,
118,
97,
108,
49,
49,
50,
49,
49,
51,
49,
49,
52,
49,
49,
53,
49,
49,
54,
109,
97,
112,
112,
101,
114,
],
lengths: [
Interned(11),
Interned(12),
Interned(7),
Interned(8),
Interned(7),
Interned(17),
Interned(2),
Interned(3),
Interned(3),
Interned(3),
Interned(4),
Interned(2),
Interned(3),
Interned(3),
Interned(3),
Interned(4),
Interned(3),
Interned(3),
Interned(3),
Interned(4),
Interned(6),
Interned(4),
Interned(6),
Interned(5),
Interned(6),
Interned(10),
Interned(16),
Interned(9),
Interned(9),
Interned(6),
Interned(11),
Interned(4),
Interned(2),
Interned(17),
Interned(12),
Interned(4),
Interned(2),
Interned(17),
Interned(8),
Interned(7),
Interned(17),
Interned(7),
Interned(2),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(4),
Interned(17),
Interned(7),
Interned(2),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(4),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(4),
Interned(17),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(4),
Interned(7),
Interned(17),
Interned(7),
Interned(6),
Interned(11),
Interned(7),
Interned(3),
Interned(17),
Interned(7),
Interned(6),
Interned(11),
Interned(7),
Interned(3),
Interned(6),
Interned(5),
Interned(6),
Interned(3),
Interned(5),
Interned(3),
Interned(5),
Interned(3),
Interned(6),
Interned(4),
Interned(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Interned(6),
Interned(4),
Interned(6),
],
offsets: [
0,
11,
23,
30,
38,
45,
62,
64,
67,
70,
73,
77,
79,
82,
85,
88,
92,
95,
98,
101,
105,
111,
115,
121,
126,
132,
142,
158,
167,
176,
182,
193,
197,
199,
216,
228,
232,
234,
251,
259,
266,
283,
290,
292,
309,
316,
319,
336,
343,
346,
363,
370,
373,
390,
397,
401,
418,
425,
427,
444,
451,
454,
471,
478,
481,
498,
505,
508,
525,
532,
536,
553,
560,
563,
580,
587,
590,
607,
614,
617,
634,
641,
645,
662,
669,
672,
689,
696,
700,
707,
724,
731,
737,
748,
755,
758,
775,
782,
788,
799,
806,
809,
815,
809,
820,
815,
820,
815,
820,
823,
829,
833,
836,
839,
842,
845,
848,
823,
829,
851,
],
strings: [
"DecodeError",
"DecodeResult",
"Decoder",
"Decoding",
"decoder",
"DecoderFormatting",
"u8",
"u16",
"u32",
"u64",
"u128",
"i8",
"i16",
"i32",
"i64",
"i128",
"f32",
"f64",
"dec",
"bool",
"string",
"list",
"record",
"tuple",
"custom",
"decodeWith",
"fromBytesPartial",
"fromBytes",
"mapResult",
"Result",
"DecodeError",
"List",
"U8",
"DecoderFormatting",
"DecodeResult",
"List",
"U8",
"DecoderFormatting",
"Decoding",
"Decoder",
"DecoderFormatting",
"Decoder",
"U8",
"DecoderFormatting",
"Decoder",
"U16",
"DecoderFormatting",
"Decoder",
"U32",
"DecoderFormatting",
"Decoder",
"U64",
"DecoderFormatting",
"Decoder",
"U128",
"DecoderFormatting",
"Decoder",
"I8",
"DecoderFormatting",
"Decoder",
"I16",
"DecoderFormatting",
"Decoder",
"I32",
"DecoderFormatting",
"Decoder",
"I64",
"DecoderFormatting",
"Decoder",
"I128",
"DecoderFormatting",
"Decoder",
"F32",
"DecoderFormatting",
"Decoder",
"F64",
"DecoderFormatting",
"Decoder",
"Dec",
"DecoderFormatting",
"Decoder",
"Bool",
"DecoderFormatting",
"Decoder",
"Str",
"DecoderFormatting",
"Decoder",
"List",
"Decoder",
"DecoderFormatting",
"Decoder",
"Result",
"DecodeError",
"Decoder",
"Str",
"DecoderFormatting",
"Decoder",
"Result",
"DecodeError",
"Decoder",
"U64",
"decode",
"bytes",
"decode",
"fmt",
"bytes",
"fmt",
"bytes",
"fmt",
"result",
"rest",
"val",
"112",
"113",
"114",
"115",
"116",
"result",
"rest",
"mapper",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffeca59ed0,
head: 000000,
bits: 120,
capacity: 128,
} [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
regions: [
@908-932,
@1320-1390,
@1556-1646,
@1688-1696,
@1712-1719,
@1852-1869,
@1885-1887,
@1948-1951,
@2013-2016,
@2078-2081,
@2143-2147,
@2210-2212,
@2273-2276,
@2338-2341,
@2403-2406,
@2468-2472,
@2535-2538,
@2600-2603,
@2665-2668,
@2730-2734,
@2797-2803,
@2865-2869,
@3265-3271,
@3794-3799,
@4510-4516,
@4719-4729,
@5163-5179,
@5735-5744,
@6136-6145,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
@4520-4526,
@4733-4738,
@4749-4755,
@4757-4760,
@5183-5188,
@5190-5193,
@5748-5753,
@5755-5758,
@5809-5825,
@5809-5825,
@5921-5924,
…,
…,
…,
…,
…,
@6149-6165,
@6149-6165,
@6167-6173,
],
home: Decode,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`Decode.DecodeError`,
`Decode.DecodeResult`,
`Decode.Decoder`,
`Decode.Decoding`,
`Decode.DecoderFormatting`,
`Decode.decoder`,
`Decode.u8`,
`Decode.u16`,
`Decode.u32`,
`Decode.u64`,
`Decode.u128`,
`Decode.i8`,
`Decode.i16`,
`Decode.i32`,
`Decode.i64`,
`Decode.i128`,
`Decode.f32`,
`Decode.f64`,
`Decode.dec`,
`Decode.bool`,
`Decode.string`,
`Decode.list`,
`Decode.record`,
`Decode.tuple`,
`Decode.custom`,
`Decode.decodeWith`,
`Decode.fromBytesPartial`,
`Decode.fromBytes`,
`Decode.mapResult`,
],
},
},
<<docs:
"Strings represent text. For example, `\"Hi!\"` is a string.\n\nThis guide starts at a high level and works down to the in-memory representation of strings and their [performance characteristics](#performance). For reasons that will be explained later in this guide, some string operations are in the `Str` module while others (notably [capitalization](#capitalization), [code points](#code-points), [graphemes](#graphemes), and sorting) are in separate packages. There's also a list of recommendations for [when to use code points, graphemes, and UTF-8](#when-to-use).\n\n## Syntax\n\nThe most common way to represent strings is using quotation marks:\n\n```\n\"Hello, World!\"\n```\n\nUsing this syntax, the whole string must go on one line. You can write multiline strings using triple quotes:\n\n```\ntext =\n \"\"\"\n In memory, this string will not have any spaces\n at its start. That's because the first line\n starts at the same indentation level as the\n opening quotation mark. Actually, none of these\n lines will be indented.\n\n However, this line will be indented!\n \"\"\"\n```\n\nIn triple-quoted strings, both the opening and closing `\"\"\"` must be at the same indentation level. Lines in the string begin at that indentation level; the spaces that indent the multiline string itself are not considered content.\n\n### Interpolation\n\n*String interpolation* is syntax for inserting a string into another string.\n\n```\nname = \"Sam\"\n\n\"Hi, my name is $(name)!\"\n```\n\nThis will evaluate to the string `\"Hi, my name is Sam!\"`\n\nYou can put any expression you like inside the parentheses, as long as it's all on one line:\n\n```\ncolors = [\"red\", \"green\", \"blue\"]\n\n\"The colors are $(colors |> Str.joinWith \", \")!\"\n```\n\nInterpolation can be used in multiline strings, but the part inside the parentheses must still be on one line.\n\n### Escapes\n\nThere are a few special escape sequences in strings:\n\n* `\\n` becomes a [newline](https://en.wikipedia.org/wiki/Newline)\n* `\\r` becomes a [carriage return](https://en.wikipedia.org/wiki/Carriage_return#Computers)\n* `\\t` becomes a [tab](https://en.wikipedia.org/wiki/Tab_key#Tab_characters)\n* `\\\"` becomes a normal `\"` (this lets you write `\"` inside a single-line string)\n* `\\\\` becomes a normal `\\` (this lets you write `\\` without it being treated as an escape)\n* `\\$` becomes a normal `$` (this lets you write `$` followed by `(` without it being treated as [interpolation](#interpolation))\n\nThese work in both single-line and multiline strings. We'll also discuss another escape later, for inserting [Unicode code points](#code-points) into a string.\n\n### Single quote syntax\n\nTry putting `'👩'` into `roc repl`. You should see this:\n\n```\n» '👩'\n\n128105 : Int *\n```\n\nThe single-quote `'` syntax lets you represent a Unicode code point (discussed in the next section) in source code, in a way that renders as the actual text it represents rather than as a number literal. This lets you see what it looks like in the source code rather than looking at a number.\n\nAt runtime, the single-quoted value will be treated the same as an ordinary number literal—in other words, `'👩'` is syntax sugar for writing `128105`. You can verify this in `roc repl`:\n\n```\n» '👩' == 128105\n\nBool.true : Bool\n```\n\nDouble quotes (`\"`), on the other hand, are not type-compatible with integers—not only because strings can be empty (`\"\"` is valid, but `''` is not) but also because there may be more than one code point involved in any given string!\n\nThere are also some special escape sequences in single-quote strings:\n\n* `\\n` becomes a [newline](https://en.wikipedia.org/wiki/Newline)\n* `\\r` becomes a [carriage return](https://en.wikipedia.org/wiki/Carriage_return#Computers)\n* `\\t` becomes a [tab](https://en.wikipedia.org/wiki/Tab_key#Tab_characters)\n* `\\'` becomes a normal `'` (this lets you write `'` inside a single-quote string)\n* `\\\\` becomes a normal `\\` (this lets you write `\\` without it being treated as an escape)\n\nMost often this single-quote syntax is used when writing parsers; most Roc programs never use it at all.\n\n## Unicode\n\nRoc strings represent text using [Unicode](https://unicode.org) This guide will provide only a basic overview of Unicode (the [Unicode glossary](http://www.unicode.org/glossary/) has over 500 entries in it), but it will include the most relevant differences between these concepts:\n\n* Code points\n* Graphemes\n* UTF-8\n\nIt will also explain why some operations are included in Roc's builtin [Str](https://www.roc-lang.org/builtins/Str)\nmodule, and why others are in separate packages like [roc-lang/unicode](https://github.com/roc-lang/unicode).\n\n### Graphemes\n\nLet's start with the following string:\n\n`\"👩\u{200d}👩\u{200d}👦\u{200d}👦\"`\n\nSome might call this a \"character.\" After all, in a monospace font, it looks to be about the same width as the letter \"A\" or the punctuation mark \"!\"—both of which are commonly called \"characters.\" Unfortunately, the term \"character\" in programming has changed meanings many times across the years and across programming languages, and today it's become a major source of confusion.\n\nUnicode uses the less ambiguous term [*grapheme*](https://www.unicode.org/glossary/#grapheme), which it defines as a \"user-perceived character\" (as opposed to one of the several historical ways the term \"character\" has been used in programming) or, alternatively, \"A minimally distinctive unit of writing in the context of a particular writing system.\"\n\nBy Unicode's definition, each of the following is an individual grapheme:\n\n* `a`\n* `鹏`\n* `👩\u{200d}👩\u{200d}👦\u{200d}👦`\n\nNote that although *grapheme* is less ambiguous than *character*, its definition is still open to interpretation. To address this, Unicode has formally specified [text segmentation rules](https://www.unicode.org/reports/tr29/) which define grapheme boundaries in precise technical terms. We won't get into those rules here, but since they can change with new Unicode releases, functions for working with graphemes are in the [roc-lang/unicode](https://github.com/roc-lang/unicode) package rather than in the builtin [`Str`](https://www.roc-lang.org/builtins/Str) module. This allows them to be updated without being blocked on a new release of the Roc language.\n\n### Code Points\n\nEvery Unicode text value can be broken down into [Unicode code points](http://www.unicode.org/glossary/#code_point), which are integers between `0` and `285_212_438` that describe components of the text. In memory, every Roc string is a sequence of these integers stored in a format called UTF-8, which will be discussed [later](#utf8).\n\nThe string `\"👩\u{200d}👩\u{200d}👦\u{200d}👦\"` happens to be made up of these code points:\n\n```\n[128105, 8205, 128105, 8205, 128102, 8205, 128102]\n```\n\nFrom this we can see that:\n\n- One grapheme can be made up of multiple code points. In fact, there is no upper limit on how many code points can go into a single grapheme! (Some programming languages use the term \"character\" to refer to individual code points; this can be confusing for graphemes like 👩\u{200d}👩\u{200d}👦\u{200d}👦 because it visually looks like \"one character\" but no single code point can represent it.)\n- Sometimes code points repeat within an individual grapheme. Here, 128105 repeats twice, as does 128102, and there's an 8205 in between each of the other code points.\n\n### Combining Code Points\n\nThe reason every other code point in 👩\u{200d}👩\u{200d}👦\u{200d}👦 is 8205 is that code point 8205 joins together other code points. This emoji, known as [\"Family: Woman, Woman, Boy, Boy\"](https://emojipedia.org/family-woman-woman-boy-boy), is made by combining several emoji using [zero-width joiners](https://emojipedia.org/zero-width-joiner)—which are represented by code point 8205 in memory, and which have no visual repesentation on their own.\n\nHere are those code points again, this time with comments about what they represent:\n\n```\n[128105] # \"👩\"\n[8205] # (joiner)\n[128105] # \"👩\"\n[8205] # (joiner)\n[128102] # \"👦\"\n[8205] # (joiner)\n[128102] # \"👦\"\n```\n\nOne way to read this is \"woman emoji joined to woman emoji joined to boy emoji joined to boy emoji.\" Without the joins, it would be:\n\n```\n\"👩👩👦👦\"\n```\n\nWith the joins, however, it is instead:\n\n```\n\"👩\u{200d}👩\u{200d}👦\u{200d}👦\"\n```\n\nEven though 👩\u{200d}👩\u{200d}👦\u{200d}👦 is visually smaller when rendered, it takes up almost twice as much memory as 👩👩👦👦 does! That's because it has all the same code points, plus the zero-width joiners in between them.\n\n### String equality and normalization\n\nBesides emoji like 👩\u{200d}👩\u{200d}👦\u{200d}👦, another classic example of multiple code points being combined to render as one grapheme has to do with accent marks. Try putting these two strings into `roc repl`:\n\n```\n\"caf\\u(e9)\"\n\"cafe\\u(301)\"\n```\n\nThe `\\u(e9)` syntax is a way of inserting code points into string literals. In this case, it's the same as inserting the hexadecimal number `0xe9` as a code point onto the end of the string `\"caf\"`. Since Unicode code point `0xe9` happens to be `é`, the string `\"caf\\u(e9)\"` ends up being identical in memory to the string `\"café\"`.\n\nWe can verify this too:\n\n```\n» \"caf\\u(e9)\" == \"café\"\n\nBool.true : Bool\n```\n\nAs it turns out, `\"cafe\\u(301)\"` is another way to represent the same word. The Unicode code point 0x301 represents a [\"combining acute accent\"](https://unicodeplus.com/U+0301)—which essentially means that it will add an accent mark to whatever came before it. In this case, since `\"cafe\\u(301)\"` has an `e` before the `\"\\u(301)\"`, that `e` ends up with an accent mark on it and becomes `é`.\n\nAlthough these two strings get rendered identically to one another, they are different in memory because their code points are different! We can also confirm this in `roc repl`:\n\n```\n» \"caf\\u(e9)\" == \"cafe\\u(301)\"\n\nBool.false : Bool\n```\n\nAs you can imagine, this can be a source of bugs. Not only are they considered unequal, they also hash differently, meaning `\"caf\\u(e9)\"` and `\"cafe\\u(301)\"` can both be separate entries in the same [`Set`](https://www.roc-lang.org/builtins/Set).\n\n One way to prevent problems like these is to perform [Unicode normalization](https://www.unicode.org/reports/tr15/), a process which converts conceptually equivalent strings (like `\"caf\\u(e9)\"` and `\"cafe\\u(301)\"`) into one canonical in-memory representation. This makes equality checks on them pass, among other benefits.\n\nIt would be technically possible for Roc to perform string normalization automatically on every equality check. Unfortunately, although some programs might want to treat `\"caf\\u(e9)\"` and `\"cafe\\u(301)\"` as equivalent, for other programs it might actually be important to be able to tell them apart. If these equality checks always passed, then there would be no way to tell them apart!\n\nAs such, normalization must be performed explicitly when desired. Like graphemes, Unicode normalization rules can change with new releases of Unicode. As such, these functions are in separate packages instead of builtins (normalization is planned to be in [roc-lang/unicode](https://github.com/roc-lang/unicode) in the future, but it has not yet been implemented) so that updates to these functions based on new Unicode releases can happen without waiting on new releases of the Roc language.\n\n### Capitalization\n\nWe've already seen two examples of Unicode definitions that can change with new Unicode releases: graphemes and normalization. Another is capitalization; these rules can change with new Unicode releases (most often in the form of additions of new languages, but breaking changes to capitalization rules for existing languages are also possible), and so they are not included in builtin [`Str`](https://www.roc-lang.org/builtins/Str).\n\nThis might seem particularly surprising, since capitalization functions are commonly included in standard libraries. However, it turns out that \"capitalizing an arbitrary string\" is impossible to do correctly without additional information.\n\nFor example, what is the capitalized version of this string?\n\n```\n\"i\"\n```\n\n* In English, the correct answer is `\"I\"`.\n* In Turkish, the correct answer is `\"İ\"`.\n\nSimilarly, the correct lowercased version of the string `\"I\"` is `\"i\"` in English and `\"ı\"` in Turkish.\n\nTurkish is not the only language to use this [dotless i](https://en.wikipedia.org/wiki/Dotless_I), and it's an example of how a function which capitalizes strings cannot give correct answers without the additional information of which language's capitalization rules should be used.\n\nMany languages defer to the operating system's [localization](https://en.wikipedia.org/wiki/Internationalization_and_localization) settings for this information. In that design, calling a program's capitalization function with an input string of `\"i\"` might give an answer of `\"I\"` on one machine and `\"İ\"` on a different machine, even though it was the same program running on both systems. Naturally, this can cause bugs—but more than that, writing tests to prevent bugs like this usually requires extra complexity compared to writing ordinary tests.\n\nIn general, Roc programs should give the same answers for the same inputs even when run on different machines. There are exceptions to this (e.g. a program running out of system resources on one machine, while being able to make more progress on a machine that has more resources), but operating system's language localization is not among them.\n\nFor these reasons, capitalization functions are not in [`Str`](https://www.roc-lang.org/builtins/Str). There is a planned `roc-lang` package to handle use cases like capitalization and sorting—sorting can also vary by language as well as by things like country—but implementation work has not yet started on this package.\n\n### UTF-8\n\nEarlier, we discussed how Unicode code points can be described as [`U32`](https://www.roc-lang.org/builtins/Num#U32) integers. However, many common code points are very low integers, and can fit into a `U8` instead of needing an entire `U32` to represent them in memory. UTF-8 takes advantage of this, using a variable-width encoding to represent code points in 1-4 bytes, which saves a lot of memory in the typical case—especially compared to [UTF-16](https://en.wikipedia.org/wiki/UTF-16), which always uses at least 2 bytes to represent each code point, or [UTF-32](https://en.wikipedia.org/wiki/UTF-32), which always uses the maximum 4 bytes.\n\nThis guide won't cover all the details of UTF-8, but the basic idea is this:\n\n- If a code point is 127 or lower, UTF-8 stores it in 1 byte.\n- If it's between 128 and 2047, UTF-8 stores it in 2 bytes.\n- If it's between 2048 and 65535, UTF-8 stores it in 3 bytes.\n- If it's higher than that, UTF-8 stores it in 4 bytes.\n\nThe specific [UTF-8 encoding](https://en.wikipedia.org/wiki/UTF-8#Encoding) of these bytes involves using 1 to 5 bits of each byte for metadata about multi-byte sequences.\n\nA valuable feature of UTF-8 is that it is backwards-compatible with the [ASCII](https://en.wikipedia.org/wiki/ASCII) encoding that was widely used for many years. ASCII existed before Unicode did, and only used the integers 0 to 127 to represent its equivalent of code points. The Unicode code points 0 to 127 represent the same semantic information as ASCII, (e.g. the number 64 represents the letter \"A\" in both ASCII and in Unicode), and since UTF-8 represents code points 0 to 127 using one byte, all valid ASCII strings can be successfully parsed as UTF-8 without any need for conversion.\n\nSince many textual computer encodings—including [CSV](https://en.wikipedia.org/wiki/CSV), [XML](https://en.wikipedia.org/wiki/XML), and [JSON](https://en.wikipedia.org/wiki/JSON)—do not use any code points above 127 for their delimiters, it is often possible to write parsers for these formats using only `Str` functions which present UTF-8 as raw `U8` sequences, such as [`Str.walkUtf8`](https://www.roc-lang.org/builtins/Str#walkUtf8) and [`Str.toUtf8`](https://www.roc-lang.org/builtins/Str#toUtf8). In the typical case where they do not to need to parse out individual Unicode code points, they can get everything they need from `Str` UTF-8 functions without needing to depend on other packages.\n\n### When to use code points, graphemes, and UTF-8\n\nDeciding when to use code points, graphemes, and UTF-8 can be nonobvious to say the least!\n\nThe way Roc organizes the `Str` module and supporting packages is designed to help answer this question. Every situation is different, but the following rules of thumb are typical:\n\n* Most often, using `Str` values along with helper functions like [`split`](https://www.roc-lang.org/builtins/Str#split), [`joinWith`](https://www.roc-lang.org/builtins/Str#joinWith), and so on, is the best option.\n* If you are specifically implementing a parser, working in UTF-8 bytes is usually the best option. So functions like [`walkUtf8`](https://www.roc-lang.org/builtins/Str#walkUtf8), [toUtf8](https://www.roc-lang.org/builtins/Str#toUtf8), and so on. (Note that single-quote literals produce number literals, so ASCII-range literals like `'a'` gives an integer literal that works with a UTF-8 `U8`.)\n* If you are implementing a Unicode library like [roc-lang/unicode](https://github.com/roc-lang/unicode), working in terms of code points will be unavoidable. Aside from basic readability considerations like `\\u(...)` in string literals, if you have the option to avoid working in terms of code points, it is almost always correct to avoid them.\n* If it seems like a good idea to split a string into \"characters\" (graphemes), you should definitely stop and reconsider whether this is really the best design. Almost always, doing this is some combination of more error-prone or slower (usually both) than doing something else that does not require taking graphemes into consideration.\n\nFor this reason (among others), grapheme functions live in [roc-lang/unicode](https://github.com/roc-lang/unicode) rather than in [`Str`](https://www.roc-lang.org/builtins/Str). They are more niche than they seem, so they should not be reached for all the time!\n\n## Performance\n\nThis section deals with how Roc strings are represented in memory, and their performance characteristics.\n\nA normal heap-allocated roc `Str` is represented on the stack as:\n- A \"capacity\" unsigned integer, which respresents how many bytes are allocated on the heap to hold the string's contents.\n- A \"length\" unsigned integer, which rerepresents how many of the \"capacity\" bytes are actually in use. (A `Str` can have more bytes allocated on the heap than are actually in use.)\n- The memory address of the first byte in the string's actual contents.\n\nEach of these three fields is the same size: 64 bits on a 64-bit system, and 32 bits on a 32-bit system. The actual contents of the string are stored in one contiguous sequence of bytes, encoded as UTF-8, often on the heap but sometimes elsewhere—more on this later. Empty strings do not have heap allocations, so an empty `Str` on a 64-bit system still takes up 24 bytes on the stack (due to its three 64-bit fields).\n\n### Reference counting and opportunistic mutation\n\nLike lists, dictionaries, and sets, Roc strings are automatically reference-counted and can benefit from opportunistic in-place mutation. The reference count is stored on the heap immediately before the first byte of the string's contents, and it has the same size as a memory address. This means it can count so high that it's impossible to write a Roc program which overflows a reference count, because having that many simultaneous references (each of which is a memory address) would have exhausted the operating system's address space first.\n\nWhen the string's reference count is 1, functions like [`Str.concat`](https://www.roc-lang.org/builtins/Str#concat) and [`Str.replaceEach`](https://www.roc-lang.org/builtins/Str#replaceEach) mutate the string in-place rather than allocating a new string. This preserves semantic immutability because it is unobservable in terms of the operation's output; if the reference count is 1, it means that memory would have otherwise been deallocated immediately anyway, and it's more efficient to reuse it instead of deallocating it and then immediately making a new allocation.\n\n The contents of statically-known strings (today that means string literals) are stored in the readonly section of the binary, so they do not need heap allocations or reference counts. They are not eligible for in-place mutation, since mutating the readonly section of the binary would cause an operating system [access violation](https://en.wikipedia.org/wiki/Segmentation_fault).\n\n### Small String Optimization\n\nRoc uses a \"small string optimization\" when representing certain strings in memory.\n\nIf you have a sufficiently long string, then on a 64-bit system it will be represented on the stack using 24 bytes, and on a 32-bit system it will take 12 bytes—plus however many bytes are in the string itself—on the heap. However, if there is a string shorter than either of these stack sizes (so, a string of up to 23 bytes on a 64-bit system, and up to 11 bytes on a 32-bit system), then that string will be stored entirely on the stack rather than having a separate heap allocation at all.\n\nThis can be much more memory-efficient! However, `List` does not have this optimization (it has some runtime cost, and in the case of `List` it's not anticipated to come up nearly as often), which means when converting a small string to `List U8` it can result in a heap allocation.\n\nNote that this optimization is based entirely on how many UTF-8 bytes the string takes up in memory. It doesn't matter how many [graphemes](#graphemes), [code points](#code-points) or anything else it has; the only factor that determines whether a particular string is eligible for the small string optimization is the number of UTF-8 bytes it takes up in memory!\n\n### Seamless Slices\n\nTry putting this into `roc repl`:\n\n```\n» \"foo/bar/baz\" |> Str.split \"/\"\n\n[\"foo\", \"bar\", \"baz\"] : List Str\n```\n\nAll of these strings are small enough that the [small string optimization](#small) will apply, so none of them will be allocated on the heap.\n\nNow let's suppose they were long enough that this optimization no longer applied:\n\n```\n» \"a much, much, much, much/longer/string compared to the last one!\" |> Str.split \"/\"\n\n[\"a much, much, much, much\", \"longer\", \"string compared to the last one!\"] : List Str\n```\n\nHere, the only strings small enough for the small string optimization are `\"/\"` and `\"longer\"`. They will be allocated on the stack.\n\nThe first and last strings in the returned list `\"a much, much, much, much\"` and `\"string compared to the last one!\"` will not be allocated on the heap either. Instead, they will be *seamless slices*, which means they will share memory with the original input string.\n\n* `\"a much, much, much, much\"` will share the first 24 bytes of the original string.\n* `\"string compared to the last one!\"` will share the last 32 bytes of the original string.\n\nAll of these strings are semantically immutable, so sharing these bytes is an implementation detail that should only affect performance. By design, there is no way at either compile time or runtime to tell whether a string is a seamless slice. This allows the optimization's behavior to change in the future without affecting Roc programs' semantic behavior.\n\nSeamless slices create additional references to the original string, which make it ineligible for opportunistic mutation (along with the slices themselves; slices are never eligible for mutation), and which also make it take longer before the original string can be deallocated. A case where this might be noticeable in terms of performance would be:\n1. A function takes a very large string as an argument and returns a much smaller slice into that string.\n2. The smaller slice is used for a long time in the program, whereas the much larger original string stops being used.\n3. In this situation, it might have been better for total program memory usage (although not necessarily overall performance) if the original large string could have been deallocated sooner, even at the expense of having to copy the smaller string into a new allocation instead of reusing the bytes with a seamless slice.\n\nIf a situation like this comes up, a slice can be turned into a separate string by using [`Str.concat`](https://www.roc-lang.org/builtins/Str#concat) to concatenate the slice onto an empty string (or one created with [`Str.withCapacity`](https://www.roc-lang.org/builtins/Str#withCapacity)).\n\nCurrently, the only way to get seamless slices of strings is by calling certain `Str` functions which return them. In general, `Str` functions which accept a string and return a subset of that string tend to do this. [`Str.trim`](https://www.roc-lang.org/builtins/Str#trim) is another example of a function which returns a seamless slice.\n"
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns [Bool.true] if the string is empty, and [Bool.false] otherwise.\n```\nexpect Str.isEmpty \"hi!\" == Bool.false\nexpect Str.isEmpty \"\" == Bool.true\n```\n",
)
docs>>
<<docs:
Some(
"Concatenates two strings together.\n```\nexpect Str.concat \"ab\" \"cd\" == \"abcd\"\nexpect Str.concat \"hello\" \"\" == \"hello\"\nexpect Str.concat \"\" \"\" == \"\"\n```\n",
)
docs>>
<<docs:
Some(
"Returns a string of the specified capacity without any content.\n\nThis is a performance optimization tool that's like calling [Str.reserve] on an empty string.\nIt's useful when you plan to build up a string incrementally, for example by calling [Str.concat] on it:\n\n```\ngreeting = \"Hello and welcome to Roc\"\nsubject = \"Awesome Programmer\"\n\n# Evaluates to \"Hello and welcome to Roc, Awesome Programmer!\"\nhelloWorld =\n Str.withCapacity 45\n |> Str.concat greeting\n |> Str.concat \", \"\n |> Str.concat subject\n |> Str.concat \"!\"\n```\n\nIn general, if you plan to use [Str.concat] on an empty string, it will be faster to start with\n[Str.withCapacity] than with `\"\"`. Even if you don't know the exact capacity of the string, giving [withCapacity]\na higher value than ends up being necessary can help prevent reallocation and copying—at\nthe cost of using more memory than is necessary.\n\nFor more details on how the performance optimization works, see [Str.reserve].\n",
)
docs>>
<<docs:
Some(
"Increase a string's capacity by at least the given number of additional bytes.\n\nThis can improve the performance of string concatenation operations like [Str.concat] by\nallocating extra capacity up front, which can prevent the need for reallocations and copies.\nConsider the following example which does not use [Str.reserve]:\n\n```\ngreeting = \"Hello and welcome to Roc\"\nsubject = \"Awesome Programmer\"\n\n# Evaluates to \"Hello and welcome to Roc, Awesome Programmer!\"\nhelloWorld =\n greeting\n |> Str.concat \", \"\n |> Str.concat subject\n |> Str.concat \"!\"\n```\n\nIn this example:\n1. We start with `greeting`, which has both a length and capacity of 24 (bytes).\n2. `|> Str.concat \", \"` will see that there isn't enough capacity to add 2 more bytes for the `\", \"`, so it will create a new heap allocation with enough bytes to hold both. (This probably will be more than 7 bytes, because when [Str] functions reallocate, they apply a multiplier to the exact capacity required. This makes it less likely that future realloctions will be needed. The multiplier amount is not specified, because it may change in future releases of Roc, but it will likely be around 1.5 to 2 times the exact capacity required.) Then it will copy the current bytes (`\"Hello\"`) into the new allocation, and finally concatenate the `\", \"` into the new allocation. The old allocation will then be deallocated because it's no longer referenced anywhere in the program.\n3. `|> Str.concat subject` will again check if there is enough capacity in the string. If it doesn't find enough capacity once again, it will make a third allocation, copy the existing bytes (`\"Hello, \"`) into that third allocation, and then deallocate the second allocation because it's already no longer being referenced anywhere else in the program. (It may find enough capacity in this particular case, because the previous [Str.concat] allocated something like 1.5 to 2 times the necessary capacity in order to anticipate future concatenations like this...but if something longer than `\"World\"` were being concatenated here, it might still require further reallocation and copying.)\n4. `|> Str.concat \"!\\n\"` will repeat this process once more.\n\nThis process can have significant performance costs due to multiple reallocation of new strings, copying between old strings and new strings, and deallocation of immediately obsolete strings.\n\nHere's a modified example which uses [Str.reserve] to eliminate the need for all that reallocation, copying, and deallocation.\n\n```\nhelloWorld =\n greeting\n |> Str.reserve 21\n |> Str.concat \", \"\n |> Str.concat subject\n |> Str.concat \"!\"\n```\n\nIn this example:\n1. We again start with `greeting`, which has both a length and capacity of 24 bytes.\n2. `|> Str.reserve 21` will ensure that there is enough capacity in the string for an additional 21 bytes (to make room for `\", \"`, `\"Awesome Programmer\"`, and `\"!\"`). Since the current capacity is only 24, it will create a new 45-byte (24 + 21) heap allocation and copy the contents of the existing allocation (`greeting`) into it.\n3. `|> Str.concat \", \"` will concatenate `, ` to the string. No reallocation, copying, or deallocation will be necessary, because the string already has a capacity of 45 btytes, and `greeting` will only use 24 of them.\n4. `|> Str.concat subject` will concatenate `subject` (`\"Awesome Programmer\"`) to the string. Again, no reallocation, copying, or deallocation will be necessary.\n5. `|> Str.concat \"!\\n\"` will concatenate `\"!\\n\"` to the string, still without any reallocation, copying, or deallocation.\n\nHere, [Str.reserve] prevented multiple reallocations, copies, and deallocations during the\n[Str.concat] calls. Notice that it did perform a heap allocation before any [Str.concat] calls\nwere made, which means that using [Str.reserve] is not free! You should only use it if you actually\nexpect to make use of the extra capacity.\n\nIdeally, you'd be able to predict exactly how many extra bytes of capacity will be needed, but this\nmay not always be knowable. When you don't know exactly how many bytes to reserve, you can often get better\nperformance by choosing a number of bytes that's too high, because a number that's too low could lead to reallocations. There's a limit to\nthis, of course; if you always give it ten times what it turns out to need, that could prevent\nreallocations but will also waste a lot of memory!\n\nIf you plan to use [Str.reserve] on an empty string, it's generally better to use [Str.withCapacity] instead.\n",
)
docs>>
<<docs:
Some(
"Combines a [List] of strings into a single string, with a separator\nstring in between each.\n```\nexpect Str.joinWith [\"one\", \"two\", \"three\"] \", \" == \"one, two, three\"\nexpect Str.joinWith [\"1\", \"2\", \"3\", \"4\"] \".\" == \"1.2.3.4\"\n```\n",
)
docs>>
<<docs:
Some(
"Split a string around a separator.\n\nPassing `\"\"` for the separator is not useful;\nit returns the original string wrapped in a [List].\n```\nexpect Str.split \"1,2,3\" \",\" == [\"1\",\"2\",\"3\"]\nexpect Str.split \"1,2,3\" \"\" == [\"1,2,3\"]\n```\n",
)
docs>>
<<docs:
Some(
"Repeats a string the given number of times.\n```\nexpect Str.repeat \"z\" 3 == \"zzz\"\nexpect Str.repeat \"na\" 8 == \"nananananananana\"\n```\nReturns `\"\"` when given `\"\"` for the string or `0` for the count.\n```\nexpect Str.repeat \"\" 10 == \"\"\nexpect Str.repeat \"anything\" 0 == \"\"\n```\n",
)
docs>>
<<docs:
Some(
"Returns a [List] of the string's [U8] UTF-8 [code units](https://unicode.org/glossary/#code_unit).\n(To split the string into a [List] of smaller [Str] values instead of [U8] values,\nsee [Str.split].)\n```\nexpect Str.toUtf8 \"Roc\" == [82, 111, 99]\nexpect Str.toUtf8 \"鹏\" == [233, 185, 143]\nexpect Str.toUtf8 \"சி\" == [224, 174, 154, 224, 174, 191]\nexpect Str.toUtf8 \"🐦\" == [240, 159, 144, 166]\n```\n",
)
docs>>
<<docs:
Some(
"Converts a [List] of [U8] UTF-8 [code units](https://unicode.org/glossary/#code_unit) to a string.\n\nReturns `Err` if the given bytes are invalid UTF-8, and returns `Ok \"\"` when given `[]`.\n```\nexpect Str.fromUtf8 [82, 111, 99] == Ok \"Roc\"\nexpect Str.fromUtf8 [233, 185, 143] == Ok \"鹏\"\nexpect Str.fromUtf8 [224, 174, 154, 224, 174, 191] == Ok \"சி\"\nexpect Str.fromUtf8 [240, 159, 144, 166] == Ok \"🐦\"\nexpect Str.fromUtf8 [] == Ok \"\"\nexpect Str.fromUtf8 [255] |> Result.isErr\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Check if the given [Str] starts with a value.\n```\nexpect Str.startsWith \"ABC\" \"A\" == Bool.true\nexpect Str.startsWith \"ABC\" \"X\" == Bool.false\n```\n",
)
docs>>
<<docs:
Some(
"Check if the given [Str] ends with a value.\n```\nexpect Str.endsWith \"ABC\" \"C\" == Bool.true\nexpect Str.endsWith \"ABC\" \"X\" == Bool.false\n```\n",
)
docs>>
<<docs:
Some(
"Return the [Str] with all whitespace removed from both the beginning\nas well as the end.\n```\nexpect Str.trim \" Hello \\n\\n\" == \"Hello\"\n```\n",
)
docs>>
<<docs:
Some(
"Return the [Str] with all whitespace removed from the beginning.\n```\nexpect Str.trimStart \" Hello \\n\\n\" == \"Hello \\n\\n\"\n```\n",
)
docs>>
<<docs:
Some(
"Return the [Str] with all whitespace removed from the end.\n```\nexpect Str.trimEnd \" Hello \\n\\n\" == \" Hello\"\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to a [Dec]. A [Dec] value is a 128-bit decimal\n[fixed-point number](https://en.wikipedia.org/wiki/Fixed-point_arithmetic).\n```\nexpect Str.toDec \"10\" == Ok 10dec\nexpect Str.toDec \"-0.25\" == Ok -0.25dec\nexpect Str.toDec \"not a number\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to a [F64]. A [F64] value is a 64-bit\n[floating-point number](https://en.wikipedia.org/wiki/IEEE_754) and can be\nspecified with a `f64` suffix.\n```\nexpect Str.toF64 \"0.10\" == Ok 0.10f64\nexpect Str.toF64 \"not a number\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to a [F32].A [F32] value is a 32-bit\n[floating-point number](https://en.wikipedia.org/wiki/IEEE_754) and can be\nspecified with a `f32` suffix.\n```\nexpect Str.toF32 \"0.10\" == Ok 0.10f32\nexpect Str.toF32 \"not a number\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to an unsigned [U128] integer. A [U128] value can hold numbers\nfrom `0` to `340_282_366_920_938_463_463_374_607_431_768_211_455` (over\n340 undecillion). It can be specified with a u128 suffix.\n```\nexpect Str.toU128 \"1500\" == Ok 1500u128\nexpect Str.toU128 \"0.1\" == Err InvalidNumStr\nexpect Str.toU128 \"-1\" == Err InvalidNumStr\nexpect Str.toU128 \"not a number\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to a signed [I128] integer. A [I128] value can hold numbers\nfrom `-170_141_183_460_469_231_731_687_303_715_884_105_728` to\n`170_141_183_460_469_231_731_687_303_715_884_105_727`. It can be specified\nwith a i128 suffix.\n```\nexpect Str.toI128 \"1500\" == Ok 1500i128\nexpect Str.toI128 \"-1\" == Ok -1i128\nexpect Str.toI128 \"0.1\" == Err InvalidNumStr\nexpect Str.toI128 \"not a number\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to an unsigned [U64] integer. A [U64] value can hold numbers\nfrom `0` to `18_446_744_073_709_551_615` (over 18 quintillion). It\ncan be specified with a u64 suffix.\n```\nexpect Str.toU64 \"1500\" == Ok 1500u64\nexpect Str.toU64 \"0.1\" == Err InvalidNumStr\nexpect Str.toU64 \"-1\" == Err InvalidNumStr\nexpect Str.toU64 \"not a number\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to a signed [I64] integer. A [I64] value can hold numbers\nfrom `-9_223_372_036_854_775_808` to `9_223_372_036_854_775_807`. It can be\nspecified with a i64 suffix.\n```\nexpect Str.toI64 \"1500\" == Ok 1500i64\nexpect Str.toI64 \"-1\" == Ok -1i64\nexpect Str.toI64 \"0.1\" == Err InvalidNumStr\nexpect Str.toI64 \"not a number\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to an unsigned [U32] integer. A [U32] value can hold numbers\nfrom `0` to `4_294_967_295` (over 4 billion). It can be specified with\na u32 suffix.\n```\nexpect Str.toU32 \"1500\" == Ok 1500u32\nexpect Str.toU32 \"0.1\" == Err InvalidNumStr\nexpect Str.toU32 \"-1\" == Err InvalidNumStr\nexpect Str.toU32 \"not a number\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to a signed [I32] integer. A [I32] value can hold numbers\nfrom `-2_147_483_648` to `2_147_483_647`. It can be\nspecified with a i32 suffix.\n```\nexpect Str.toI32 \"1500\" == Ok 1500i32\nexpect Str.toI32 \"-1\" == Ok -1i32\nexpect Str.toI32 \"0.1\" == Err InvalidNumStr\nexpect Str.toI32 \"not a number\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to an unsigned [U16] integer. A [U16] value can hold numbers\nfrom `0` to `65_535`. It can be specified with a u16 suffix.\n```\nexpect Str.toU16 \"1500\" == Ok 1500u16\nexpect Str.toU16 \"0.1\" == Err InvalidNumStr\nexpect Str.toU16 \"-1\" == Err InvalidNumStr\nexpect Str.toU16 \"not a number\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to a signed [I16] integer. A [I16] value can hold numbers\nfrom `-32_768` to `32_767`. It can be\nspecified with a i16 suffix.\n```\nexpect Str.toI16 \"1500\" == Ok 1500i16\nexpect Str.toI16 \"-1\" == Ok -1i16\nexpect Str.toI16 \"0.1\" == Err InvalidNumStr\nexpect Str.toI16 \"not a number\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to an unsigned [U8] integer. A [U8] value can hold numbers\nfrom `0` to `255`. It can be specified with a u8 suffix.\n```\nexpect Str.toU8 \"250\" == Ok 250u8\nexpect Str.toU8 \"-0.1\" == Err InvalidNumStr\nexpect Str.toU8 \"not a number\" == Err InvalidNumStr\nexpect Str.toU8 \"1500\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Encode a [Str] to a signed [I8] integer. A [I8] value can hold numbers\nfrom `-128` to `127`. It can be\nspecified with a i8 suffix.\n```\nexpect Str.toI8 \"-15\" == Ok -15i8\nexpect Str.toI8 \"150.00\" == Err InvalidNumStr\nexpect Str.toI8 \"not a number\" == Err InvalidNumStr\n```\n",
)
docs>>
<<docs:
Some(
"Get the byte at the given index, without performing a bounds check.\n",
)
docs>>
<<docs:
Some(
"Gives the number of bytes in a [Str] value.\n```\nexpect Str.countUtf8Bytes \"Hello World\" == 11\n```\n",
)
docs>>
<<docs:
Some(
"string slice that does not do bounds checking or utf-8 verification\n",
)
docs>>
<<docs:
Some(
"Returns the given [Str] with each occurrence of a substring replaced.\nIf the substring is not found, returns the original string.\n\n```\nexpect Str.replaceEach \"foo/bar/baz\" \"/\" \"_\" == \"foo_bar_baz\"\nexpect Str.replaceEach \"not here\" \"/\" \"_\" == \"not here\"\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns the given [Str] with the first occurrence of a substring replaced.\nIf the substring is not found, returns the original string.\n\n```\nexpect Str.replaceFirst \"foo/bar/baz\" \"/\" \"_\" == \"foo_bar/baz\"\nexpect Str.replaceFirst \"no slashes here\" \"/\" \"_\" == \"no slashes here\"\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns the given [Str] with the last occurrence of a substring replaced.\nIf the substring is not found, returns the original string.\n\n```\nexpect Str.replaceLast \"foo/bar/baz\" \"/\" \"_\" == \"foo/bar_baz\"\nexpect Str.replaceLast \"no slashes here\" \"/\" \"_\" == \"no slashes here\"\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns the given [Str] before the first occurrence of a [delimiter](https://www.computerhope.com/jargon/d/delimite.htm), as well\nas the rest of the string after that occurrence.\nReturns [Err NotFound] if the delimiter is not found.\n```\nexpect Str.splitFirst \"foo/bar/baz\" \"/\" == Ok { before: \"foo\", after: \"bar/baz\" }\nexpect Str.splitFirst \"no slashes here\" \"/\" == Err NotFound\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns the given [Str] before the last occurrence of a delimiter, as well as\nthe rest of the string after that occurrence.\nReturns [Err NotFound] if the delimiter is not found.\n```\nexpect Str.splitLast \"foo/bar/baz\" \"/\" == Ok { before: \"foo/bar\", after: \"baz\" }\nexpect Str.splitLast \"no slashes here\" \"/\" == Err NotFound\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Walks over the `UTF-8` bytes of the given [Str] and calls a function to update\nstate for each byte. The index for that byte in the string is provided\nto the update function.\n```\nf : List U8, U8, U64 -> List U8\nf = \\state, byte, _ -> List.append state byte\nexpect Str.walkUtf8WithIndex \"ABC\" [] f == [65, 66, 67]\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Walks over the `UTF-8` bytes of the given [Str] and calls a function to update\nstate for each byte.\n\n```\nsumOfUtf8Bytes =\n Str.walkUtf8 \"Hello, World!\" 0 \\total, byte ->\n total + byte\n\nexpect sumOfUtf8Bytes == 105\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Shrink the memory footprint of a str such that its capacity and length are equal.\nNote: This will also convert seamless slices to regular lists.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Adds a prefix to the given [Str].\n```\nexpect Str.withPrefix \"Awesome\" \"Roc\" == \"RocAwesome\"\n```\n",
)
docs>>
<<docs:
Some(
"Determines whether or not the first Str contains the second.\n```\nexpect Str.contains \"foobarbaz\" \"bar\"\nexpect !(Str.contains \"apple\" \"orange\")\nexpect Str.contains \"anything\" \"\"\n```\n",
)
docs>>
adding docs for "Str.roc",
docs ModuleDocumentation {
name: "Str",
entries: [
DetachedDoc(
"Strings represent text. For example, `\"Hi!\"` is a string.\n\nThis guide starts at a high level and works down to the in-memory representation of strings and their [performance characteristics](#performance). For reasons that will be explained later in this guide, some string operations are in the `Str` module while others (notably [capitalization](#capitalization), [code points](#code-points), [graphemes](#graphemes), and sorting) are in separate packages. There's also a list of recommendations for [when to use code points, graphemes, and UTF-8](#when-to-use).\n\n## Syntax\n\nThe most common way to represent strings is using quotation marks:\n\n```\n\"Hello, World!\"\n```\n\nUsing this syntax, the whole string must go on one line. You can write multiline strings using triple quotes:\n\n```\ntext =\n \"\"\"\n In memory, this string will not have any spaces\n at its start. That's because the first line\n starts at the same indentation level as the\n opening quotation mark. Actually, none of these\n lines will be indented.\n\n However, this line will be indented!\n \"\"\"\n```\n\nIn triple-quoted strings, both the opening and closing `\"\"\"` must be at the same indentation level. Lines in the string begin at that indentation level; the spaces that indent the multiline string itself are not considered content.\n\n### Interpolation\n\n*String interpolation* is syntax for inserting a string into another string.\n\n```\nname = \"Sam\"\n\n\"Hi, my name is $(name)!\"\n```\n\nThis will evaluate to the string `\"Hi, my name is Sam!\"`\n\nYou can put any expression you like inside the parentheses, as long as it's all on one line:\n\n```\ncolors = [\"red\", \"green\", \"blue\"]\n\n\"The colors are $(colors |> Str.joinWith \", \")!\"\n```\n\nInterpolation can be used in multiline strings, but the part inside the parentheses must still be on one line.\n\n### Escapes\n\nThere are a few special escape sequences in strings:\n\n* `\\n` becomes a [newline](https://en.wikipedia.org/wiki/Newline)\n* `\\r` becomes a [carriage return](https://en.wikipedia.org/wiki/Carriage_return#Computers)\n* `\\t` becomes a [tab](https://en.wikipedia.org/wiki/Tab_key#Tab_characters)\n* `\\\"` becomes a normal `\"` (this lets you write `\"` inside a single-line string)\n* `\\\\` becomes a normal `\\` (this lets you write `\\` without it being treated as an escape)\n* `\\$` becomes a normal `$` (this lets you write `$` followed by `(` without it being treated as [interpolation](#interpolation))\n\nThese work in both single-line and multiline strings. We'll also discuss another escape later, for inserting [Unicode code points](#code-points) into a string.\n\n### Single quote syntax\n\nTry putting `'👩'` into `roc repl`. You should see this:\n\n```\n» '👩'\n\n128105 : Int *\n```\n\nThe single-quote `'` syntax lets you represent a Unicode code point (discussed in the next section) in source code, in a way that renders as the actual text it represents rather than as a number literal. This lets you see what it looks like in the source code rather than looking at a number.\n\nAt runtime, the single-quoted value will be treated the same as an ordinary number literal—in other words, `'👩'` is syntax sugar for writing `128105`. You can verify this in `roc repl`:\n\n```\n» '👩' == 128105\n\nBool.true : Bool\n```\n\nDouble quotes (`\"`), on the other hand, are not type-compatible with integers—not only because strings can be empty (`\"\"` is valid, but `''` is not) but also because there may be more than one code point involved in any given string!\n\nThere are also some special escape sequences in single-quote strings:\n\n* `\\n` becomes a [newline](https://en.wikipedia.org/wiki/Newline)\n* `\\r` becomes a [carriage return](https://en.wikipedia.org/wiki/Carriage_return#Computers)\n* `\\t` becomes a [tab](https://en.wikipedia.org/wiki/Tab_key#Tab_characters)\n* `\\'` becomes a normal `'` (this lets you write `'` inside a single-quote string)\n* `\\\\` becomes a normal `\\` (this lets you write `\\` without it being treated as an escape)\n\nMost often this single-quote syntax is used when writing parsers; most Roc programs never use it at all.\n\n## Unicode\n\nRoc strings represent text using [Unicode](https://unicode.org) This guide will provide only a basic overview of Unicode (the [Unicode glossary](http://www.unicode.org/glossary/) has over 500 entries in it), but it will include the most relevant differences between these concepts:\n\n* Code points\n* Graphemes\n* UTF-8\n\nIt will also explain why some operations are included in Roc's builtin [Str](https://www.roc-lang.org/builtins/Str)\nmodule, and why others are in separate packages like [roc-lang/unicode](https://github.com/roc-lang/unicode).\n\n### Graphemes\n\nLet's start with the following string:\n\n`\"👩\u{200d}👩\u{200d}👦\u{200d}👦\"`\n\nSome might call this a \"character.\" After all, in a monospace font, it looks to be about the same width as the letter \"A\" or the punctuation mark \"!\"—both of which are commonly called \"characters.\" Unfortunately, the term \"character\" in programming has changed meanings many times across the years and across programming languages, and today it's become a major source of confusion.\n\nUnicode uses the less ambiguous term [*grapheme*](https://www.unicode.org/glossary/#grapheme), which it defines as a \"user-perceived character\" (as opposed to one of the several historical ways the term \"character\" has been used in programming) or, alternatively, \"A minimally distinctive unit of writing in the context of a particular writing system.\"\n\nBy Unicode's definition, each of the following is an individual grapheme:\n\n* `a`\n* `鹏`\n* `👩\u{200d}👩\u{200d}👦\u{200d}👦`\n\nNote that although *grapheme* is less ambiguous than *character*, its definition is still open to interpretation. To address this, Unicode has formally specified [text segmentation rules](https://www.unicode.org/reports/tr29/) which define grapheme boundaries in precise technical terms. We won't get into those rules here, but since they can change with new Unicode releases, functions for working with graphemes are in the [roc-lang/unicode](https://github.com/roc-lang/unicode) package rather than in the builtin [`Str`](https://www.roc-lang.org/builtins/Str) module. This allows them to be updated without being blocked on a new release of the Roc language.\n\n### Code Points\n\nEvery Unicode text value can be broken down into [Unicode code points](http://www.unicode.org/glossary/#code_point), which are integers between `0` and `285_212_438` that describe components of the text. In memory, every Roc string is a sequence of these integers stored in a format called UTF-8, which will be discussed [later](#utf8).\n\nThe string `\"👩\u{200d}👩\u{200d}👦\u{200d}👦\"` happens to be made up of these code points:\n\n```\n[128105, 8205, 128105, 8205, 128102, 8205, 128102]\n```\n\nFrom this we can see that:\n\n- One grapheme can be made up of multiple code points. In fact, there is no upper limit on how many code points can go into a single grapheme! (Some programming languages use the term \"character\" to refer to individual code points; this can be confusing for graphemes like 👩\u{200d}👩\u{200d}👦\u{200d}👦 because it visually looks like \"one character\" but no single code point can represent it.)\n- Sometimes code points repeat within an individual grapheme. Here, 128105 repeats twice, as does 128102, and there's an 8205 in between each of the other code points.\n\n### Combining Code Points\n\nThe reason every other code point in 👩\u{200d}👩\u{200d}👦\u{200d}👦 is 8205 is that code point 8205 joins together other code points. This emoji, known as [\"Family: Woman, Woman, Boy, Boy\"](https://emojipedia.org/family-woman-woman-boy-boy), is made by combining several emoji using [zero-width joiners](https://emojipedia.org/zero-width-joiner)—which are represented by code point 8205 in memory, and which have no visual repesentation on their own.\n\nHere are those code points again, this time with comments about what they represent:\n\n```\n[128105] # \"👩\"\n[8205] # (joiner)\n[128105] # \"👩\"\n[8205] # (joiner)\n[128102] # \"👦\"\n[8205] # (joiner)\n[128102] # \"👦\"\n```\n\nOne way to read this is \"woman emoji joined to woman emoji joined to boy emoji joined to boy emoji.\" Without the joins, it would be:\n\n```\n\"👩👩👦👦\"\n```\n\nWith the joins, however, it is instead:\n\n```\n\"👩\u{200d}👩\u{200d}👦\u{200d}👦\"\n```\n\nEven though 👩\u{200d}👩\u{200d}👦\u{200d}👦 is visually smaller when rendered, it takes up almost twice as much memory as 👩👩👦👦 does! That's because it has all the same code points, plus the zero-width joiners in between them.\n\n### String equality and normalization\n\nBesides emoji like 👩\u{200d}👩\u{200d}👦\u{200d}👦, another classic example of multiple code points being combined to render as one grapheme has to do with accent marks. Try putting these two strings into `roc repl`:\n\n```\n\"caf\\u(e9)\"\n\"cafe\\u(301)\"\n```\n\nThe `\\u(e9)` syntax is a way of inserting code points into string literals. In this case, it's the same as inserting the hexadecimal number `0xe9` as a code point onto the end of the string `\"caf\"`. Since Unicode code point `0xe9` happens to be `é`, the string `\"caf\\u(e9)\"` ends up being identical in memory to the string `\"café\"`.\n\nWe can verify this too:\n\n```\n» \"caf\\u(e9)\" == \"café\"\n\nBool.true : Bool\n```\n\nAs it turns out, `\"cafe\\u(301)\"` is another way to represent the same word. The Unicode code point 0x301 represents a [\"combining acute accent\"](https://unicodeplus.com/U+0301)—which essentially means that it will add an accent mark to whatever came before it. In this case, since `\"cafe\\u(301)\"` has an `e` before the `\"\\u(301)\"`, that `e` ends up with an accent mark on it and becomes `é`.\n\nAlthough these two strings get rendered identically to one another, they are different in memory because their code points are different! We can also confirm this in `roc repl`:\n\n```\n» \"caf\\u(e9)\" == \"cafe\\u(301)\"\n\nBool.false : Bool\n```\n\nAs you can imagine, this can be a source of bugs. Not only are they considered unequal, they also hash differently, meaning `\"caf\\u(e9)\"` and `\"cafe\\u(301)\"` can both be separate entries in the same [`Set`](https://www.roc-lang.org/builtins/Set).\n\n One way to prevent problems like these is to perform [Unicode normalization](https://www.unicode.org/reports/tr15/), a process which converts conceptually equivalent strings (like `\"caf\\u(e9)\"` and `\"cafe\\u(301)\"`) into one canonical in-memory representation. This makes equality checks on them pass, among other benefits.\n\nIt would be technically possible for Roc to perform string normalization automatically on every equality check. Unfortunately, although some programs might want to treat `\"caf\\u(e9)\"` and `\"cafe\\u(301)\"` as equivalent, for other programs it might actually be important to be able to tell them apart. If these equality checks always passed, then there would be no way to tell them apart!\n\nAs such, normalization must be performed explicitly when desired. Like graphemes, Unicode normalization rules can change with new releases of Unicode. As such, these functions are in separate packages instead of builtins (normalization is planned to be in [roc-lang/unicode](https://github.com/roc-lang/unicode) in the future, but it has not yet been implemented) so that updates to these functions based on new Unicode releases can happen without waiting on new releases of the Roc language.\n\n### Capitalization\n\nWe've already seen two examples of Unicode definitions that can change with new Unicode releases: graphemes and normalization. Another is capitalization; these rules can change with new Unicode releases (most often in the form of additions of new languages, but breaking changes to capitalization rules for existing languages are also possible), and so they are not included in builtin [`Str`](https://www.roc-lang.org/builtins/Str).\n\nThis might seem particularly surprising, since capitalization functions are commonly included in standard libraries. However, it turns out that \"capitalizing an arbitrary string\" is impossible to do correctly without additional information.\n\nFor example, what is the capitalized version of this string?\n\n```\n\"i\"\n```\n\n* In English, the correct answer is `\"I\"`.\n* In Turkish, the correct answer is `\"İ\"`.\n\nSimilarly, the correct lowercased version of the string `\"I\"` is `\"i\"` in English and `\"ı\"` in Turkish.\n\nTurkish is not the only language to use this [dotless i](https://en.wikipedia.org/wiki/Dotless_I), and it's an example of how a function which capitalizes strings cannot give correct answers without the additional information of which language's capitalization rules should be used.\n\nMany languages defer to the operating system's [localization](https://en.wikipedia.org/wiki/Internationalization_and_localization) settings for this information. In that design, calling a program's capitalization function with an input string of `\"i\"` might give an answer of `\"I\"` on one machine and `\"İ\"` on a different machine, even though it was the same program running on both systems. Naturally, this can cause bugs—but more than that, writing tests to prevent bugs like this usually requires extra complexity compared to writing ordinary tests.\n\nIn general, Roc programs should give the same answers for the same inputs even when run on different machines. There are exceptions to this (e.g. a program running out of system resources on one machine, while being able to make more progress on a machine that has more resources), but operating system's language localization is not among them.\n\nFor these reasons, capitalization functions are not in [`Str`](https://www.roc-lang.org/builtins/Str). There is a planned `roc-lang` package to handle use cases like capitalization and sorting—sorting can also vary by language as well as by things like country—but implementation work has not yet started on this package.\n\n### UTF-8\n\nEarlier, we discussed how Unicode code points can be described as [`U32`](https://www.roc-lang.org/builtins/Num#U32) integers. However, many common code points are very low integers, and can fit into a `U8` instead of needing an entire `U32` to represent them in memory. UTF-8 takes advantage of this, using a variable-width encoding to represent code points in 1-4 bytes, which saves a lot of memory in the typical case—especially compared to [UTF-16](https://en.wikipedia.org/wiki/UTF-16), which always uses at least 2 bytes to represent each code point, or [UTF-32](https://en.wikipedia.org/wiki/UTF-32), which always uses the maximum 4 bytes.\n\nThis guide won't cover all the details of UTF-8, but the basic idea is this:\n\n- If a code point is 127 or lower, UTF-8 stores it in 1 byte.\n- If it's between 128 and 2047, UTF-8 stores it in 2 bytes.\n- If it's between 2048 and 65535, UTF-8 stores it in 3 bytes.\n- If it's higher than that, UTF-8 stores it in 4 bytes.\n\nThe specific [UTF-8 encoding](https://en.wikipedia.org/wiki/UTF-8#Encoding) of these bytes involves using 1 to 5 bits of each byte for metadata about multi-byte sequences.\n\nA valuable feature of UTF-8 is that it is backwards-compatible with the [ASCII](https://en.wikipedia.org/wiki/ASCII) encoding that was widely used for many years. ASCII existed before Unicode did, and only used the integers 0 to 127 to represent its equivalent of code points. The Unicode code points 0 to 127 represent the same semantic information as ASCII, (e.g. the number 64 represents the letter \"A\" in both ASCII and in Unicode), and since UTF-8 represents code points 0 to 127 using one byte, all valid ASCII strings can be successfully parsed as UTF-8 without any need for conversion.\n\nSince many textual computer encodings—including [CSV](https://en.wikipedia.org/wiki/CSV), [XML](https://en.wikipedia.org/wiki/XML), and [JSON](https://en.wikipedia.org/wiki/JSON)—do not use any code points above 127 for their delimiters, it is often possible to write parsers for these formats using only `Str` functions which present UTF-8 as raw `U8` sequences, such as [`Str.walkUtf8`](https://www.roc-lang.org/builtins/Str#walkUtf8) and [`Str.toUtf8`](https://www.roc-lang.org/builtins/Str#toUtf8). In the typical case where they do not to need to parse out individual Unicode code points, they can get everything they need from `Str` UTF-8 functions without needing to depend on other packages.\n\n### When to use code points, graphemes, and UTF-8\n\nDeciding when to use code points, graphemes, and UTF-8 can be nonobvious to say the least!\n\nThe way Roc organizes the `Str` module and supporting packages is designed to help answer this question. Every situation is different, but the following rules of thumb are typical:\n\n* Most often, using `Str` values along with helper functions like [`split`](https://www.roc-lang.org/builtins/Str#split), [`joinWith`](https://www.roc-lang.org/builtins/Str#joinWith), and so on, is the best option.\n* If you are specifically implementing a parser, working in UTF-8 bytes is usually the best option. So functions like [`walkUtf8`](https://www.roc-lang.org/builtins/Str#walkUtf8), [toUtf8](https://www.roc-lang.org/builtins/Str#toUtf8), and so on. (Note that single-quote literals produce number literals, so ASCII-range literals like `'a'` gives an integer literal that works with a UTF-8 `U8`.)\n* If you are implementing a Unicode library like [roc-lang/unicode](https://github.com/roc-lang/unicode), working in terms of code points will be unavoidable. Aside from basic readability considerations like `\\u(...)` in string literals, if you have the option to avoid working in terms of code points, it is almost always correct to avoid them.\n* If it seems like a good idea to split a string into \"characters\" (graphemes), you should definitely stop and reconsider whether this is really the best design. Almost always, doing this is some combination of more error-prone or slower (usually both) than doing something else that does not require taking graphemes into consideration.\n\nFor this reason (among others), grapheme functions live in [roc-lang/unicode](https://github.com/roc-lang/unicode) rather than in [`Str`](https://www.roc-lang.org/builtins/Str). They are more niche than they seem, so they should not be reached for all the time!\n\n## Performance\n\nThis section deals with how Roc strings are represented in memory, and their performance characteristics.\n\nA normal heap-allocated roc `Str` is represented on the stack as:\n- A \"capacity\" unsigned integer, which respresents how many bytes are allocated on the heap to hold the string's contents.\n- A \"length\" unsigned integer, which rerepresents how many of the \"capacity\" bytes are actually in use. (A `Str` can have more bytes allocated on the heap than are actually in use.)\n- The memory address of the first byte in the string's actual contents.\n\nEach of these three fields is the same size: 64 bits on a 64-bit system, and 32 bits on a 32-bit system. The actual contents of the string are stored in one contiguous sequence of bytes, encoded as UTF-8, often on the heap but sometimes elsewhere—more on this later. Empty strings do not have heap allocations, so an empty `Str` on a 64-bit system still takes up 24 bytes on the stack (due to its three 64-bit fields).\n\n### Reference counting and opportunistic mutation\n\nLike lists, dictionaries, and sets, Roc strings are automatically reference-counted and can benefit from opportunistic in-place mutation. The reference count is stored on the heap immediately before the first byte of the string's contents, and it has the same size as a memory address. This means it can count so high that it's impossible to write a Roc program which overflows a reference count, because having that many simultaneous references (each of which is a memory address) would have exhausted the operating system's address space first.\n\nWhen the string's reference count is 1, functions like [`Str.concat`](https://www.roc-lang.org/builtins/Str#concat) and [`Str.replaceEach`](https://www.roc-lang.org/builtins/Str#replaceEach) mutate the string in-place rather than allocating a new string. This preserves semantic immutability because it is unobservable in terms of the operation's output; if the reference count is 1, it means that memory would have otherwise been deallocated immediately anyway, and it's more efficient to reuse it instead of deallocating it and then immediately making a new allocation.\n\n The contents of statically-known strings (today that means string literals) are stored in the readonly section of the binary, so they do not need heap allocations or reference counts. They are not eligible for in-place mutation, since mutating the readonly section of the binary would cause an operating system [access violation](https://en.wikipedia.org/wiki/Segmentation_fault).\n\n### Small String Optimization\n\nRoc uses a \"small string optimization\" when representing certain strings in memory.\n\nIf you have a sufficiently long string, then on a 64-bit system it will be represented on the stack using 24 bytes, and on a 32-bit system it will take 12 bytes—plus however many bytes are in the string itself—on the heap. However, if there is a string shorter than either of these stack sizes (so, a string of up to 23 bytes on a 64-bit system, and up to 11 bytes on a 32-bit system), then that string will be stored entirely on the stack rather than having a separate heap allocation at all.\n\nThis can be much more memory-efficient! However, `List` does not have this optimization (it has some runtime cost, and in the case of `List` it's not anticipated to come up nearly as often), which means when converting a small string to `List U8` it can result in a heap allocation.\n\nNote that this optimization is based entirely on how many UTF-8 bytes the string takes up in memory. It doesn't matter how many [graphemes](#graphemes), [code points](#code-points) or anything else it has; the only factor that determines whether a particular string is eligible for the small string optimization is the number of UTF-8 bytes it takes up in memory!\n\n### Seamless Slices\n\nTry putting this into `roc repl`:\n\n```\n» \"foo/bar/baz\" |> Str.split \"/\"\n\n[\"foo\", \"bar\", \"baz\"] : List Str\n```\n\nAll of these strings are small enough that the [small string optimization](#small) will apply, so none of them will be allocated on the heap.\n\nNow let's suppose they were long enough that this optimization no longer applied:\n\n```\n» \"a much, much, much, much/longer/string compared to the last one!\" |> Str.split \"/\"\n\n[\"a much, much, much, much\", \"longer\", \"string compared to the last one!\"] : List Str\n```\n\nHere, the only strings small enough for the small string optimization are `\"/\"` and `\"longer\"`. They will be allocated on the stack.\n\nThe first and last strings in the returned list `\"a much, much, much, much\"` and `\"string compared to the last one!\"` will not be allocated on the heap either. Instead, they will be *seamless slices*, which means they will share memory with the original input string.\n\n* `\"a much, much, much, much\"` will share the first 24 bytes of the original string.\n* `\"string compared to the last one!\"` will share the last 32 bytes of the original string.\n\nAll of these strings are semantically immutable, so sharing these bytes is an implementation detail that should only affect performance. By design, there is no way at either compile time or runtime to tell whether a string is a seamless slice. This allows the optimization's behavior to change in the future without affecting Roc programs' semantic behavior.\n\nSeamless slices create additional references to the original string, which make it ineligible for opportunistic mutation (along with the slices themselves; slices are never eligible for mutation), and which also make it take longer before the original string can be deallocated. A case where this might be noticeable in terms of performance would be:\n1. A function takes a very large string as an argument and returns a much smaller slice into that string.\n2. The smaller slice is used for a long time in the program, whereas the much larger original string stops being used.\n3. In this situation, it might have been better for total program memory usage (although not necessarily overall performance) if the original large string could have been deallocated sooner, even at the expense of having to copy the smaller string into a new allocation instead of reusing the bytes with a seamless slice.\n\nIf a situation like this comes up, a slice can be turned into a separate string by using [`Str.concat`](https://www.roc-lang.org/builtins/Str#concat) to concatenate the slice onto an empty string (or one created with [`Str.withCapacity`](https://www.roc-lang.org/builtins/Str#withCapacity)).\n\nCurrently, the only way to get seamless slices of strings is by calling certain `Str` functions which return them. In general, `Str` functions which accept a string and return a subset of that string tend to do this. [`Str.trim`](https://www.roc-lang.org/builtins/Str#trim) is another example of a function which returns a seamless slice.\n",
),
DocDef(
DocDef {
name: "Utf8ByteProblem",
symbol: `Str.Utf8ByteProblem`,
type_vars: [],
type_annotation: TagUnion {
tags: [
Tag {
name: "InvalidStartByte",
values: [],
},
Tag {
name: "UnexpectedEndOfSequence",
values: [],
},
Tag {
name: "ExpectedContinuation",
values: [],
},
Tag {
name: "OverlongEncoding",
values: [],
},
Tag {
name: "CodepointTooLarge",
values: [],
},
Tag {
name: "EncodesSurrogateHalf",
values: [],
},
],
extension: NoTypeAnn,
},
docs: None,
},
),
DocDef(
DocDef {
name: "Utf8Problem",
symbol: `Str.Utf8Problem`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "isEmpty",
symbol: `Str.isEmpty`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Returns [Bool.true] if the string is empty, and [Bool.false] otherwise.\n```\nexpect Str.isEmpty \"hi!\" == Bool.false\nexpect Str.isEmpty \"\" == Bool.true\n```\n",
),
},
),
DocDef(
DocDef {
name: "concat",
symbol: `Str.concat`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Concatenates two strings together.\n```\nexpect Str.concat \"ab\" \"cd\" == \"abcd\"\nexpect Str.concat \"hello\" \"\" == \"hello\"\nexpect Str.concat \"\" \"\" == \"\"\n```\n",
),
},
),
DocDef(
DocDef {
name: "withCapacity",
symbol: `Str.withCapacity`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Returns a string of the specified capacity without any content.\n\nThis is a performance optimization tool that's like calling [Str.reserve] on an empty string.\nIt's useful when you plan to build up a string incrementally, for example by calling [Str.concat] on it:\n\n```\ngreeting = \"Hello and welcome to Roc\"\nsubject = \"Awesome Programmer\"\n\n# Evaluates to \"Hello and welcome to Roc, Awesome Programmer!\"\nhelloWorld =\n Str.withCapacity 45\n |> Str.concat greeting\n |> Str.concat \", \"\n |> Str.concat subject\n |> Str.concat \"!\"\n```\n\nIn general, if you plan to use [Str.concat] on an empty string, it will be faster to start with\n[Str.withCapacity] than with `\"\"`. Even if you don't know the exact capacity of the string, giving [withCapacity]\na higher value than ends up being necessary can help prevent reallocation and copying—at\nthe cost of using more memory than is necessary.\n\nFor more details on how the performance optimization works, see [Str.reserve].\n",
),
},
),
DocDef(
DocDef {
name: "reserve",
symbol: `Str.reserve`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Increase a string's capacity by at least the given number of additional bytes.\n\nThis can improve the performance of string concatenation operations like [Str.concat] by\nallocating extra capacity up front, which can prevent the need for reallocations and copies.\nConsider the following example which does not use [Str.reserve]:\n\n```\ngreeting = \"Hello and welcome to Roc\"\nsubject = \"Awesome Programmer\"\n\n# Evaluates to \"Hello and welcome to Roc, Awesome Programmer!\"\nhelloWorld =\n greeting\n |> Str.concat \", \"\n |> Str.concat subject\n |> Str.concat \"!\"\n```\n\nIn this example:\n1. We start with `greeting`, which has both a length and capacity of 24 (bytes).\n2. `|> Str.concat \", \"` will see that there isn't enough capacity to add 2 more bytes for the `\", \"`, so it will create a new heap allocation with enough bytes to hold both. (This probably will be more than 7 bytes, because when [Str] functions reallocate, they apply a multiplier to the exact capacity required. This makes it less likely that future realloctions will be needed. The multiplier amount is not specified, because it may change in future releases of Roc, but it will likely be around 1.5 to 2 times the exact capacity required.) Then it will copy the current bytes (`\"Hello\"`) into the new allocation, and finally concatenate the `\", \"` into the new allocation. The old allocation will then be deallocated because it's no longer referenced anywhere in the program.\n3. `|> Str.concat subject` will again check if there is enough capacity in the string. If it doesn't find enough capacity once again, it will make a third allocation, copy the existing bytes (`\"Hello, \"`) into that third allocation, and then deallocate the second allocation because it's already no longer being referenced anywhere else in the program. (It may find enough capacity in this particular case, because the previous [Str.concat] allocated something like 1.5 to 2 times the necessary capacity in order to anticipate future concatenations like this...but if something longer than `\"World\"` were being concatenated here, it might still require further reallocation and copying.)\n4. `|> Str.concat \"!\\n\"` will repeat this process once more.\n\nThis process can have significant performance costs due to multiple reallocation of new strings, copying between old strings and new strings, and deallocation of immediately obsolete strings.\n\nHere's a modified example which uses [Str.reserve] to eliminate the need for all that reallocation, copying, and deallocation.\n\n```\nhelloWorld =\n greeting\n |> Str.reserve 21\n |> Str.concat \", \"\n |> Str.concat subject\n |> Str.concat \"!\"\n```\n\nIn this example:\n1. We again start with `greeting`, which has both a length and capacity of 24 bytes.\n2. `|> Str.reserve 21` will ensure that there is enough capacity in the string for an additional 21 bytes (to make room for `\", \"`, `\"Awesome Programmer\"`, and `\"!\"`). Since the current capacity is only 24, it will create a new 45-byte (24 + 21) heap allocation and copy the contents of the existing allocation (`greeting`) into it.\n3. `|> Str.concat \", \"` will concatenate `, ` to the string. No reallocation, copying, or deallocation will be necessary, because the string already has a capacity of 45 btytes, and `greeting` will only use 24 of them.\n4. `|> Str.concat subject` will concatenate `subject` (`\"Awesome Programmer\"`) to the string. Again, no reallocation, copying, or deallocation will be necessary.\n5. `|> Str.concat \"!\\n\"` will concatenate `\"!\\n\"` to the string, still without any reallocation, copying, or deallocation.\n\nHere, [Str.reserve] prevented multiple reallocations, copies, and deallocations during the\n[Str.concat] calls. Notice that it did perform a heap allocation before any [Str.concat] calls\nwere made, which means that using [Str.reserve] is not free! You should only use it if you actually\nexpect to make use of the extra capacity.\n\nIdeally, you'd be able to predict exactly how many extra bytes of capacity will be needed, but this\nmay not always be knowable. When you don't know exactly how many bytes to reserve, you can often get better\nperformance by choosing a number of bytes that's too high, because a number that's too low could lead to reallocations. There's a limit to\nthis, of course; if you always give it ten times what it turns out to need, that could prevent\nreallocations but will also waste a lot of memory!\n\nIf you plan to use [Str.reserve] on an empty string, it's generally better to use [Str.withCapacity] instead.\n",
),
},
),
DocDef(
DocDef {
name: "joinWith",
symbol: `Str.joinWith`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Str",
parts: [],
},
],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Combines a [List] of strings into a single string, with a separator\nstring in between each.\n```\nexpect Str.joinWith [\"one\", \"two\", \"three\"] \", \" == \"one, two, three\"\nexpect Str.joinWith [\"1\", \"2\", \"3\", \"4\"] \".\" == \"1.2.3.4\"\n```\n",
),
},
),
DocDef(
DocDef {
name: "split",
symbol: `Str.split`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
Apply {
name: "Str",
parts: [],
},
],
},
},
docs: Some(
"Split a string around a separator.\n\nPassing `\"\"` for the separator is not useful;\nit returns the original string wrapped in a [List].\n```\nexpect Str.split \"1,2,3\" \",\" == [\"1\",\"2\",\"3\"]\nexpect Str.split \"1,2,3\" \"\" == [\"1,2,3\"]\n```\n",
),
},
),
DocDef(
DocDef {
name: "repeat",
symbol: `Str.repeat`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Repeats a string the given number of times.\n```\nexpect Str.repeat \"z\" 3 == \"zzz\"\nexpect Str.repeat \"na\" 8 == \"nananananananana\"\n```\nReturns `\"\"` when given `\"\"` for the string or `0` for the count.\n```\nexpect Str.repeat \"\" 10 == \"\"\nexpect Str.repeat \"anything\" 0 == \"\"\n```\n",
),
},
),
DocDef(
DocDef {
name: "toUtf8",
symbol: `Str.toUtf8`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
},
docs: Some(
"Returns a [List] of the string's [U8] UTF-8 [code units](https://unicode.org/glossary/#code_unit).\n(To split the string into a [List] of smaller [Str] values instead of [U8] values,\nsee [Str.split].)\n```\nexpect Str.toUtf8 \"Roc\" == [82, 111, 99]\nexpect Str.toUtf8 \"鹏\" == [233, 185, 143]\nexpect Str.toUtf8 \"சி\" == [224, 174, 154, 224, 174, 191]\nexpect Str.toUtf8 \"🐦\" == [240, 159, 144, 166]\n```\n",
),
},
),
DocDef(
DocDef {
name: "fromUtf8",
symbol: `Str.fromUtf8`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Str",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "BadUtf8",
values: [
Apply {
name: "Utf8ByteProblem",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Converts a [List] of [U8] UTF-8 [code units](https://unicode.org/glossary/#code_unit) to a string.\n\nReturns `Err` if the given bytes are invalid UTF-8, and returns `Ok \"\"` when given `[]`.\n```\nexpect Str.fromUtf8 [82, 111, 99] == Ok \"Roc\"\nexpect Str.fromUtf8 [233, 185, 143] == Ok \"鹏\"\nexpect Str.fromUtf8 [224, 174, 154, 224, 174, 191] == Ok \"சி\"\nexpect Str.fromUtf8 [240, 159, 144, 166] == Ok \"🐦\"\nexpect Str.fromUtf8 [] == Ok \"\"\nexpect Str.fromUtf8 [255] |> Result.isErr\n```\n",
),
},
),
DocDef(
DocDef {
name: "FromUtf8Result",
symbol: `Str.FromUtf8Result`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "fromUtf8Lowlevel",
symbol: `Str.fromUtf8Lowlevel`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
],
output: Apply {
name: "FromUtf8Result",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "startsWith",
symbol: `Str.startsWith`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Check if the given [Str] starts with a value.\n```\nexpect Str.startsWith \"ABC\" \"A\" == Bool.true\nexpect Str.startsWith \"ABC\" \"X\" == Bool.false\n```\n",
),
},
),
DocDef(
DocDef {
name: "endsWith",
symbol: `Str.endsWith`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Check if the given [Str] ends with a value.\n```\nexpect Str.endsWith \"ABC\" \"C\" == Bool.true\nexpect Str.endsWith \"ABC\" \"X\" == Bool.false\n```\n",
),
},
),
DocDef(
DocDef {
name: "trim",
symbol: `Str.trim`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Return the [Str] with all whitespace removed from both the beginning\nas well as the end.\n```\nexpect Str.trim \" Hello \\n\\n\" == \"Hello\"\n```\n",
),
},
),
DocDef(
DocDef {
name: "trimStart",
symbol: `Str.trimStart`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Return the [Str] with all whitespace removed from the beginning.\n```\nexpect Str.trimStart \" Hello \\n\\n\" == \"Hello \\n\\n\"\n```\n",
),
},
),
DocDef(
DocDef {
name: "trimEnd",
symbol: `Str.trimEnd`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Return the [Str] with all whitespace removed from the end.\n```\nexpect Str.trimEnd \" Hello \\n\\n\" == \" Hello\"\n```\n",
),
},
),
DocDef(
DocDef {
name: "toDec",
symbol: `Str.toDec`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Dec",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to a [Dec]. A [Dec] value is a 128-bit decimal\n[fixed-point number](https://en.wikipedia.org/wiki/Fixed-point_arithmetic).\n```\nexpect Str.toDec \"10\" == Ok 10dec\nexpect Str.toDec \"-0.25\" == Ok -0.25dec\nexpect Str.toDec \"not a number\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "toF64",
symbol: `Str.toF64`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "F64",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to a [F64]. A [F64] value is a 64-bit\n[floating-point number](https://en.wikipedia.org/wiki/IEEE_754) and can be\nspecified with a `f64` suffix.\n```\nexpect Str.toF64 \"0.10\" == Ok 0.10f64\nexpect Str.toF64 \"not a number\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "toF32",
symbol: `Str.toF32`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "F32",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to a [F32].A [F32] value is a 32-bit\n[floating-point number](https://en.wikipedia.org/wiki/IEEE_754) and can be\nspecified with a `f32` suffix.\n```\nexpect Str.toF32 \"0.10\" == Ok 0.10f32\nexpect Str.toF32 \"not a number\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "toU128",
symbol: `Str.toU128`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "U128",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to an unsigned [U128] integer. A [U128] value can hold numbers\nfrom `0` to `340_282_366_920_938_463_463_374_607_431_768_211_455` (over\n340 undecillion). It can be specified with a u128 suffix.\n```\nexpect Str.toU128 \"1500\" == Ok 1500u128\nexpect Str.toU128 \"0.1\" == Err InvalidNumStr\nexpect Str.toU128 \"-1\" == Err InvalidNumStr\nexpect Str.toU128 \"not a number\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "toI128",
symbol: `Str.toI128`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "I128",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to a signed [I128] integer. A [I128] value can hold numbers\nfrom `-170_141_183_460_469_231_731_687_303_715_884_105_728` to\n`170_141_183_460_469_231_731_687_303_715_884_105_727`. It can be specified\nwith a i128 suffix.\n```\nexpect Str.toI128 \"1500\" == Ok 1500i128\nexpect Str.toI128 \"-1\" == Ok -1i128\nexpect Str.toI128 \"0.1\" == Err InvalidNumStr\nexpect Str.toI128 \"not a number\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "toU64",
symbol: `Str.toU64`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "U64",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to an unsigned [U64] integer. A [U64] value can hold numbers\nfrom `0` to `18_446_744_073_709_551_615` (over 18 quintillion). It\ncan be specified with a u64 suffix.\n```\nexpect Str.toU64 \"1500\" == Ok 1500u64\nexpect Str.toU64 \"0.1\" == Err InvalidNumStr\nexpect Str.toU64 \"-1\" == Err InvalidNumStr\nexpect Str.toU64 \"not a number\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "toI64",
symbol: `Str.toI64`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "I64",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to a signed [I64] integer. A [I64] value can hold numbers\nfrom `-9_223_372_036_854_775_808` to `9_223_372_036_854_775_807`. It can be\nspecified with a i64 suffix.\n```\nexpect Str.toI64 \"1500\" == Ok 1500i64\nexpect Str.toI64 \"-1\" == Ok -1i64\nexpect Str.toI64 \"0.1\" == Err InvalidNumStr\nexpect Str.toI64 \"not a number\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "toU32",
symbol: `Str.toU32`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "U32",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to an unsigned [U32] integer. A [U32] value can hold numbers\nfrom `0` to `4_294_967_295` (over 4 billion). It can be specified with\na u32 suffix.\n```\nexpect Str.toU32 \"1500\" == Ok 1500u32\nexpect Str.toU32 \"0.1\" == Err InvalidNumStr\nexpect Str.toU32 \"-1\" == Err InvalidNumStr\nexpect Str.toU32 \"not a number\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "toI32",
symbol: `Str.toI32`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "I32",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to a signed [I32] integer. A [I32] value can hold numbers\nfrom `-2_147_483_648` to `2_147_483_647`. It can be\nspecified with a i32 suffix.\n```\nexpect Str.toI32 \"1500\" == Ok 1500i32\nexpect Str.toI32 \"-1\" == Ok -1i32\nexpect Str.toI32 \"0.1\" == Err InvalidNumStr\nexpect Str.toI32 \"not a number\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "toU16",
symbol: `Str.toU16`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "U16",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to an unsigned [U16] integer. A [U16] value can hold numbers\nfrom `0` to `65_535`. It can be specified with a u16 suffix.\n```\nexpect Str.toU16 \"1500\" == Ok 1500u16\nexpect Str.toU16 \"0.1\" == Err InvalidNumStr\nexpect Str.toU16 \"-1\" == Err InvalidNumStr\nexpect Str.toU16 \"not a number\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "toI16",
symbol: `Str.toI16`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "I16",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to a signed [I16] integer. A [I16] value can hold numbers\nfrom `-32_768` to `32_767`. It can be\nspecified with a i16 suffix.\n```\nexpect Str.toI16 \"1500\" == Ok 1500i16\nexpect Str.toI16 \"-1\" == Ok -1i16\nexpect Str.toI16 \"0.1\" == Err InvalidNumStr\nexpect Str.toI16 \"not a number\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "toU8",
symbol: `Str.toU8`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "U8",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to an unsigned [U8] integer. A [U8] value can hold numbers\nfrom `0` to `255`. It can be specified with a u8 suffix.\n```\nexpect Str.toU8 \"250\" == Ok 250u8\nexpect Str.toU8 \"-0.1\" == Err InvalidNumStr\nexpect Str.toU8 \"not a number\" == Err InvalidNumStr\nexpect Str.toU8 \"1500\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "toI8",
symbol: `Str.toI8`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "I8",
parts: [],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Encode a [Str] to a signed [I8] integer. A [I8] value can hold numbers\nfrom `-128` to `127`. It can be\nspecified with a i8 suffix.\n```\nexpect Str.toI8 \"-15\" == Ok -15i8\nexpect Str.toI8 \"150.00\" == Err InvalidNumStr\nexpect Str.toI8 \"not a number\" == Err InvalidNumStr\n```\n",
),
},
),
DocDef(
DocDef {
name: "getUnsafe",
symbol: `Str.getUnsafe`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "U8",
parts: [],
},
},
docs: Some(
"Get the byte at the given index, without performing a bounds check.\n",
),
},
),
DocDef(
DocDef {
name: "countUtf8Bytes",
symbol: `Str.countUtf8Bytes`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: Some(
"Gives the number of bytes in a [Str] value.\n```\nexpect Str.countUtf8Bytes \"Hello World\" == 11\n```\n",
),
},
),
DocDef(
DocDef {
name: "substringUnsafe",
symbol: `Str.substringUnsafe`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"string slice that does not do bounds checking or utf-8 verification\n",
),
},
),
DocDef(
DocDef {
name: "replaceEach",
symbol: `Str.replaceEach`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Returns the given [Str] with each occurrence of a substring replaced.\nIf the substring is not found, returns the original string.\n\n```\nexpect Str.replaceEach \"foo/bar/baz\" \"/\" \"_\" == \"foo_bar_baz\"\nexpect Str.replaceEach \"not here\" \"/\" \"_\" == \"not here\"\n```\n",
),
},
),
DocDef(
DocDef {
name: "replaceEachHelp",
symbol: `Str.replaceEachHelp`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "replaceFirst",
symbol: `Str.replaceFirst`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Returns the given [Str] with the first occurrence of a substring replaced.\nIf the substring is not found, returns the original string.\n\n```\nexpect Str.replaceFirst \"foo/bar/baz\" \"/\" \"_\" == \"foo_bar/baz\"\nexpect Str.replaceFirst \"no slashes here\" \"/\" \"_\" == \"no slashes here\"\n```\n",
),
},
),
DocDef(
DocDef {
name: "replaceLast",
symbol: `Str.replaceLast`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Returns the given [Str] with the last occurrence of a substring replaced.\nIf the substring is not found, returns the original string.\n\n```\nexpect Str.replaceLast \"foo/bar/baz\" \"/\" \"_\" == \"foo/bar_baz\"\nexpect Str.replaceLast \"no slashes here\" \"/\" \"_\" == \"no slashes here\"\n```\n",
),
},
),
DocDef(
DocDef {
name: "splitFirst",
symbol: `Str.splitFirst`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Record {
fields: [
RecordField {
name: "before",
type_annotation: Apply {
name: "Str",
parts: [],
},
},
RecordField {
name: "after",
type_annotation: Apply {
name: "Str",
parts: [],
},
},
],
extension: NoTypeAnn,
},
TagUnion {
tags: [
Tag {
name: "NotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Returns the given [Str] before the first occurrence of a [delimiter](https://www.computerhope.com/jargon/d/delimite.htm), as well\nas the rest of the string after that occurrence.\nReturns [Err NotFound] if the delimiter is not found.\n```\nexpect Str.splitFirst \"foo/bar/baz\" \"/\" == Ok { before: \"foo\", after: \"bar/baz\" }\nexpect Str.splitFirst \"no slashes here\" \"/\" == Err NotFound\n```\n",
),
},
),
DocDef(
DocDef {
name: "firstMatch",
symbol: `Str.firstMatch`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: TagUnion {
tags: [
Tag {
name: "Some",
values: [
Apply {
name: "U64",
parts: [],
},
],
},
Tag {
name: "None",
values: [],
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "firstMatchHelp",
symbol: `Str.firstMatchHelp`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: TagUnion {
tags: [
Tag {
name: "Some",
values: [
Apply {
name: "U64",
parts: [],
},
],
},
Tag {
name: "None",
values: [],
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "splitLast",
symbol: `Str.splitLast`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Record {
fields: [
RecordField {
name: "before",
type_annotation: Apply {
name: "Str",
parts: [],
},
},
RecordField {
name: "after",
type_annotation: Apply {
name: "Str",
parts: [],
},
},
],
extension: NoTypeAnn,
},
TagUnion {
tags: [
Tag {
name: "NotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Returns the given [Str] before the last occurrence of a delimiter, as well as\nthe rest of the string after that occurrence.\nReturns [Err NotFound] if the delimiter is not found.\n```\nexpect Str.splitLast \"foo/bar/baz\" \"/\" == Ok { before: \"foo/bar\", after: \"baz\" }\nexpect Str.splitLast \"no slashes here\" \"/\" == Err NotFound\n```\n",
),
},
),
DocDef(
DocDef {
name: "lastMatch",
symbol: `Str.lastMatch`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: TagUnion {
tags: [
Tag {
name: "Some",
values: [
Apply {
name: "U64",
parts: [],
},
],
},
Tag {
name: "None",
values: [],
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "lastMatchHelp",
symbol: `Str.lastMatchHelp`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: TagUnion {
tags: [
Tag {
name: "Some",
values: [
Apply {
name: "U64",
parts: [],
},
],
},
Tag {
name: "None",
values: [],
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "matchesAt",
symbol: `Str.matchesAt`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "walkUtf8WithIndex",
symbol: `Str.walkUtf8WithIndex`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
Apply {
name: "U8",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"state",
),
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Walks over the `UTF-8` bytes of the given [Str] and calls a function to update\nstate for each byte. The index for that byte in the string is provided\nto the update function.\n```\nf : List U8, U8, U64 -> List U8\nf = \\state, byte, _ -> List.append state byte\nexpect Str.walkUtf8WithIndex \"ABC\" [] f == [65, 66, 67]\n```\n",
),
},
),
DocDef(
DocDef {
name: "walkUtf8WithIndexHelp",
symbol: `Str.walkUtf8WithIndexHelp`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
Apply {
name: "U8",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"state",
),
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"state",
),
},
docs: None,
},
),
DocDef(
DocDef {
name: "walkUtf8",
symbol: `Str.walkUtf8`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
Apply {
name: "U8",
parts: [],
},
],
output: BoundVariable(
"state",
),
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Walks over the `UTF-8` bytes of the given [Str] and calls a function to update\nstate for each byte.\n\n```\nsumOfUtf8Bytes =\n Str.walkUtf8 \"Hello, World!\" 0 \\total, byte ->\n total + byte\n\nexpect sumOfUtf8Bytes == 105\n```\n",
),
},
),
DocDef(
DocDef {
name: "walkUtf8Help",
symbol: `Str.walkUtf8Help`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
Apply {
name: "U8",
parts: [],
},
],
output: BoundVariable(
"state",
),
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"state",
),
},
docs: None,
},
),
DocDef(
DocDef {
name: "releaseExcessCapacity",
symbol: `Str.releaseExcessCapacity`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Shrink the memory footprint of a str such that its capacity and length are equal.\nNote: This will also convert seamless slices to regular lists.\n",
),
},
),
DocDef(
DocDef {
name: "strToNum",
symbol: `Str.strToNum`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Record {
fields: [
RecordField {
name: "berrorcode",
type_annotation: Apply {
name: "U8",
parts: [],
},
},
RecordField {
name: "aresult",
type_annotation: Apply {
name: "Num",
parts: [
Wildcard,
],
},
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "strToNumHelp",
symbol: `Str.strToNumHelp`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Result",
parts: [
Apply {
name: "Num",
parts: [
BoundVariable(
"a",
),
],
},
TagUnion {
tags: [
Tag {
name: "InvalidNumStr",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "withPrefix",
symbol: `Str.withPrefix`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: Some(
"Adds a prefix to the given [Str].\n```\nexpect Str.withPrefix \"Awesome\" \"Roc\" == \"RocAwesome\"\n```\n",
),
},
),
DocDef(
DocDef {
name: "contains",
symbol: `Str.contains`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Determines whether or not the first Str contains the second.\n```\nexpect Str.contains \"foobarbaz\" \"bar\"\nexpect !(Str.contains \"apple\" \"orange\")\nexpect Str.contains \"anything\" \"\"\n```\n",
),
},
),
],
scope: Scope {
aliases: VecMap {
keys: [
`Num.Binary32`,
`Num.F32`,
`Num.FloatingPoint`,
`Num.Unsigned16`,
`Num.U16`,
`Bool.Bool`,
`Num.U64`,
`Num.Binary64`,
`Num.Int`,
`Num.Signed128`,
`Num.Unsigned8`,
`Num.Frac`,
`Num.U32`,
`Num.Signed64`,
`Num.Signed8`,
`Num.I64`,
`Num.U8`,
`Num.I16`,
`Result.Result`,
`Num.Unsigned128`,
`Num.I8`,
`Num.Num`,
`Num.Decimal`,
`Num.Unsigned32`,
`Num.Signed32`,
`Num.Integer`,
`Num.I128`,
`Num.U128`,
`Num.I32`,
`Num.Signed16`,
`Num.Unsigned64`,
`Num.F64`,
`Num.Dec`,
`Str.Utf8ByteProblem`,
`Str.Utf8Problem`,
`Str.FromUtf8Result`,
],
values: [
Alias {
region: @17634-17642,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19444-19447,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17650-17669,
type_variables: [
@17664-17669 AliasVar {
name: 'range',
var: 67,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <67>,
kind: Opaque,
},
Alias {
region: @17202-17212,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17544-17547,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @1780-1784,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: ['False', 'True'],
kind: Opaque,
},
Alias {
region: @17482-17485,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17619-17627,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @12895-12904,
type_variables: [
@12899-12904 AliasVar {
name: 'range',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` <64>[ but actually <64> ])[ but actually (Alias `Num.Integer` <64>[ but actually <64> ]) ]),
kind: Structural,
},
Alias {
region: @17074-17083,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17219-17228,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17034-17044,
type_variables: [
@17039-17044 AliasVar {
name: 'range',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` <65>[ but actually <65> ])[ but actually (Alias `Num.FloatingPoint` <65>[ but actually <65> ]) ]),
kind: Structural,
},
Alias {
region: @17513-17516,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17090-17098,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17135-17142,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17291-17294,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17575-17577,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17349-17352,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @241-254,
type_variables: [
@248-250 AliasVar {
name: 'ok',
var: 64,
opt_bound_abilities: None,
},
@251-254 AliasVar {
name: 'err',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['Err' <65>, 'Ok' <64>]<63>,
kind: Structural,
},
Alias {
region: @17150-17161,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17431-17433,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Int` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ]) ]) ]),
kind: Structural,
},
Alias {
region: @5228-5237,
type_variables: [
@5232-5237 AliasVar {
name: 'range',
var: 63,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <63>,
kind: Opaque,
},
Alias {
region: @17605-17612,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17185-17195,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17105-17113,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17236-17249,
type_variables: [
@17244-17249 AliasVar {
name: 'range',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <66>,
kind: Opaque,
},
Alias {
region: @17260-17264,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17449-17453,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17320-17323,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17120-17128,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17168-17178,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19085-19088,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @23363-23366,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @26725-26740,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<63>,
kind: Structural,
},
Alias {
region: @26896-26907,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
64,
],
recursion_variables: {},
typ: { 'problem' : RigidRequired((Alias `Str.Utf8ByteProblem`[ but actually ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<64> ]))'byteIndex' : RigidRequired((DelayedAlias `Num.U64`)), },
kind: Structural,
},
Alias {
region: @35465-35479,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
65,
],
recursion_variables: {},
typ: { 'dProblemCode' : RigidRequired((Alias `Str.Utf8ByteProblem`[ but actually ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<65> ]))'cIsOk' : RigidRequired((DelayedAlias `Bool.Bool`)), 'aByteIndex' : RigidRequired((DelayedAlias `Num.U64`)), 'bString' : RigidRequired((`Str.Str`)), },
kind: Structural,
},
],
},
abilities_store: IAbilitiesStore {
members_of_ability: {
`Bool.Eq`: [
`Bool.isEq`,
],
},
specialization_to_root: {
`Bool.boolIsEq`: ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
},
},
ability_members: {
`Bool.isEq`: AbilityMemberData {
parent_ability: `Bool.Eq`,
region: @1635-1639,
typ: Imported,
},
},
declared_implementations: {
ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
}: Impl(
`Bool.boolIsEq`,
),
},
specializations: {},
next_specialization_id: 25,
resolved_specializations: {},
},
home: Str,
exposed_ident_count: 49,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "U8",
},
),
`Num.U8`,
@26651-26653,
),
(
Ident(
IdentStr {
string: "Result",
},
),
`Result.Result`,
@26608-26614,
),
(
Ident(
IdentStr {
string: "Eq",
},
),
`Bool.Eq`,
@26585-26587,
),
(
Ident(
IdentStr {
string: "I8",
},
),
`Num.I8`,
@26676-26678,
),
(
Ident(
IdentStr {
string: "I128",
},
),
`Num.I128`,
@26695-26699,
),
(
Ident(
IdentStr {
string: "Dec",
},
),
`Num.Dec`,
@26711-26714,
),
(
Ident(
IdentStr {
string: "U64",
},
),
`Num.U64`,
@26665-26668,
),
(
Ident(
IdentStr {
string: "I64",
},
),
`Num.I64`,
@26690-26693,
),
(
Ident(
IdentStr {
string: "U16",
},
),
`Num.U16`,
@26655-26658,
),
(
Ident(
IdentStr {
string: "Bool",
},
),
`Bool.Bool`,
@26579-26583,
),
(
Ident(
IdentStr {
string: "U128",
},
),
`Num.U128`,
@26670-26674,
),
(
Ident(
IdentStr {
string: "F64",
},
),
`Num.F64`,
@26706-26709,
),
(
Ident(
IdentStr {
string: "Num",
},
),
`Num.Num`,
@26646-26649,
),
(
Ident(
IdentStr {
string: "I32",
},
),
`Num.I32`,
@26685-26688,
),
(
Ident(
IdentStr {
string: "I16",
},
),
`Num.I16`,
@26680-26683,
),
(
Ident(
IdentStr {
string: "F32",
},
),
`Num.F32`,
@26701-26704,
),
(
Ident(
IdentStr {
string: "U32",
},
),
`Num.U32`,
@26660-26663,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
83,
116,
114,
105,
115,
69,
109,
112,
116,
121,
35,
97,
112,
112,
101,
110,
100,
99,
111,
110,
99,
97,
116,
106,
111,
105,
110,
87,
105,
116,
104,
115,
112,
108,
105,
116,
119,
105,
116,
104,
80,
114,
101,
102,
105,
120,
115,
116,
97,
114,
116,
115,
87,
105,
116,
104,
101,
110,
100,
115,
87,
105,
116,
104,
102,
114,
111,
109,
85,
116,
102,
56,
85,
116,
102,
56,
80,
114,
111,
98,
108,
101,
109,
85,
116,
102,
56,
66,
121,
116,
101,
80,
114,
111,
98,
108,
101,
109,
116,
111,
85,
116,
102,
56,
119,
97,
108,
107,
85,
116,
102,
56,
35,
97,
108,
105,
97,
115,
65,
110,
97,
108,
121,
115,
105,
115,
83,
116,
97,
116,
105,
99,
102,
114,
111,
109,
85,
116,
102,
56,
82,
97,
110,
103,
101,
114,
101,
112,
101,
97,
116,
116,
114,
105,
109,
116,
114,
105,
109,
83,
116,
97,
114,
116,
116,
114,
105,
109,
69,
110,
100,
119,
105,
116,
104,
67,
97,
112,
97,
99,
105,
116,
121,
116,
111,
70,
54,
52,
116,
111,
70,
51,
50,
116,
111,
68,
101,
99,
116,
111,
85,
49,
50,
56,
116,
111,
73,
49,
50,
56,
116,
111,
85,
54,
52,
116,
111,
73,
54,
52,
116,
111,
85,
51,
50,
116,
111,
73,
51,
50,
116,
111,
85,
49,
54,
116,
111,
73,
49,
54,
116,
111,
85,
56,
116,
111,
73,
56,
99,
111,
110,
116,
97,
105,
110,
115,
103,
101,
116,
85,
110,
115,
97,
102,
101,
99,
111,
117,
110,
116,
85,
116,
102,
56,
66,
121,
116,
101,
115,
115,
117,
98,
115,
116,
114,
105,
110,
103,
85,
110,
115,
97,
102,
101,
115,
112,
108,
105,
116,
70,
105,
114,
115,
116,
115,
112,
108,
105,
116,
76,
97,
115,
116,
119,
97,
108,
107,
85,
116,
102,
56,
87,
105,
116,
104,
73,
110,
100,
101,
120,
114,
101,
115,
101,
114,
118,
101,
115,
116,
114,
84,
111,
78,
117,
109,
102,
114,
111,
109,
85,
116,
102,
56,
76,
111,
119,
108,
101,
118,
101,
108,
99,
97,
112,
97,
99,
105,
116,
121,
114,
101,
112,
108,
97,
99,
101,
69,
97,
99,
104,
114,
101,
112,
108,
97,
99,
101,
70,
105,
114,
115,
116,
114,
101,
112,
108,
97,
99,
101,
76,
97,
115,
116,
114,
101,
108,
101,
97,
115,
101,
69,
120,
99,
101,
115,
115,
67,
97,
112,
97,
99,
105,
116,
121,
70,
114,
111,
109,
85,
116,
102,
56,
82,
101,
115,
117,
108,
116,
114,
101,
112,
108,
97,
99,
101,
69,
97,
99,
104,
72,
101,
108,
112,
102,
105,
114,
115,
116,
77,
97,
116,
99,
104,
102,
105,
114,
115,
116,
77,
97,
116,
99,
104,
72,
101,
108,
112,
108,
97,
115,
116,
77,
97,
116,
99,
104,
108,
97,
115,
116,
77,
97,
116,
99,
104,
72,
101,
108,
112,
109,
105,
110,
109,
97,
116,
99,
104,
101,
115,
65,
116,
109,
97,
116,
99,
104,
101,
115,
65,
116,
72,
101,
108,
112,
119,
97,
108,
107,
85,
116,
102,
56,
87,
105,
116,
104,
73,
110,
100,
101,
120,
72,
101,
108,
112,
119,
97,
108,
107,
85,
116,
102,
56,
72,
101,
108,
112,
115,
116,
114,
84,
111,
78,
117,
109,
72,
101,
108,
112,
85,
54,
52,
85,
116,
102,
56,
66,
121,
116,
101,
80,
114,
111,
98,
108,
101,
109,
85,
54,
52,
83,
116,
114,
66,
111,
111,
108,
85,
116,
102,
56,
66,
121,
116,
101,
80,
114,
111,
98,
108,
101,
109,
98,
121,
116,
101,
115,
114,
101,
115,
117,
108,
116,
54,
57,
55,
48,
55,
49,
115,
116,
114,
105,
110,
103,
104,
97,
121,
115,
116,
97,
99,
107,
110,
101,
101,
100,
108,
101,
102,
108,
111,
119,
101,
114,
98,
101,
102,
111,
114,
101,
97,
102,
116,
101,
114,
98,
117,
102,
105,
110,
100,
101,
120,
114,
101,
109,
97,
105,
110,
105,
110,
103,
49,
49,
50,
49,
49,
51,
49,
49,
52,
104,
97,
121,
115,
116,
97,
99,
107,
76,
101,
110,
103,
116,
104,
110,
101,
101,
100,
108,
101,
76,
101,
110,
103,
116,
104,
108,
97,
115,
116,
80,
111,
115,
115,
105,
98,
108,
101,
49,
50,
52,
49,
50,
53,
49,
51,
50,
49,
51,
51,
49,
51,
52,
108,
97,
115,
116,
80,
111,
115,
115,
105,
98,
108,
101,
73,
110,
100,
101,
120,
49,
52,
51,
110,
101,
120,
116,
73,
110,
100,
101,
120,
49,
52,
53,
120,
121,
104,
97,
121,
115,
116,
97,
99,
107,
73,
110,
100,
101,
120,
101,
110,
100,
73,
110,
100,
101,
120,
115,
116,
97,
116,
101,
110,
101,
101,
100,
108,
101,
73,
110,
100,
101,
120,
105,
115,
65,
116,
69,
110,
100,
79,
102,
72,
97,
121,
115,
116,
97,
99,
107,
100,
105,
100,
87,
97,
108,
107,
69,
110,
116,
105,
114,
101,
78,
101,
101,
100,
108,
101,
100,
111,
101,
115,
84,
104,
105,
115,
77,
97,
116,
99,
104,
100,
111,
101,
115,
82,
101,
115,
116,
77,
97,
116,
99,
104,
115,
116,
101,
112,
108,
101,
110,
103,
116,
104,
98,
121,
116,
101,
110,
101,
119,
83,
116,
97,
116,
101,
115,
116,
114,
105,
110,
105,
116,
105,
97,
108,
49,
56,
55,
49,
56,
56,
49,
56,
57,
112,
114,
101,
102,
105,
120,
49,
57,
52,
49,
57,
53,
49,
57,
54,
49,
57,
55,
49,
57,
56,
49,
57,
57,
50,
48,
48,
50,
48,
49,
50,
48,
50,
50,
48,
51,
50,
48,
52,
50,
48,
53,
50,
48,
54,
50,
48,
55,
50,
48,
56,
50,
48,
57,
50,
49,
48,
50,
49,
49,
50,
49,
50,
50,
49,
51,
50,
49,
52,
50,
49,
53,
50,
49,
54,
50,
49,
55,
50,
49,
56,
50,
49,
57,
50,
50,
48,
50,
50,
49,
50,
50,
50,
50,
50,
51,
50,
50,
52,
50,
50,
53,
50,
50,
54,
50,
50,
55,
50,
50,
56,
50,
50,
57,
50,
51,
48,
50,
51,
49,
],
lengths: [
Interned(3),
Interned(7),
Interned(7),
Interned(6),
Interned(8),
Interned(5),
Interned(10),
Interned(10),
Interned(8),
Interned(8),
Interned(11),
Interned(15),
Interned(6),
Interned(8),
Interned(20),
Interned(13),
Interned(6),
Interned(4),
Interned(9),
Interned(7),
Interned(12),
Interned(5),
Interned(5),
Interned(5),
Interned(6),
Interned(6),
Interned(5),
Interned(5),
Interned(5),
Interned(5),
Interned(5),
Interned(5),
Interned(4),
Interned(4),
Interned(8),
Interned(9),
Interned(14),
Interned(15),
Interned(10),
Interned(9),
Interned(17),
Interned(7),
Interned(8),
Interned(16),
Interned(8),
Interned(11),
Interned(12),
Interned(11),
Interned(21),
Interned(14),
Interned(15),
Interned(10),
Interned(14),
Interned(9),
Interned(13),
Interned(3),
Interned(9),
Interned(13),
Interned(21),
Interned(12),
Interned(12),
Interned(3),
Interned(15),
Interned(3),
Interned(3),
Interned(4),
Interned(15),
Interned(5),
Interned(6),
Generated(2),
Generated(2),
Generated(2),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(8),
Interned(6),
Interned(6),
Interned(6),
Interned(5),
Interned(3),
Interned(8),
Interned(6),
Interned(6),
Interned(6),
Interned(5),
Interned(8),
Interned(6),
Interned(6),
Interned(6),
Interned(5),
Interned(8),
Interned(6),
Interned(6),
Interned(6),
Interned(5),
Interned(8),
Interned(6),
Interned(5),
Interned(9),
Interned(6),
Interned(5),
Generated(3),
Generated(3),
Generated(3),
Interned(8),
Interned(6),
Interned(14),
Interned(12),
Interned(12),
Interned(8),
Interned(6),
Interned(5),
Interned(12),
Generated(3),
Generated(3),
Interned(8),
Interned(6),
Interned(5),
Interned(9),
Interned(6),
Interned(5),
Generated(3),
Generated(3),
Generated(3),
Interned(8),
Interned(6),
Interned(14),
Interned(12),
Interned(17),
Interned(8),
Interned(6),
Interned(5),
Generated(3),
Interned(9),
Generated(3),
Interned(1),
Interned(1),
Interned(8),
Interned(13),
Interned(6),
Interned(14),
Interned(12),
Interned(8),
Interned(5),
Interned(8),
Interned(13),
Interned(6),
Interned(11),
Interned(12),
Interned(8),
Interned(17),
Interned(19),
Interned(13),
Interned(13),
Interned(6),
Interned(5),
Interned(4),
Interned(6),
Interned(5),
Interned(4),
Interned(5),
Interned(6),
Interned(4),
Interned(8),
Interned(3),
Interned(7),
Interned(4),
Interned(3),
Interned(5),
Interned(4),
Interned(5),
Interned(6),
Interned(4),
Interned(8),
Interned(6),
Interned(6),
Generated(3),
Generated(3),
Generated(3),
Interned(3),
Interned(6),
Interned(8),
Interned(6),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
],
offsets: [
0,
3,
10,
17,
23,
31,
36,
46,
56,
64,
72,
83,
98,
104,
112,
132,
145,
151,
155,
164,
171,
183,
188,
193,
198,
204,
210,
215,
220,
225,
230,
235,
240,
244,
248,
256,
265,
279,
294,
304,
313,
330,
337,
345,
361,
369,
380,
392,
403,
424,
438,
453,
463,
477,
486,
499,
502,
511,
524,
545,
557,
569,
572,
587,
590,
593,
597,
612,
617,
623,
625,
627,
629,
629,
629,
629,
629,
629,
629,
629,
629,
629,
629,
629,
629,
635,
643,
649,
655,
661,
666,
635,
643,
649,
655,
661,
635,
643,
649,
655,
661,
635,
643,
649,
655,
661,
635,
643,
669,
674,
655,
661,
683,
686,
689,
635,
643,
692,
706,
718,
635,
643,
669,
718,
730,
733,
635,
643,
669,
674,
655,
661,
736,
739,
742,
635,
643,
692,
706,
745,
635,
643,
669,
762,
765,
774,
777,
778,
635,
779,
643,
692,
706,
792,
800,
635,
779,
643,
805,
706,
792,
816,
833,
852,
865,
629,
800,
878,
629,
800,
878,
669,
882,
888,
892,
900,
903,
878,
900,
800,
878,
669,
882,
888,
892,
629,
617,
910,
913,
916,
900,
919,
635,
643,
925,
928,
931,
934,
937,
940,
943,
946,
949,
952,
955,
958,
961,
964,
967,
970,
973,
976,
979,
982,
985,
988,
991,
994,
997,
1000,
1003,
1006,
1009,
1012,
1015,
1018,
1021,
1024,
1027,
1030,
1033,
1036,
],
strings: [
"Str",
"isEmpty",
"#append",
"concat",
"joinWith",
"split",
"withPrefix",
"startsWith",
"endsWith",
"fromUtf8",
"Utf8Problem",
"Utf8ByteProblem",
"toUtf8",
"walkUtf8",
"#aliasAnalysisStatic",
"fromUtf8Range",
"repeat",
"trim",
"trimStart",
"trimEnd",
"withCapacity",
"toF64",
"toF32",
"toDec",
"toU128",
"toI128",
"toU64",
"toI64",
"toU32",
"toI32",
"toU16",
"toI16",
"toU8",
"toI8",
"contains",
"getUnsafe",
"countUtf8Bytes",
"substringUnsafe",
"splitFirst",
"splitLast",
"walkUtf8WithIndex",
"reserve",
"strToNum",
"fromUtf8Lowlevel",
"capacity",
"replaceEach",
"replaceFirst",
"replaceLast",
"releaseExcessCapacity",
"FromUtf8Result",
"replaceEachHelp",
"firstMatch",
"firstMatchHelp",
"lastMatch",
"lastMatchHelp",
"min",
"matchesAt",
"matchesAtHelp",
"walkUtf8WithIndexHelp",
"walkUtf8Help",
"strToNumHelp",
"U64",
"Utf8ByteProblem",
"U64",
"Str",
"Bool",
"Utf8ByteProblem",
"bytes",
"result",
"69",
"70",
"71",
"string",
"string",
"string",
"string",
"string",
"string",
"string",
"string",
"string",
"string",
"string",
"string",
"string",
"haystack",
"needle",
"flower",
"before",
"after",
"buf",
"haystack",
"needle",
"flower",
"before",
"after",
"haystack",
"needle",
"flower",
"before",
"after",
"haystack",
"needle",
"flower",
"before",
"after",
"haystack",
"needle",
"index",
"remaining",
"before",
"after",
"112",
"113",
"114",
"haystack",
"needle",
"haystackLength",
"needleLength",
"lastPossible",
"haystack",
"needle",
"index",
"lastPossible",
"124",
"125",
"haystack",
"needle",
"index",
"remaining",
"before",
"after",
"132",
"133",
"134",
"haystack",
"needle",
"haystackLength",
"needleLength",
"lastPossibleIndex",
"haystack",
"needle",
"index",
"143",
"nextIndex",
"145",
"x",
"y",
"haystack",
"haystackIndex",
"needle",
"haystackLength",
"needleLength",
"endIndex",
"state",
"haystack",
"haystackIndex",
"needle",
"needleIndex",
"needleLength",
"endIndex",
"isAtEndOfHaystack",
"didWalkEntireNeedle",
"doesThisMatch",
"doesRestMatch",
"string",
"state",
"step",
"string",
"state",
"step",
"index",
"length",
"byte",
"newState",
"str",
"initial",
"step",
"str",
"state",
"step",
"index",
"length",
"byte",
"newState",
"string",
"result",
"187",
"188",
"189",
"str",
"prefix",
"haystack",
"needle",
"194",
"195",
"196",
"197",
"198",
"199",
"200",
"201",
"202",
"203",
"204",
"205",
"206",
"207",
"208",
"209",
"210",
"211",
"212",
"213",
"214",
"215",
"216",
"217",
"218",
"219",
"220",
"221",
"222",
"223",
"224",
"225",
"226",
"227",
"228",
"229",
"230",
"231",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffed646ea0,
head: 000000,
bits: 232,
capacity: 256,
} [
0,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
regions: [
…,
@27127-27134,
…,
@27319-27325,
@33357-33365,
@33642-33647,
@52419-52429,
@35788-35798,
@35973-35981,
@35035-35043,
@26896-26956,
@26725-26894,
@34430-34436,
@51261-51269,
…,
…,
@33975-33981,
@36162-36166,
@36329-36338,
@36486-36493,
@28384-28396,
@37205-37210,
@37565-37570,
@36844-36849,
@38075-38081,
@38606-38612,
@39081-39086,
@39545-39550,
@40001-40006,
@40441-40446,
@40870-40875,
@41296-41301,
@41713-41717,
@42087-42091,
@52698-52706,
@42197-42206,
@42335-42349,
@42435-42450,
@45480-45490,
@47470-47479,
@50474-50491,
@33084-33091,
@51970-51978,
@35582-35598,
…,
@42787-42798,
@44053-44065,
@44695-44706,
@51934-51955,
@35465-35580,
@43294-43309,
@46473-46483,
@46773-46787,
@48360-48369,
@48660-48673,
@48943-48946,
@49016-49025,
@49387-49400,
@50674-50695,
@51424-51436,
@52079-52091,
…,
…,
…,
…,
…,
…,
@35047-35052,
@35060-35066,
…,
…,
…,
@36853-36859,
@37214-37220,
@37574-37580,
@38085-38091,
@38616-38622,
@39090-39096,
@39554-39560,
@40010-40016,
@40450-40456,
@40879-40885,
@41305-41311,
@41721-41727,
@42095-42101,
@42802-42810,
@42812-42818,
@42820-42826,
@42880-42897,
@42880-42897,
@43313-43316,
@43318-43326,
@43328-43334,
@43336-43342,
@43396-43413,
@43396-43413,
@44069-44077,
@44079-44085,
@44087-44093,
@44147-44164,
@44147-44164,
@44710-44718,
@44720-44726,
@44728-44734,
@44787-44804,
@44787-44804,
@45494-45502,
@45504-45510,
@45566-45571,
@45587-45596,
@45676-45682,
@45734-45739,
…,
…,
…,
@46487-46495,
@46497-46503,
@46511-46525,
@46560-46572,
@46605-46617,
@46791-46799,
@46801-46807,
@46809-46814,
@46816-46828,
…,
…,
@47483-47491,
@47493-47499,
@47554-47559,
@47575-47584,
@47664-47670,
@47722-47727,
…,
…,
…,
@48373-48381,
@48383-48389,
@48397-48411,
@48446-48458,
@48491-48508,
@48677-48685,
@48687-48693,
@48695-48700,
…,
@48830-48839,
…,
@48950-48951,
@48953-48954,
@49029-49037,
@49039-49052,
@49054-49060,
@49068-49082,
@49117-49129,
@49162-49170,
@49404-49409,
@49417-49489,
@49417-49489,
@49417-49489,
@49417-49489,
@49417-49489,
@49417-49489,
@49502-49519,
@49587-49606,
@49683-49696,
@49816-49829,
@50495-50501,
@50503-50508,
@50510-50514,
@50699-50705,
@50707-50712,
@50714-50718,
@50720-50725,
@50727-50733,
@50772-50776,
@50814-50822,
@51273-51276,
@51278-51285,
@51287-51291,
@51440-51443,
@51445-51450,
@51452-51456,
@51458-51463,
@51465-51471,
@51510-51514,
@51549-51557,
@52095-52101,
@52159-52165,
…,
…,
…,
@52433-52436,
@52438-52444,
@52710-52718,
@52720-52726,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
],
home: Str,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`Str.Utf8Problem`,
`Str.Utf8ByteProblem`,
`Str.concat`,
`Str.isEmpty`,
`Str.joinWith`,
`Str.split`,
`Str.repeat`,
`Str.countUtf8Bytes`,
`Str.toUtf8`,
`Str.fromUtf8`,
`Str.startsWith`,
`Str.endsWith`,
`Str.trim`,
`Str.trimStart`,
`Str.trimEnd`,
`Str.toDec`,
`Str.toF64`,
`Str.toF32`,
`Str.toU128`,
`Str.toI128`,
`Str.toU64`,
`Str.toI64`,
`Str.toU32`,
`Str.toI32`,
`Str.toU16`,
`Str.toI16`,
`Str.toU8`,
`Str.toI8`,
`Str.replaceEach`,
`Str.replaceFirst`,
`Str.replaceLast`,
`Str.splitFirst`,
`Str.splitLast`,
`Str.walkUtf8`,
`Str.walkUtf8WithIndex`,
`Str.reserve`,
`Str.releaseExcessCapacity`,
`Str.withCapacity`,
`Str.withPrefix`,
`Str.contains`,
],
},
},
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
adding docs for "Inspect.roc",
docs ModuleDocumentation {
name: "Inspect",
entries: [
DocDef(
DocDef {
name: "KeyValWalker",
symbol: `Inspect.KeyValWalker`,
type_vars: [
"state",
"collection",
"key",
"val",
],
type_annotation: Function {
args: [
BoundVariable(
"collection",
),
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"key",
),
BoundVariable(
"val",
),
],
output: BoundVariable(
"state",
),
},
],
output: BoundVariable(
"state",
),
},
docs: None,
},
),
DocDef(
DocDef {
name: "ElemWalker",
symbol: `Inspect.ElemWalker`,
type_vars: [
"state",
"collection",
"elem",
],
type_annotation: Function {
args: [
BoundVariable(
"collection",
),
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"elem",
),
],
output: BoundVariable(
"state",
),
},
],
output: BoundVariable(
"state",
),
},
docs: None,
},
),
DocDef(
DocDef {
name: "InspectFormatter",
symbol: `Inspect.InspectFormatter`,
type_vars: [],
type_annotation: Ability {
members: [
AbilityMember {
name: "init",
type_annotation: Function {
args: [
Record {
fields: [],
extension: NoTypeAnn,
},
],
output: BoundVariable(
"f",
),
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "tag",
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "List",
parts: [
Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "tuple",
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "record",
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Record {
fields: [
RecordField {
name: "key",
type_annotation: Apply {
name: "Str",
parts: [],
},
},
RecordField {
name: "value",
type_annotation: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
],
extension: NoTypeAnn,
},
],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "bool",
type_annotation: Function {
args: [
Apply {
name: "Bool",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "str",
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "list",
type_annotation: Function {
args: [
BoundVariable(
"list",
),
Apply {
name: "ElemWalker",
parts: [
BoundVariable(
"state",
),
BoundVariable(
"list",
),
BoundVariable(
"elem",
),
],
},
Function {
args: [
BoundVariable(
"elem",
),
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "set",
type_annotation: Function {
args: [
BoundVariable(
"set",
),
Apply {
name: "ElemWalker",
parts: [
BoundVariable(
"state",
),
BoundVariable(
"set",
),
BoundVariable(
"elem",
),
],
},
Function {
args: [
BoundVariable(
"elem",
),
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "dict",
type_annotation: Function {
args: [
BoundVariable(
"dict",
),
Apply {
name: "KeyValWalker",
parts: [
BoundVariable(
"state",
),
BoundVariable(
"dict",
),
BoundVariable(
"key",
),
BoundVariable(
"value",
),
],
},
Function {
args: [
BoundVariable(
"key",
),
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
Function {
args: [
BoundVariable(
"value",
),
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "opaque",
type_annotation: Function {
args: [
Wildcard,
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "function",
type_annotation: Function {
args: [
Wildcard,
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u8",
type_annotation: Function {
args: [
Apply {
name: "U8",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i8",
type_annotation: Function {
args: [
Apply {
name: "I8",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u16",
type_annotation: Function {
args: [
Apply {
name: "U16",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i16",
type_annotation: Function {
args: [
Apply {
name: "I16",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u32",
type_annotation: Function {
args: [
Apply {
name: "U32",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i32",
type_annotation: Function {
args: [
Apply {
name: "I32",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u64",
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i64",
type_annotation: Function {
args: [
Apply {
name: "I64",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "u128",
type_annotation: Function {
args: [
Apply {
name: "U128",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "i128",
type_annotation: Function {
args: [
Apply {
name: "I128",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "f32",
type_annotation: Function {
args: [
Apply {
name: "F32",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "f64",
type_annotation: Function {
args: [
Apply {
name: "F64",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
AbilityMember {
name: "dec",
type_annotation: Function {
args: [
Apply {
name: "Dec",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "Inspector",
symbol: `Inspect.Inspector`,
type_vars: [
"f",
],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "custom",
symbol: `Inspect.custom`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Function {
args: [
BoundVariable(
"f",
),
],
output: BoundVariable(
"f",
),
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
implements: [
ImplementsClause {
name: "f",
abilities: [
Apply {
name: "InspectFormatter",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "apply",
symbol: `Inspect.apply`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
BoundVariable(
"f",
),
],
output: BoundVariable(
"f",
),
},
implements: [
ImplementsClause {
name: "f",
abilities: [
Apply {
name: "InspectFormatter",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "Inspect",
symbol: `Inspect.Inspect`,
type_vars: [],
type_annotation: Ability {
members: [
AbilityMember {
name: "toInspector",
type_annotation: Function {
args: [
BoundVariable(
"val",
),
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
able_variables: [
(
"val",
[
Apply {
name: "Inspect",
parts: [],
},
],
),
(
"f",
[
Apply {
name: "InspectFormatter",
parts: [],
},
],
),
],
docs: None,
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "inspect",
symbol: `Inspect.inspect`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"val",
),
],
output: BoundVariable(
"f",
),
},
implements: [
ImplementsClause {
name: "val",
abilities: [
Apply {
name: "Inspect",
parts: [],
},
],
},
ImplementsClause {
name: "f",
abilities: [
Apply {
name: "InspectFormatter",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "toStr",
symbol: `Inspect.toStr`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"val",
),
],
output: Apply {
name: "Str",
parts: [],
},
},
implements: [
ImplementsClause {
name: "val",
abilities: [
Apply {
name: "Inspect",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "DbgFormatter",
symbol: `Inspect.DbgFormatter`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "dbgInit",
symbol: `Inspect.dbgInit`,
type_vars: [],
type_annotation: Function {
args: [
Record {
fields: [],
extension: NoTypeAnn,
},
],
output: Apply {
name: "DbgFormatter",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgList",
symbol: `Inspect.dbgList`,
type_vars: [],
type_annotation: Function {
args: [
BoundVariable(
"list",
),
Apply {
name: "ElemWalker",
parts: [
Tuple {
elems: [
Apply {
name: "DbgFormatter",
parts: [],
},
Apply {
name: "Bool",
parts: [],
},
],
extension: NoTypeAnn,
},
BoundVariable(
"list",
),
BoundVariable(
"elem",
),
],
},
Function {
args: [
BoundVariable(
"elem",
),
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgSet",
symbol: `Inspect.dbgSet`,
type_vars: [],
type_annotation: Function {
args: [
BoundVariable(
"set",
),
Apply {
name: "ElemWalker",
parts: [
Tuple {
elems: [
Apply {
name: "DbgFormatter",
parts: [],
},
Apply {
name: "Bool",
parts: [],
},
],
extension: NoTypeAnn,
},
BoundVariable(
"set",
),
BoundVariable(
"elem",
),
],
},
Function {
args: [
BoundVariable(
"elem",
),
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgDict",
symbol: `Inspect.dbgDict`,
type_vars: [],
type_annotation: Function {
args: [
BoundVariable(
"dict",
),
Apply {
name: "KeyValWalker",
parts: [
Tuple {
elems: [
Apply {
name: "DbgFormatter",
parts: [],
},
Apply {
name: "Bool",
parts: [],
},
],
extension: NoTypeAnn,
},
BoundVariable(
"dict",
),
BoundVariable(
"key",
),
BoundVariable(
"value",
),
],
},
Function {
args: [
BoundVariable(
"key",
),
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
Function {
args: [
BoundVariable(
"value",
),
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgTag",
symbol: `Inspect.dbgTag`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
Apply {
name: "List",
parts: [
Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgTuple",
symbol: `Inspect.dbgTuple`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgRecord",
symbol: `Inspect.dbgRecord`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Record {
fields: [
RecordField {
name: "key",
type_annotation: Apply {
name: "Str",
parts: [],
},
},
RecordField {
name: "value",
type_annotation: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
],
extension: NoTypeAnn,
},
],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgBool",
symbol: `Inspect.dbgBool`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Bool",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgStr",
symbol: `Inspect.dbgStr`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgOpaque",
symbol: `Inspect.dbgOpaque`,
type_vars: [],
type_annotation: Function {
args: [
Wildcard,
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgFunction",
symbol: `Inspect.dbgFunction`,
type_vars: [],
type_annotation: Function {
args: [
Wildcard,
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgU8",
symbol: `Inspect.dbgU8`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U8",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgI8",
symbol: `Inspect.dbgI8`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "I8",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgU16",
symbol: `Inspect.dbgU16`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U16",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgI16",
symbol: `Inspect.dbgI16`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "I16",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgU32",
symbol: `Inspect.dbgU32`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U32",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgI32",
symbol: `Inspect.dbgI32`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "I32",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgU64",
symbol: `Inspect.dbgU64`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgI64",
symbol: `Inspect.dbgI64`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "I64",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgU128",
symbol: `Inspect.dbgU128`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U128",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgI128",
symbol: `Inspect.dbgI128`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "I128",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgF32",
symbol: `Inspect.dbgF32`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "F32",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgF64",
symbol: `Inspect.dbgF64`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "F64",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgDec",
symbol: `Inspect.dbgDec`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dec",
parts: [],
},
],
output: Apply {
name: "Inspector",
parts: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dbgWrite",
symbol: `Inspect.dbgWrite`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "DbgFormatter",
parts: [],
},
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "DbgFormatter",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "toDbgStr",
symbol: `Inspect.toDbgStr`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "DbgFormatter",
parts: [],
},
],
output: Apply {
name: "Str",
parts: [],
},
},
docs: None,
},
),
],
scope: Scope {
aliases: VecMap {
keys: [
`Num.Binary32`,
`Num.F32`,
`Num.FloatingPoint`,
`Str.Utf8ByteProblem`,
`Num.Unsigned16`,
`Num.U16`,
`Bool.Bool`,
`Num.U64`,
`Num.Binary64`,
`Num.Int`,
`Num.Signed128`,
`Num.Unsigned8`,
`Num.Frac`,
`Num.U32`,
`Num.Signed64`,
`Num.Signed8`,
`Num.I64`,
`Num.U8`,
`Num.I16`,
`Num.Unsigned128`,
`Num.I8`,
`Num.Num`,
`Num.Decimal`,
`Str.Utf8Problem`,
`Num.Unsigned32`,
`Num.Signed32`,
`Num.Integer`,
`Num.I128`,
`Num.U128`,
`Num.I32`,
`Num.Signed16`,
`Num.Unsigned64`,
`Num.F64`,
`Num.Dec`,
`Str.IdentId(49)`,
`Inspect.KeyValWalker`,
`Inspect.ElemWalker`,
`Inspect.Inspector`,
`Inspect.DbgFormatter`,
],
values: [
Alias {
region: @17634-17642,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19444-19447,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17650-17669,
type_variables: [
@17664-17669 AliasVar {
name: 'range',
var: 67,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <67>,
kind: Opaque,
},
Alias {
region: @26725-26740,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<63>,
kind: Structural,
},
Alias {
region: @17202-17212,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17544-17547,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @1780-1784,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: ['False', 'True'],
kind: Opaque,
},
Alias {
region: @17482-17485,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17619-17627,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @12895-12904,
type_variables: [
@12899-12904 AliasVar {
name: 'range',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` <64>[ but actually <64> ])[ but actually (Alias `Num.Integer` <64>[ but actually <64> ]) ]),
kind: Structural,
},
Alias {
region: @17074-17083,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17219-17228,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17034-17044,
type_variables: [
@17039-17044 AliasVar {
name: 'range',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` <65>[ but actually <65> ])[ but actually (Alias `Num.FloatingPoint` <65>[ but actually <65> ]) ]),
kind: Structural,
},
Alias {
region: @17513-17516,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17090-17098,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17135-17142,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17291-17294,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17575-17577,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17349-17352,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17150-17161,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17431-17433,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Int` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ]) ]) ]),
kind: Structural,
},
Alias {
region: @5228-5237,
type_variables: [
@5232-5237 AliasVar {
name: 'range',
var: 63,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <63>,
kind: Opaque,
},
Alias {
region: @17605-17612,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @26896-26907,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
64,
],
recursion_variables: {},
typ: { 'problem' : RigidRequired((Alias `Str.Utf8ByteProblem`[ but actually ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<64> ]))'byteIndex' : RigidRequired((DelayedAlias `Num.U64`)), },
kind: Structural,
},
Alias {
region: @17185-17195,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17105-17113,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17236-17249,
type_variables: [
@17244-17249 AliasVar {
name: 'range',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <66>,
kind: Opaque,
},
Alias {
region: @17260-17264,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17449-17453,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17320-17323,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17120-17128,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17168-17178,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19085-19088,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @23363-23366,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @35465-35479,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
65,
],
recursion_variables: {},
typ: { 'dProblemCode' : RigidRequired((Alias `Str.Utf8ByteProblem`[ but actually ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<65> ]))'cIsOk' : RigidRequired((DelayedAlias `Bool.Bool`)), 'aByteIndex' : RigidRequired((DelayedAlias `Num.U64`)), 'bString' : RigidRequired((`Str.Str`)), },
kind: Structural,
},
Alias {
region: @707-744,
type_variables: [
@720-725 AliasVar {
name: 'state',
var: 64,
opt_bound_abilities: None,
},
@726-736 AliasVar {
name: 'collection',
var: 63,
opt_bound_abilities: None,
},
@737-740 AliasVar {
name: 'key',
var: 65,
opt_bound_abilities: None,
},
@741-744 AliasVar {
name: 'val',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [
LambdaSet(
<67>,
),
LambdaSet(
<68>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn(<63>, <64>, Fn(<64>, <65>, <66> |<67>| -> <64>) |<68>| -> <64>),
kind: Structural,
},
Alias {
region: @802-834,
type_variables: [
@813-818 AliasVar {
name: 'state',
var: 70,
opt_bound_abilities: None,
},
@819-829 AliasVar {
name: 'collection',
var: 69,
opt_bound_abilities: None,
},
@830-834 AliasVar {
name: 'elem',
var: 71,
opt_bound_abilities: None,
},
],
lambda_set_variables: [
LambdaSet(
<72>,
),
LambdaSet(
<73>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn(<69>, <70>, Fn(<70>, <71> |<72>| -> <70>) |<73>| -> <70>),
kind: Structural,
},
Alias {
region: @3006-3017,
type_variables: [
@3016-3017 AliasVar {
name: 'f',
var: 74,
opt_bound_abilities: Some(
AbilitySet(
[
`Inspect.InspectFormatter`,
],
),
),
},
],
lambda_set_variables: [
LambdaSet(
<75>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn(<74> |<75>| -> <74>),
kind: Opaque,
},
Alias {
region: @3808-3820,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'data' : RigidRequired((`Str.Str`)) },
kind: Opaque,
},
],
},
abilities_store: IAbilitiesStore {
members_of_ability: {
`Bool.Eq`: [
`Bool.isEq`,
],
`Inspect.Inspect`: [
`Inspect.toInspector`,
],
`Inspect.InspectFormatter`: [
`Inspect.init`,
`Inspect.tag`,
`Inspect.tuple`,
`Inspect.record`,
`Inspect.bool`,
`Inspect.str`,
`Inspect.list`,
`Inspect.set`,
`Inspect.dict`,
`Inspect.opaque`,
`Inspect.function`,
`Inspect.u8`,
`Inspect.i8`,
`Inspect.u16`,
`Inspect.i16`,
`Inspect.u32`,
`Inspect.i32`,
`Inspect.u64`,
`Inspect.i64`,
`Inspect.u128`,
`Inspect.i128`,
`Inspect.f32`,
`Inspect.f64`,
`Inspect.dec`,
],
},
specialization_to_root: {
`Inspect.dbgInit`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.init`,
},
`Inspect.dbgFunction`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.function`,
},
`Inspect.dbgI128`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.i128`,
},
`Inspect.dbgBool`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.bool`,
},
`Inspect.dbgF64`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.f64`,
},
`Inspect.dbgRecord`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.record`,
},
`Inspect.dbgU128`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.u128`,
},
`Inspect.dbgOpaque`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.opaque`,
},
`Inspect.dbgU32`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.u32`,
},
`Inspect.dbgDec`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.dec`,
},
`Inspect.dbgU8`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.u8`,
},
`Inspect.dbgDict`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.dict`,
},
`Inspect.dbgF32`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.f32`,
},
`Inspect.dbgI64`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.i64`,
},
`Bool.boolIsEq`: ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
},
`Inspect.dbgSet`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.set`,
},
`Inspect.dbgStr`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.str`,
},
`Inspect.dbgI8`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.i8`,
},
`Inspect.dbgU16`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.u16`,
},
`Inspect.dbgU64`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.u64`,
},
`Inspect.dbgI32`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.i32`,
},
`Inspect.dbgTag`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.tag`,
},
`Inspect.dbgTuple`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.tuple`,
},
`Inspect.dbgList`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.list`,
},
`Inspect.dbgI16`: ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.i16`,
},
},
ability_members: {
`Inspect.i16`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2355-2358,
typ: Local {
signature_var: 168,
signature: Fn((DelayedAlias `Num.I16`) |Uls(165:`Inspect.i16`:1)| -> (DelayedAlias `Inspect.Inspector` @2378-2379 OptAbleType { typ: <165>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(165:`Inspect.i16`:2))),
variables: MemberVariables {
able_vars: [
165,
],
rigid_vars: [
166,
167,
],
flex_vars: [],
},
},
},
`Bool.isEq`: AbilityMemberData {
parent_ability: `Bool.Eq`,
region: @1635-1639,
typ: Imported,
},
`Inspect.function`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2095-2103,
typ: Local {
signature_var: 152,
signature: Fn(<149> |Uls(148:`Inspect.function`:1)| -> (DelayedAlias `Inspect.Inspector` @2121-2122 OptAbleType { typ: <148>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(148:`Inspect.function`:2))),
variables: MemberVariables {
able_vars: [
148,
],
rigid_vars: [
149,
150,
151,
],
flex_vars: [],
},
},
},
`Inspect.f32`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2814-2817,
typ: Local {
signature_var: 196,
signature: Fn((DelayedAlias `Num.F32`) |Uls(193:`Inspect.f32`:1)| -> (DelayedAlias `Inspect.Inspector` @2837-2838 OptAbleType { typ: <193>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(193:`Inspect.f32`:2))),
variables: MemberVariables {
able_vars: [
193,
],
rigid_vars: [
194,
195,
],
flex_vars: [],
},
},
},
`Inspect.toInspector`: AbilityMemberData {
parent_ability: `Inspect.Inspect`,
region: @3291-3302,
typ: Local {
signature_var: 80,
signature: Fn(<76> |Uls(76:`Inspect.toInspector`:1)| -> (DelayedAlias `Inspect.Inspector` @3322-3323 OptAbleType { typ: <77>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(76:`Inspect.toInspector`:2))),
variables: MemberVariables {
able_vars: [
76,
77,
],
rigid_vars: [
78,
79,
],
flex_vars: [],
},
},
},
`Inspect.set`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1499-1502,
typ: Local {
signature_var: 128,
signature: Fn(<119>, (DelayedAlias `Inspect.ElemWalker` @1521-1526 OptAbleType { typ: <120>, opt_abilities: None } @1527-1530 OptAbleType { typ: <119>, opt_abilities: None } @1531-1535 OptAbleType { typ: <121>, opt_abilities: None } α@Uls(118:`Inspect.set`:2) ν@Uls(118:`Inspect.set`:3)), Fn(<121> |Uls(118:`Inspect.set`:4)| -> (DelayedAlias `Inspect.Inspector` @1556-1557 OptAbleType { typ: <118>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(118:`Inspect.set`:5))) |Uls(118:`Inspect.set`:1)| -> (DelayedAlias `Inspect.Inspector` @1572-1573 OptAbleType { typ: <118>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(118:`Inspect.set`:6))),
variables: MemberVariables {
able_vars: [
118,
],
rigid_vars: [
119,
120,
121,
122,
123,
124,
125,
126,
127,
],
flex_vars: [],
},
},
},
`Inspect.f64`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2879-2882,
typ: Local {
signature_var: 200,
signature: Fn((DelayedAlias `Num.F64`) |Uls(197:`Inspect.f64`:1)| -> (DelayedAlias `Inspect.Inspector` @2902-2903 OptAbleType { typ: <197>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(197:`Inspect.f64`:2))),
variables: MemberVariables {
able_vars: [
197,
],
rigid_vars: [
198,
199,
],
flex_vars: [],
},
},
},
`Inspect.str`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1315-1318,
typ: Local {
signature_var: 106,
signature: Fn((`Str.Str`) |Uls(103:`Inspect.str`:1)| -> (DelayedAlias `Inspect.Inspector` @1338-1339 OptAbleType { typ: <103>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(103:`Inspect.str`:2))),
variables: MemberVariables {
able_vars: [
103,
],
rigid_vars: [
104,
105,
],
flex_vars: [],
},
},
},
`Inspect.i8`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2227-2229,
typ: Local {
signature_var: 160,
signature: Fn((DelayedAlias `Num.I8`) |Uls(157:`Inspect.i8`:1)| -> (DelayedAlias `Inspect.Inspector` @2248-2249 OptAbleType { typ: <157>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(157:`Inspect.i8`:2))),
variables: MemberVariables {
able_vars: [
157,
],
rigid_vars: [
158,
159,
],
flex_vars: [],
},
},
},
`Inspect.u64`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2550-2553,
typ: Local {
signature_var: 180,
signature: Fn((DelayedAlias `Num.U64`) |Uls(177:`Inspect.u64`:1)| -> (DelayedAlias `Inspect.Inspector` @2573-2574 OptAbleType { typ: <177>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(177:`Inspect.u64`:2))),
variables: MemberVariables {
able_vars: [
177,
],
rigid_vars: [
178,
179,
],
flex_vars: [],
},
},
},
`Inspect.dec`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2944-2947,
typ: Local {
signature_var: 204,
signature: Fn((DelayedAlias `Num.Dec`) |Uls(201:`Inspect.dec`:1)| -> (DelayedAlias `Inspect.Inspector` @2967-2968 OptAbleType { typ: <201>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(201:`Inspect.dec`:2))),
variables: MemberVariables {
able_vars: [
201,
],
rigid_vars: [
202,
203,
],
flex_vars: [],
},
},
},
`Inspect.i32`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2485-2488,
typ: Local {
signature_var: 176,
signature: Fn((DelayedAlias `Num.I32`) |Uls(173:`Inspect.i32`:1)| -> (DelayedAlias `Inspect.Inspector` @2508-2509 OptAbleType { typ: <173>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(173:`Inspect.i32`:2))),
variables: MemberVariables {
able_vars: [
173,
],
rigid_vars: [
174,
175,
],
flex_vars: [],
},
},
},
`Inspect.u128`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2680-2684,
typ: Local {
signature_var: 188,
signature: Fn((DelayedAlias `Num.U128`) |Uls(185:`Inspect.u128`:1)| -> (DelayedAlias `Inspect.Inspector` @2705-2706 OptAbleType { typ: <185>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(185:`Inspect.u128`:2))),
variables: MemberVariables {
able_vars: [
185,
],
rigid_vars: [
186,
187,
],
flex_vars: [],
},
},
},
`Inspect.tag`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @977-980,
typ: Local {
signature_var: 88,
signature: Fn((`Str.Str`), (`List.List` @994-1005 (DelayedAlias `Inspect.Inspector` @1004-1005 OptAbleType { typ: <84>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(84:`Inspect.tag`:2))) |Uls(84:`Inspect.tag`:1)| -> (DelayedAlias `Inspect.Inspector` @1020-1021 OptAbleType { typ: <84>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(84:`Inspect.tag`:3))),
variables: MemberVariables {
able_vars: [
84,
],
rigid_vars: [
85,
86,
87,
],
flex_vars: [],
},
},
},
`Inspect.bool`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1248-1252,
typ: Local {
signature_var: 102,
signature: Fn((DelayedAlias `Bool.Bool`) |Uls(99:`Inspect.bool`:1)| -> (DelayedAlias `Inspect.Inspector` @1273-1274 OptAbleType { typ: <99>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(99:`Inspect.bool`:2))),
variables: MemberVariables {
able_vars: [
99,
],
rigid_vars: [
100,
101,
],
flex_vars: [],
},
},
},
`Inspect.opaque`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1880-1886,
typ: Local {
signature_var: 147,
signature: Fn(<144> |Uls(143:`Inspect.opaque`:1)| -> (DelayedAlias `Inspect.Inspector` @1904-1905 OptAbleType { typ: <143>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(143:`Inspect.opaque`:2))),
variables: MemberVariables {
able_vars: [
143,
],
rigid_vars: [
144,
145,
146,
],
flex_vars: [],
},
},
},
`Inspect.record`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1144-1150,
typ: Local {
signature_var: 98,
signature: Fn((`List.List` @1158-1192 { 'value' : RigidRequired((DelayedAlias `Inspect.Inspector` @1189-1190 OptAbleType { typ: <94>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(94:`Inspect.record`:2)))'key' : RigidRequired((`Str.Str`)), }) |Uls(94:`Inspect.record`:1)| -> (DelayedAlias `Inspect.Inspector` @1206-1207 OptAbleType { typ: <94>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(94:`Inspect.record`:3))),
variables: MemberVariables {
able_vars: [
94,
],
rigid_vars: [
95,
96,
97,
],
flex_vars: [],
},
},
},
`Inspect.u16`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2290-2293,
typ: Local {
signature_var: 164,
signature: Fn((DelayedAlias `Num.U16`) |Uls(161:`Inspect.u16`:1)| -> (DelayedAlias `Inspect.Inspector` @2313-2314 OptAbleType { typ: <161>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(161:`Inspect.u16`:2))),
variables: MemberVariables {
able_vars: [
161,
],
rigid_vars: [
162,
163,
],
flex_vars: [],
},
},
},
`Inspect.u32`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2420-2423,
typ: Local {
signature_var: 172,
signature: Fn((DelayedAlias `Num.U32`) |Uls(169:`Inspect.u32`:1)| -> (DelayedAlias `Inspect.Inspector` @2443-2444 OptAbleType { typ: <169>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(169:`Inspect.u32`:2))),
variables: MemberVariables {
able_vars: [
169,
],
rigid_vars: [
170,
171,
],
flex_vars: [],
},
},
},
`Inspect.i64`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2615-2618,
typ: Local {
signature_var: 184,
signature: Fn((DelayedAlias `Num.I64`) |Uls(181:`Inspect.i64`:1)| -> (DelayedAlias `Inspect.Inspector` @2638-2639 OptAbleType { typ: <181>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(181:`Inspect.i64`:2))),
variables: MemberVariables {
able_vars: [
181,
],
rigid_vars: [
182,
183,
],
flex_vars: [],
},
},
},
`Inspect.tuple`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1062-1067,
typ: Local {
signature_var: 93,
signature: Fn((`List.List` @1076-1087 (DelayedAlias `Inspect.Inspector` @1086-1087 OptAbleType { typ: <89>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(89:`Inspect.tuple`:2))) |Uls(89:`Inspect.tuple`:1)| -> (DelayedAlias `Inspect.Inspector` @1102-1103 OptAbleType { typ: <89>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(89:`Inspect.tuple`:3))),
variables: MemberVariables {
able_vars: [
89,
],
rigid_vars: [
90,
91,
92,
],
flex_vars: [],
},
},
},
`Inspect.u8`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2164-2166,
typ: Local {
signature_var: 156,
signature: Fn((DelayedAlias `Num.U8`) |Uls(153:`Inspect.u8`:1)| -> (DelayedAlias `Inspect.Inspector` @2185-2186 OptAbleType { typ: <153>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(153:`Inspect.u8`:2))),
variables: MemberVariables {
able_vars: [
153,
],
rigid_vars: [
154,
155,
],
flex_vars: [],
},
},
},
`Inspect.i128`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2747-2751,
typ: Local {
signature_var: 192,
signature: Fn((DelayedAlias `Num.I128`) |Uls(189:`Inspect.i128`:1)| -> (DelayedAlias `Inspect.Inspector` @2772-2773 OptAbleType { typ: <189>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(189:`Inspect.i128`:2))),
variables: MemberVariables {
able_vars: [
189,
],
rigid_vars: [
190,
191,
],
flex_vars: [],
},
},
},
`Inspect.dict`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1614-1618,
typ: Local {
signature_var: 142,
signature: Fn(<130>, (DelayedAlias `Inspect.KeyValWalker` @1640-1645 OptAbleType { typ: <131>, opt_abilities: None } @1646-1650 OptAbleType { typ: <130>, opt_abilities: None } @1651-1654 OptAbleType { typ: <132>, opt_abilities: None } @1655-1660 OptAbleType { typ: <133>, opt_abilities: None } α@Uls(129:`Inspect.dict`:2) ν@Uls(129:`Inspect.dict`:3)), Fn(<132> |Uls(129:`Inspect.dict`:4)| -> (DelayedAlias `Inspect.Inspector` @1680-1681 OptAbleType { typ: <129>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(129:`Inspect.dict`:5))), Fn(<133> |Uls(129:`Inspect.dict`:6)| -> (DelayedAlias `Inspect.Inspector` @1704-1705 OptAbleType { typ: <129>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(129:`Inspect.dict`:7))) |Uls(129:`Inspect.dict`:1)| -> (DelayedAlias `Inspect.Inspector` @1720-1721 OptAbleType { typ: <129>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(129:`Inspect.dict`:8))),
variables: MemberVariables {
able_vars: [
129,
],
rigid_vars: [
130,
131,
132,
133,
134,
135,
136,
137,
138,
139,
140,
141,
],
flex_vars: [],
},
},
},
`Inspect.list`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1381-1385,
typ: Local {
signature_var: 117,
signature: Fn(<108>, (DelayedAlias `Inspect.ElemWalker` @1405-1410 OptAbleType { typ: <109>, opt_abilities: None } @1411-1415 OptAbleType { typ: <108>, opt_abilities: None } @1416-1420 OptAbleType { typ: <110>, opt_abilities: None } α@Uls(107:`Inspect.list`:2) ν@Uls(107:`Inspect.list`:3)), Fn(<110> |Uls(107:`Inspect.list`:4)| -> (DelayedAlias `Inspect.Inspector` @1441-1442 OptAbleType { typ: <107>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(107:`Inspect.list`:5))) |Uls(107:`Inspect.list`:1)| -> (DelayedAlias `Inspect.Inspector` @1457-1458 OptAbleType { typ: <107>, opt_abilities: Some(AbilitySet([`Inspect.InspectFormatter`])) } α@Uls(107:`Inspect.list`:6))),
variables: MemberVariables {
able_vars: [
107,
],
rigid_vars: [
108,
109,
110,
111,
112,
113,
114,
115,
116,
],
flex_vars: [],
},
},
},
`Inspect.init`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @921-925,
typ: Local {
signature_var: 83,
signature: Fn({} |Uls(81:`Inspect.init`:1)| -> <81>),
variables: MemberVariables {
able_vars: [
81,
],
rigid_vars: [
82,
],
flex_vars: [],
},
},
},
},
declared_implementations: {
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.i16`,
}: Impl(
`Inspect.dbgI16`,
),
ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
}: Impl(
`Bool.boolIsEq`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.str`,
}: Impl(
`Inspect.dbgStr`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.u32`,
}: Impl(
`Inspect.dbgU32`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.i128`,
}: Impl(
`Inspect.dbgI128`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.function`,
}: Impl(
`Inspect.dbgFunction`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.dec`,
}: Impl(
`Inspect.dbgDec`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.init`,
}: Impl(
`Inspect.dbgInit`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.bool`,
}: Impl(
`Inspect.dbgBool`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.opaque`,
}: Impl(
`Inspect.dbgOpaque`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.f64`,
}: Impl(
`Inspect.dbgF64`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.u64`,
}: Impl(
`Inspect.dbgU64`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.i32`,
}: Impl(
`Inspect.dbgI32`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.i64`,
}: Impl(
`Inspect.dbgI64`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.tag`,
}: Impl(
`Inspect.dbgTag`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.dict`,
}: Impl(
`Inspect.dbgDict`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.u8`,
}: Impl(
`Inspect.dbgU8`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.tuple`,
}: Impl(
`Inspect.dbgTuple`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.f32`,
}: Impl(
`Inspect.dbgF32`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.list`,
}: Impl(
`Inspect.dbgList`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.set`,
}: Impl(
`Inspect.dbgSet`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.i8`,
}: Impl(
`Inspect.dbgI8`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.u128`,
}: Impl(
`Inspect.dbgU128`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.u16`,
}: Impl(
`Inspect.dbgU16`,
),
ImplKey {
opaque: `Inspect.DbgFormatter`,
ability_member: `Inspect.record`,
}: Impl(
`Inspect.dbgRecord`,
),
},
specializations: {},
next_specialization_id: 3,
resolved_specializations: {},
},
home: Inspect,
exposed_ident_count: 34,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "U8",
},
),
`Num.U8`,
@606-608,
),
(
Ident(
IdentStr {
string: "I8",
},
),
`Num.I8`,
@631-633,
),
(
Ident(
IdentStr {
string: "I128",
},
),
`Num.I128`,
@650-654,
),
(
Ident(
IdentStr {
string: "Dec",
},
),
`Num.Dec`,
@666-669,
),
(
Ident(
IdentStr {
string: "U64",
},
),
`Num.U64`,
@620-623,
),
(
Ident(
IdentStr {
string: "I64",
},
),
`Num.I64`,
@645-648,
),
(
Ident(
IdentStr {
string: "U16",
},
),
`Num.U16`,
@610-613,
),
(
Ident(
IdentStr {
string: "Bool",
},
),
`Bool.Bool`,
@584-588,
),
(
Ident(
IdentStr {
string: "U128",
},
),
`Num.U128`,
@625-629,
),
(
Ident(
IdentStr {
string: "F64",
},
),
`Num.F64`,
@661-664,
),
(
Ident(
IdentStr {
string: "I32",
},
),
`Num.I32`,
@640-643,
),
(
Ident(
IdentStr {
string: "I16",
},
),
`Num.I16`,
@635-638,
),
(
Ident(
IdentStr {
string: "F32",
},
),
`Num.F32`,
@656-659,
),
(
Ident(
IdentStr {
string: "U32",
},
),
`Num.U32`,
@615-618,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
73,
110,
115,
112,
101,
99,
116,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
69,
108,
101,
109,
87,
97,
108,
107,
101,
114,
75,
101,
121,
86,
97,
108,
87,
97,
108,
107,
101,
114,
105,
110,
115,
112,
101,
99,
116,
105,
110,
105,
116,
108,
105,
115,
116,
115,
101,
116,
100,
105,
99,
116,
116,
97,
103,
116,
117,
112,
108,
101,
114,
101,
99,
111,
114,
100,
98,
111,
111,
108,
115,
116,
114,
111,
112,
97,
113,
117,
101,
102,
117,
110,
99,
116,
105,
111,
110,
117,
56,
105,
56,
117,
49,
54,
105,
49,
54,
117,
51,
50,
105,
51,
50,
117,
54,
52,
105,
54,
52,
117,
49,
50,
56,
105,
49,
50,
56,
102,
51,
50,
102,
54,
52,
100,
101,
99,
99,
117,
115,
116,
111,
109,
97,
112,
112,
108,
121,
116,
111,
73,
110,
115,
112,
101,
99,
116,
111,
114,
116,
111,
83,
116,
114,
68,
98,
103,
70,
111,
114,
109,
97,
116,
116,
101,
114,
100,
98,
103,
73,
110,
105,
116,
100,
98,
103,
76,
105,
115,
116,
100,
98,
103,
83,
101,
116,
100,
98,
103,
68,
105,
99,
116,
100,
98,
103,
84,
97,
103,
100,
98,
103,
84,
117,
112,
108,
101,
100,
98,
103,
82,
101,
99,
111,
114,
100,
100,
98,
103,
66,
111,
111,
108,
100,
98,
103,
83,
116,
114,
100,
98,
103,
79,
112,
97,
113,
117,
101,
100,
98,
103,
70,
117,
110,
99,
116,
105,
111,
110,
100,
98,
103,
85,
56,
100,
98,
103,
73,
56,
100,
98,
103,
85,
49,
54,
100,
98,
103,
73,
49,
54,
100,
98,
103,
85,
51,
50,
100,
98,
103,
73,
51,
50,
100,
98,
103,
85,
54,
52,
100,
98,
103,
73,
54,
52,
100,
98,
103,
85,
49,
50,
56,
100,
98,
103,
73,
49,
50,
56,
100,
98,
103,
70,
51,
50,
100,
98,
103,
70,
54,
52,
100,
98,
103,
68,
101,
99,
100,
98,
103,
87,
114,
105,
116,
101,
116,
111,
68,
98,
103,
83,
116,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
76,
105,
115,
116,
73,
110,
115,
112,
101,
99,
116,
111,
114,
83,
116,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
76,
105,
115,
116,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
76,
105,
115,
116,
83,
116,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
66,
111,
111,
108,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
83,
116,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
69,
108,
101,
109,
87,
97,
108,
107,
101,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
69,
108,
101,
109,
87,
97,
108,
107,
101,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
75,
101,
121,
86,
97,
108,
87,
97,
108,
107,
101,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
85,
56,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
56,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
85,
49,
54,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
49,
54,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
85,
51,
50,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
51,
50,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
85,
54,
52,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
54,
52,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
85,
49,
50,
56,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
73,
49,
50,
56,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
70,
51,
50,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
70,
54,
52,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
111,
114,
68,
101,
99,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
70,
111,
114,
109,
97,
116,
116,
101,
114,
73,
110,
115,
112,
101,
99,
116,
73,
110,
115,
112,
101,
99,
116,
111,
114,
83,
116,
114,
102,
110,
102,
109,
116,
118,
97,
108,
118,
97,
108,
70,
110,
99,
111,
110,
116,
101,
110,
116,
119,
97,
108,
107,
70,
110,
116,
111,
68,
98,
103,
73,
110,
115,
112,
101,
99,
116,
111,
114,
49,
53,
50,
102,
48,
49,
53,
52,
102,
49,
49,
53,
54,
102,
50,
112,
114,
101,
112,
101,
110,
100,
83,
101,
112,
101,
108,
101,
109,
102,
51,
49,
54,
49,
102,
52,
49,
54,
51,
49,
54,
55,
49,
54,
57,
49,
55,
49,
49,
55,
54,
49,
55,
56,
100,
107,
101,
121,
84,
111,
73,
110,
115,
112,
101,
99,
116,
111,
114,
118,
97,
108,
117,
101,
84,
111,
73,
110,
115,
112,
101,
99,
116,
111,
114,
49,
56,
51,
49,
56,
53,
49,
56,
55,
107,
101,
121,
118,
97,
108,
117,
101,
49,
57,
51,
120,
49,
57,
53,
49,
57,
55,
110,
97,
109,
101,
102,
105,
101,
108,
100,
115,
50,
48,
48,
50,
48,
50,
50,
48,
52,
50,
48,
54,
105,
110,
115,
112,
101,
99,
116,
111,
114,
50,
48,
57,
50,
49,
50,
50,
49,
52,
50,
49,
54,
50,
50,
49,
50,
50,
51,
50,
50,
53,
50,
50,
55,
50,
50,
57,
50,
51,
53,
50,
51,
55,
50,
51,
57,
98,
50,
52,
49,
50,
52,
51,
115,
50,
52,
54,
50,
52,
56,
50,
53,
48,
110,
117,
109,
50,
53,
51,
50,
53,
54,
50,
53,
57,
50,
54,
50,
50,
54,
53,
50,
54,
56,
50,
55,
49,
50,
55,
52,
50,
55,
55,
50,
56,
48,
50,
56,
51,
50,
56,
54,
50,
56,
57,
100,
97,
116,
97,
97,
100,
100,
101,
100,
],
lengths: [
Interned(7),
Interned(9),
Interned(16),
Interned(10),
Interned(12),
Interned(7),
Interned(4),
Interned(4),
Interned(3),
Interned(4),
Interned(3),
Interned(5),
Interned(6),
Interned(4),
Interned(3),
Interned(6),
Interned(8),
Interned(2),
Interned(2),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Interned(4),
Interned(4),
Interned(3),
Interned(3),
Interned(3),
Interned(6),
Interned(5),
Interned(11),
Interned(5),
Interned(12),
Interned(7),
Interned(7),
Interned(6),
Interned(7),
Interned(6),
Interned(8),
Interned(9),
Interned(7),
Interned(6),
Interned(9),
Interned(11),
Interned(5),
Interned(5),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(7),
Interned(7),
Interned(6),
Interned(6),
Interned(6),
Interned(8),
Interned(8),
Interned(16),
Interned(16),
Interned(9),
Interned(4),
Interned(9),
Interned(3),
Interned(16),
Interned(9),
Interned(4),
Interned(9),
Interned(16),
Interned(9),
Interned(4),
Interned(3),
Interned(9),
Interned(16),
Interned(9),
Interned(4),
Interned(16),
Interned(9),
Interned(3),
Interned(16),
Interned(9),
Interned(9),
Interned(10),
Interned(16),
Interned(9),
Interned(9),
Interned(10),
Interned(16),
Interned(9),
Interned(9),
Interned(9),
Interned(12),
Interned(16),
Interned(9),
Interned(16),
Interned(9),
Interned(16),
Interned(9),
Interned(2),
Interned(16),
Interned(9),
Interned(2),
Interned(16),
Interned(9),
Interned(3),
Interned(16),
Interned(9),
Interned(3),
Interned(16),
Interned(9),
Interned(3),
Interned(16),
Interned(9),
Interned(3),
Interned(16),
Interned(9),
Interned(3),
Interned(16),
Interned(9),
Interned(3),
Interned(16),
Interned(9),
Interned(4),
Interned(16),
Interned(9),
Interned(4),
Interned(16),
Interned(9),
Interned(3),
Interned(16),
Interned(9),
Interned(3),
Interned(16),
Interned(9),
Interned(3),
Interned(16),
Interned(16),
Interned(7),
Interned(9),
Interned(3),
Interned(2),
Interned(2),
Interned(3),
Interned(3),
Interned(5),
Interned(3),
Interned(7),
Interned(6),
Interned(14),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Interned(10),
Interned(4),
Interned(2),
Generated(3),
Interned(2),
Generated(3),
Interned(7),
Interned(6),
Interned(14),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Interned(10),
Interned(4),
Interned(2),
Generated(3),
Interned(2),
Generated(3),
Interned(1),
Interned(6),
Interned(14),
Interned(16),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Interned(10),
Interned(3),
Interned(5),
Interned(2),
Generated(3),
Interned(1),
Generated(3),
Interned(2),
Generated(3),
Interned(4),
Interned(6),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Interned(9),
Generated(3),
Interned(1),
Interned(6),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Interned(10),
Interned(9),
Interned(2),
Generated(3),
Interned(2),
Generated(3),
Interned(6),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Interned(10),
Interned(3),
Interned(5),
Interned(2),
Generated(3),
Interned(1),
Generated(3),
Interned(2),
Generated(3),
Interned(1),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Interned(1),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(3),
Generated(3),
Interned(2),
Interned(4),
Interned(5),
Interned(4),
],
offsets: [
0,
7,
16,
32,
42,
54,
61,
65,
69,
72,
76,
79,
84,
90,
94,
97,
103,
111,
113,
115,
118,
121,
124,
127,
130,
133,
137,
141,
144,
147,
150,
156,
161,
172,
177,
189,
196,
203,
209,
216,
222,
230,
239,
246,
252,
261,
272,
277,
282,
288,
294,
300,
306,
312,
318,
325,
332,
338,
344,
350,
358,
366,
382,
398,
407,
411,
420,
423,
439,
448,
452,
461,
477,
486,
490,
493,
502,
518,
527,
531,
547,
556,
559,
575,
584,
593,
603,
619,
628,
637,
647,
663,
672,
681,
690,
702,
718,
727,
743,
752,
768,
777,
779,
795,
804,
806,
822,
831,
834,
850,
859,
862,
878,
887,
890,
906,
915,
918,
934,
943,
946,
962,
971,
974,
990,
999,
1003,
1019,
1028,
1032,
1048,
1057,
1060,
1076,
1085,
1088,
1104,
1113,
1116,
1132,
1148,
1155,
1164,
1167,
1167,
1169,
1172,
1175,
1172,
1180,
1187,
1193,
1207,
1210,
1212,
1215,
1217,
1220,
1222,
1232,
1236,
1238,
1241,
1243,
1180,
1187,
1193,
1246,
1210,
1249,
1215,
1252,
1220,
1222,
1232,
1236,
1255,
1241,
1258,
1261,
1187,
1262,
1276,
1292,
1210,
1295,
1215,
1298,
1220,
1222,
1301,
1304,
1236,
1309,
1312,
1313,
1241,
1316,
1319,
1323,
1329,
1210,
1332,
1210,
1335,
1215,
1338,
1220,
1341,
1350,
1312,
1323,
1353,
1210,
1356,
1215,
1359,
1220,
1222,
1341,
1236,
1362,
1241,
1365,
1323,
1368,
1210,
1371,
1215,
1374,
1220,
1222,
1301,
1304,
1236,
1377,
1312,
1380,
1241,
1383,
1386,
1387,
1210,
1390,
1210,
1393,
1394,
1210,
1397,
1210,
1400,
1210,
1403,
1406,
1210,
1403,
1409,
1210,
1403,
1412,
1210,
1403,
1415,
1210,
1403,
1418,
1210,
1403,
1421,
1210,
1403,
1424,
1210,
1403,
1427,
1210,
1403,
1430,
1210,
1403,
1433,
1210,
1403,
1436,
1210,
1403,
1439,
1210,
1403,
1442,
1210,
1445,
1449,
1445,
],
strings: [
"Inspect",
"Inspector",
"InspectFormatter",
"ElemWalker",
"KeyValWalker",
"inspect",
"init",
"list",
"set",
"dict",
"tag",
"tuple",
"record",
"bool",
"str",
"opaque",
"function",
"u8",
"i8",
"u16",
"i16",
"u32",
"i32",
"u64",
"i64",
"u128",
"i128",
"f32",
"f64",
"dec",
"custom",
"apply",
"toInspector",
"toStr",
"DbgFormatter",
"dbgInit",
"dbgList",
"dbgSet",
"dbgDict",
"dbgTag",
"dbgTuple",
"dbgRecord",
"dbgBool",
"dbgStr",
"dbgOpaque",
"dbgFunction",
"dbgU8",
"dbgI8",
"dbgU16",
"dbgI16",
"dbgU32",
"dbgI32",
"dbgU64",
"dbgI64",
"dbgU128",
"dbgI128",
"dbgF32",
"dbgF64",
"dbgDec",
"dbgWrite",
"toDbgStr",
"InspectFormatter",
"InspectFormatter",
"Inspector",
"List",
"Inspector",
"Str",
"InspectFormatter",
"Inspector",
"List",
"Inspector",
"InspectFormatter",
"Inspector",
"List",
"Str",
"Inspector",
"InspectFormatter",
"Inspector",
"Bool",
"InspectFormatter",
"Inspector",
"Str",
"InspectFormatter",
"Inspector",
"Inspector",
"ElemWalker",
"InspectFormatter",
"Inspector",
"Inspector",
"ElemWalker",
"InspectFormatter",
"Inspector",
"Inspector",
"Inspector",
"KeyValWalker",
"InspectFormatter",
"Inspector",
"InspectFormatter",
"Inspector",
"InspectFormatter",
"Inspector",
"U8",
"InspectFormatter",
"Inspector",
"I8",
"InspectFormatter",
"Inspector",
"U16",
"InspectFormatter",
"Inspector",
"I16",
"InspectFormatter",
"Inspector",
"U32",
"InspectFormatter",
"Inspector",
"I32",
"InspectFormatter",
"Inspector",
"U64",
"InspectFormatter",
"Inspector",
"I64",
"InspectFormatter",
"Inspector",
"U128",
"InspectFormatter",
"Inspector",
"I128",
"InspectFormatter",
"Inspector",
"F32",
"InspectFormatter",
"Inspector",
"F64",
"InspectFormatter",
"Inspector",
"Dec",
"InspectFormatter",
"InspectFormatter",
"Inspect",
"Inspector",
"Str",
"fn",
"fn",
"fmt",
"val",
"valFn",
"val",
"content",
"walkFn",
"toDbgInspector",
"152",
"f0",
"154",
"f1",
"156",
"f2",
"prependSep",
"elem",
"f3",
"161",
"f4",
"163",
"content",
"walkFn",
"toDbgInspector",
"167",
"f0",
"169",
"f1",
"171",
"f2",
"prependSep",
"elem",
"f3",
"176",
"f4",
"178",
"d",
"walkFn",
"keyToInspector",
"valueToInspector",
"183",
"f0",
"185",
"f1",
"187",
"f2",
"prependSep",
"key",
"value",
"f3",
"193",
"x",
"195",
"f4",
"197",
"name",
"fields",
"200",
"f0",
"202",
"f0",
"204",
"f1",
"206",
"f2",
"inspector",
"209",
"x",
"fields",
"212",
"f0",
"214",
"f1",
"216",
"f2",
"prependSep",
"inspector",
"f3",
"221",
"f4",
"223",
"fields",
"225",
"f0",
"227",
"f1",
"229",
"f2",
"prependSep",
"key",
"value",
"f3",
"235",
"x",
"237",
"f4",
"239",
"b",
"241",
"f0",
"243",
"f0",
"s",
"246",
"f0",
"248",
"f0",
"250",
"f0",
"num",
"253",
"f0",
"num",
"256",
"f0",
"num",
"259",
"f0",
"num",
"262",
"f0",
"num",
"265",
"f0",
"num",
"268",
"f0",
"num",
"271",
"f0",
"num",
"274",
"f0",
"num",
"277",
"f0",
"num",
"280",
"f0",
"num",
"283",
"f0",
"num",
"286",
"f0",
"num",
"289",
"f0",
"data",
"added",
"data",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffed38cad0,
head: 000000,
bits: 294,
capacity: 320,
} [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
regions: [
@3268-3275,
@3006-3063,
@889-905,
@802-887,
@707-801,
@3464-3471,
@921-925,
@1381-1385,
@1499-1502,
@1614-1618,
@977-980,
@1062-1067,
@1144-1150,
@1248-1252,
@1315-1318,
@1880-1886,
@2095-2103,
@2164-2166,
@2227-2229,
@2290-2293,
@2355-2358,
@2420-2423,
@2485-2488,
@2550-2553,
@2615-2618,
@2680-2684,
@2747-2751,
@2814-2817,
@2879-2882,
@2944-2947,
@3134-3140,
@3229-3234,
@3291-3302,
@3592-3597,
@3808-3838,
@4564-4571,
@4727-4734,
@5243-5249,
@5802-5809,
@6339-6345,
@6748-6756,
@7189-7198,
@7641-7648,
@7827-7833,
@8022-8031,
@8127-8138,
@8231-8236,
@8337-8342,
@8445-8451,
@8554-8560,
@8663-8669,
@8772-8778,
@8881-8887,
@8990-8996,
@9101-9108,
@9213-9220,
@9323-9329,
@9432-9438,
@9541-9547,
@9656-9664,
@9783-9791,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
@3144-3146,
@3249-3251,
@3253-3256,
@3475-3478,
@3498-3503,
@3601-3604,
@4738-4745,
@4747-4753,
@4755-4769,
…,
@4777-4779,
…,
@4818-4820,
…,
@4833-4835,
@4837-4847,
@4850-4854,
@4898-4900,
…,
@5075-5077,
…,
@5253-5260,
@5262-5268,
@5270-5284,
…,
@5292-5294,
…,
@5333-5335,
…,
@5348-5350,
@5352-5362,
@5365-5369,
@5413-5415,
…,
@5590-5592,
…,
@5813-5814,
@5816-5822,
@5824-5838,
@5840-5856,
…,
@5864-5866,
…,
@5905-5907,
…,
@5920-5922,
@5924-5934,
@5937-5940,
@5942-5947,
@5985-5987,
…,
@6166-6167,
…,
@6216-6218,
…,
@6349-6353,
@6355-6361,
…,
@6405-6407,
…,
@6460-6462,
…,
@6534-6536,
…,
@6552-6554,
@6556-6565,
…,
@6633-6634,
@6760-6766,
…,
@6774-6776,
…,
@6815-6817,
…,
@6830-6832,
@6834-6844,
@6847-6856,
@6902-6904,
…,
@7047-7049,
…,
@7202-7208,
…,
@7216-7218,
…,
@7257-7259,
…,
@7272-7274,
@7276-7286,
@7289-7303,
@7289-7303,
@7349-7351,
…,
@7516-7517,
…,
@7547-7549,
…,
@7652-7653,
…,
@7679-7681,
…,
@7741-7743,
@7837-7838,
…,
@7846-7848,
…,
@8044-8046,
…,
@8151-8153,
@8240-8243,
…,
@8251-8253,
@8346-8349,
…,
@8357-8359,
@8455-8458,
…,
@8466-8468,
@8564-8567,
…,
@8575-8577,
@8673-8676,
…,
@8684-8686,
@8782-8785,
…,
@8793-8795,
@8891-8894,
…,
@8902-8904,
@9000-9003,
…,
@9011-9013,
@9112-9115,
…,
@9123-9125,
@9224-9227,
…,
@9235-9237,
@9333-9336,
…,
@9344-9346,
@9442-9445,
…,
@9453-9455,
@9551-9554,
…,
@9562-9564,
@9682-9690,
@9692-9697,
@9809-9817,
],
home: Inspect,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`Inspect.Inspect`,
`Inspect.Inspector`,
`Inspect.InspectFormatter`,
`Inspect.ElemWalker`,
`Inspect.KeyValWalker`,
`Inspect.inspect`,
`Inspect.init`,
`Inspect.list`,
`Inspect.set`,
`Inspect.dict`,
`Inspect.tag`,
`Inspect.tuple`,
`Inspect.record`,
`Inspect.bool`,
`Inspect.str`,
`Inspect.function`,
`Inspect.opaque`,
`Inspect.u8`,
`Inspect.i8`,
`Inspect.u16`,
`Inspect.i16`,
`Inspect.u32`,
`Inspect.i32`,
`Inspect.u64`,
`Inspect.i64`,
`Inspect.u128`,
`Inspect.i128`,
`Inspect.f32`,
`Inspect.f64`,
`Inspect.dec`,
`Inspect.custom`,
`Inspect.apply`,
`Inspect.toInspector`,
`Inspect.toStr`,
],
},
},
<<docs:
Some(
"A value that can be hashed.\n",
)
docs>>
<<docs:
Some(
"Describes a hashing algorithm that is fed bytes and produces an integer hash.\n\nThe [Hasher] ability describes general-purpose hashers. It only allows\nemission of 64-bit unsigned integer hashes. It is not suitable for\ncryptographically-secure hashing.\n",
)
docs>>
<<docs:
Some(
"Adds a string into a [Hasher] by hashing its UTF-8 bytes.\n",
)
docs>>
<<docs:
Some(
"Adds a list of [Hash]able elements to a [Hasher] by hashing each element.\n",
)
docs>>
<<docs:
Some(
"Adds a single [Bool] to a hasher.\n",
)
docs>>
<<docs:
Some(
"Adds a single I8 to a hasher.\n",
)
docs>>
<<docs:
Some(
"Adds a single I16 to a hasher.\n",
)
docs>>
<<docs:
Some(
"Adds a single I32 to a hasher.\n",
)
docs>>
<<docs:
Some(
"Adds a single I64 to a hasher.\n",
)
docs>>
<<docs:
Some(
"Adds a single I128 to a hasher.\n",
)
docs>>
<<docs:
Some(
"LOWLEVEL get the i128 representation of a Dec.\n",
)
docs>>
<<docs:
Some(
"Adds a single [Dec] to a hasher.\n",
)
docs>>
<<docs:
Some(
"Adds a container of [Hash]able elements to a [Hasher] by hashing each element.\nThe container is iterated using the walk method passed in.\nThe order of the elements does not affect the final hash.\n",
)
docs>>
adding docs for "Hash.roc",
docs ModuleDocumentation {
name: "Hash",
entries: [
DocDef(
DocDef {
name: "Hash",
symbol: `Hash.Hash`,
type_vars: [],
type_annotation: Ability {
members: [
AbilityMember {
name: "hash",
type_annotation: Function {
args: [
BoundVariable(
"hasher",
),
BoundVariable(
"a",
),
],
output: BoundVariable(
"hasher",
),
},
able_variables: [
(
"a",
[
Apply {
name: "Hash",
parts: [],
},
],
),
(
"hasher",
[
Apply {
name: "Hasher",
parts: [],
},
],
),
],
docs: Some(
"Hashes a value into a [Hasher].\nNote that [hash] does not produce a hash value itself; the hasher must be\n[complete]d in order to extract the hash value.\n",
),
},
],
},
docs: Some(
"A value that can be hashed.\n",
),
},
),
DocDef(
DocDef {
name: "Hasher",
symbol: `Hash.Hasher`,
type_vars: [],
type_annotation: Ability {
members: [
AbilityMember {
name: "addBytes",
type_annotation: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
],
output: BoundVariable(
"a",
),
},
able_variables: [
(
"a",
[
Apply {
name: "Hasher",
parts: [],
},
],
),
],
docs: Some(
"Adds a list of bytes to the hasher.\n",
),
},
AbilityMember {
name: "addU8",
type_annotation: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "U8",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
able_variables: [
(
"a",
[
Apply {
name: "Hasher",
parts: [],
},
],
),
],
docs: Some(
"Adds a single U8 to the hasher.\n",
),
},
AbilityMember {
name: "addU16",
type_annotation: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "U16",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
able_variables: [
(
"a",
[
Apply {
name: "Hasher",
parts: [],
},
],
),
],
docs: Some(
"Adds a single U16 to the hasher.\n",
),
},
AbilityMember {
name: "addU32",
type_annotation: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "U32",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
able_variables: [
(
"a",
[
Apply {
name: "Hasher",
parts: [],
},
],
),
],
docs: Some(
"Adds a single U32 to the hasher.\n",
),
},
AbilityMember {
name: "addU64",
type_annotation: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
able_variables: [
(
"a",
[
Apply {
name: "Hasher",
parts: [],
},
],
),
],
docs: Some(
"Adds a single U64 to the hasher.\n",
),
},
AbilityMember {
name: "addU128",
type_annotation: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "U128",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
able_variables: [
(
"a",
[
Apply {
name: "Hasher",
parts: [],
},
],
),
],
docs: Some(
"Adds a single U128 to the hasher.\n",
),
},
AbilityMember {
name: "complete",
type_annotation: Function {
args: [
BoundVariable(
"a",
),
],
output: Apply {
name: "U64",
parts: [],
},
},
able_variables: [
(
"a",
[
Apply {
name: "Hasher",
parts: [],
},
],
),
],
docs: Some(
"Completes the hasher, extracting a hash value from its\naccumulated hash state.\n",
),
},
],
},
docs: Some(
"Describes a hashing algorithm that is fed bytes and produces an integer hash.\n\nThe [Hasher] ability describes general-purpose hashers. It only allows\nemission of 64-bit unsigned integer hashes. It is not suitable for\ncryptographically-secure hashing.\n",
),
},
),
DocDef(
DocDef {
name: "hashBool",
symbol: `Hash.hashBool`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "Bool",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
implements: [
ImplementsClause {
name: "a",
abilities: [
Apply {
name: "Hasher",
parts: [],
},
],
},
],
},
docs: Some(
"Adds a single [Bool] to a hasher.\n",
),
},
),
DocDef(
DocDef {
name: "hashI8",
symbol: `Hash.hashI8`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "I8",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
implements: [
ImplementsClause {
name: "a",
abilities: [
Apply {
name: "Hasher",
parts: [],
},
],
},
],
},
docs: Some(
"Adds a single I8 to a hasher.\n",
),
},
),
DocDef(
DocDef {
name: "hashI16",
symbol: `Hash.hashI16`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "I16",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
implements: [
ImplementsClause {
name: "a",
abilities: [
Apply {
name: "Hasher",
parts: [],
},
],
},
],
},
docs: Some(
"Adds a single I16 to a hasher.\n",
),
},
),
DocDef(
DocDef {
name: "hashI32",
symbol: `Hash.hashI32`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "I32",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
implements: [
ImplementsClause {
name: "a",
abilities: [
Apply {
name: "Hasher",
parts: [],
},
],
},
],
},
docs: Some(
"Adds a single I32 to a hasher.\n",
),
},
),
DocDef(
DocDef {
name: "hashI64",
symbol: `Hash.hashI64`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "I64",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
implements: [
ImplementsClause {
name: "a",
abilities: [
Apply {
name: "Hasher",
parts: [],
},
],
},
],
},
docs: Some(
"Adds a single I64 to a hasher.\n",
),
},
),
DocDef(
DocDef {
name: "hashI128",
symbol: `Hash.hashI128`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "I128",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
implements: [
ImplementsClause {
name: "a",
abilities: [
Apply {
name: "Hasher",
parts: [],
},
],
},
],
},
docs: Some(
"Adds a single I128 to a hasher.\n",
),
},
),
DocDef(
DocDef {
name: "i128OfDec",
symbol: `Hash.i128OfDec`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dec",
parts: [],
},
],
output: Apply {
name: "I128",
parts: [],
},
},
docs: Some(
"LOWLEVEL get the i128 representation of a Dec.\n",
),
},
),
DocDef(
DocDef {
name: "hashDec",
symbol: `Hash.hashDec`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"a",
),
Apply {
name: "Dec",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
implements: [
ImplementsClause {
name: "a",
abilities: [
Apply {
name: "Hasher",
parts: [],
},
],
},
],
},
docs: Some(
"Adds a single [Dec] to a hasher.\n",
),
},
),
],
scope: Scope {
aliases: VecMap {
keys: [
`Num.Binary32`,
`Num.F32`,
`Num.FloatingPoint`,
`Str.Utf8ByteProblem`,
`Num.Unsigned16`,
`Num.U16`,
`Bool.Bool`,
`Num.U64`,
`Num.Binary64`,
`Num.Int`,
`Num.Signed128`,
`Num.Unsigned8`,
`Num.Frac`,
`Num.U32`,
`Num.Signed64`,
`Num.Signed8`,
`Num.I64`,
`Num.U8`,
`Num.I16`,
`Num.Unsigned128`,
`Num.I8`,
`Num.Num`,
`Num.Decimal`,
`Str.Utf8Problem`,
`Num.Unsigned32`,
`Num.Signed32`,
`Num.Integer`,
`Num.I128`,
`Num.U128`,
`Num.I32`,
`Num.Signed16`,
`Num.Unsigned64`,
`Num.F64`,
`Num.Dec`,
`Str.IdentId(49)`,
],
values: [
Alias {
region: @17634-17642,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19444-19447,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17650-17669,
type_variables: [
@17664-17669 AliasVar {
name: 'range',
var: 67,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <67>,
kind: Opaque,
},
Alias {
region: @26725-26740,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<63>,
kind: Structural,
},
Alias {
region: @17202-17212,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17544-17547,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @1780-1784,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: ['False', 'True'],
kind: Opaque,
},
Alias {
region: @17482-17485,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17619-17627,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @12895-12904,
type_variables: [
@12899-12904 AliasVar {
name: 'range',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` <64>[ but actually <64> ])[ but actually (Alias `Num.Integer` <64>[ but actually <64> ]) ]),
kind: Structural,
},
Alias {
region: @17074-17083,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17219-17228,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17034-17044,
type_variables: [
@17039-17044 AliasVar {
name: 'range',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` <65>[ but actually <65> ])[ but actually (Alias `Num.FloatingPoint` <65>[ but actually <65> ]) ]),
kind: Structural,
},
Alias {
region: @17513-17516,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17090-17098,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17135-17142,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17291-17294,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17575-17577,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17349-17352,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17150-17161,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17431-17433,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Int` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ]) ]) ]),
kind: Structural,
},
Alias {
region: @5228-5237,
type_variables: [
@5232-5237 AliasVar {
name: 'range',
var: 63,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <63>,
kind: Opaque,
},
Alias {
region: @17605-17612,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @26896-26907,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
64,
],
recursion_variables: {},
typ: { 'problem' : RigidRequired((Alias `Str.Utf8ByteProblem`[ but actually ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<64> ]))'byteIndex' : RigidRequired((DelayedAlias `Num.U64`)), },
kind: Structural,
},
Alias {
region: @17185-17195,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17105-17113,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17236-17249,
type_variables: [
@17244-17249 AliasVar {
name: 'range',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <66>,
kind: Opaque,
},
Alias {
region: @17260-17264,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17449-17453,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17320-17323,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17120-17128,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17168-17178,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19085-19088,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @23363-23366,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @35465-35479,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
65,
],
recursion_variables: {},
typ: { 'dProblemCode' : RigidRequired((Alias `Str.Utf8ByteProblem`[ but actually ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<65> ]))'cIsOk' : RigidRequired((DelayedAlias `Bool.Bool`)), 'aByteIndex' : RigidRequired((DelayedAlias `Num.U64`)), 'bString' : RigidRequired((`Str.Str`)), },
kind: Structural,
},
],
},
abilities_store: IAbilitiesStore {
members_of_ability: {
`Hash.Hash`: [
`Hash.hash`,
],
`Bool.Eq`: [
`Bool.isEq`,
],
`Hash.Hasher`: [
`Hash.addBytes`,
`Hash.addU8`,
`Hash.addU16`,
`Hash.addU32`,
`Hash.addU64`,
`Hash.addU128`,
`Hash.complete`,
],
},
specialization_to_root: {
`Bool.boolIsEq`: ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
},
},
ability_members: {
`Hash.hash`: AbilityMemberData {
parent_ability: `Hash.Hash`,
region: @742-746,
typ: Local {
signature_var: 87,
signature: Fn(<85>, <84> |Uls(84:`Hash.hash`:1)| -> <85>),
variables: MemberVariables {
able_vars: [
84,
85,
],
rigid_vars: [
86,
],
flex_vars: [],
},
},
},
`Bool.isEq`: AbilityMemberData {
parent_ability: `Bool.Eq`,
region: @1635-1639,
typ: Imported,
},
`Hash.addU128`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1614-1621,
typ: Local {
signature_var: 80,
signature: Fn(<78>, (DelayedAlias `Num.U128`) |Uls(78:`Hash.addU128`:1)| -> <78>),
variables: MemberVariables {
able_vars: [
78,
],
rigid_vars: [
79,
],
flex_vars: [],
},
},
},
`Hash.addU32`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1429-1435,
typ: Local {
signature_var: 74,
signature: Fn(<72>, (DelayedAlias `Num.U32`) |Uls(72:`Hash.addU32`:1)| -> <72>),
variables: MemberVariables {
able_vars: [
72,
],
rigid_vars: [
73,
],
flex_vars: [],
},
},
},
`Hash.addU8`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1247-1252,
typ: Local {
signature_var: 68,
signature: Fn(<66>, (DelayedAlias `Num.U8`) |Uls(66:`Hash.addU8`:1)| -> <66>),
variables: MemberVariables {
able_vars: [
66,
],
rigid_vars: [
67,
],
flex_vars: [],
},
},
},
`Hash.addU16`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1337-1343,
typ: Local {
signature_var: 71,
signature: Fn(<69>, (DelayedAlias `Num.U16`) |Uls(69:`Hash.addU16`:1)| -> <69>),
variables: MemberVariables {
able_vars: [
69,
],
rigid_vars: [
70,
],
flex_vars: [],
},
},
},
`Hash.addU64`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1521-1527,
typ: Local {
signature_var: 77,
signature: Fn(<75>, (DelayedAlias `Num.U64`) |Uls(75:`Hash.addU64`:1)| -> <75>),
variables: MemberVariables {
able_vars: [
75,
],
rigid_vars: [
76,
],
flex_vars: [],
},
},
},
`Hash.complete`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1761-1769,
typ: Local {
signature_var: 83,
signature: Fn(<81> |Uls(81:`Hash.complete`:1)| -> (DelayedAlias `Num.U64`)),
variables: MemberVariables {
able_vars: [
81,
],
rigid_vars: [
82,
],
flex_vars: [],
},
},
},
`Hash.addBytes`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1150-1158,
typ: Local {
signature_var: 65,
signature: Fn(<63>, (`List.List` @1169-1171 (DelayedAlias `Num.U8`)) |Uls(63:`Hash.addBytes`:1)| -> <63>),
variables: MemberVariables {
able_vars: [
63,
],
rigid_vars: [
64,
],
flex_vars: [],
},
},
},
},
declared_implementations: {
ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
}: Impl(
`Bool.boolIsEq`,
),
},
specializations: {},
next_specialization_id: 12,
resolved_specializations: {},
},
home: Hash,
exposed_ident_count: 21,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "U8",
},
),
`Num.U8`,
@452-454,
),
(
Ident(
IdentStr {
string: "I32",
},
),
`Num.I32`,
@486-489,
),
(
Ident(
IdentStr {
string: "I8",
},
),
`Num.I8`,
@477-479,
),
(
Ident(
IdentStr {
string: "I16",
},
),
`Num.I16`,
@481-484,
),
(
Ident(
IdentStr {
string: "I128",
},
),
`Num.I128`,
@496-500,
),
(
Ident(
IdentStr {
string: "Dec",
},
),
`Num.Dec`,
@502-505,
),
(
Ident(
IdentStr {
string: "U64",
},
),
`Num.U64`,
@466-469,
),
(
Ident(
IdentStr {
string: "I64",
},
),
`Num.I64`,
@491-494,
),
(
Ident(
IdentStr {
string: "U16",
},
),
`Num.U16`,
@456-459,
),
(
Ident(
IdentStr {
string: "U32",
},
),
`Num.U32`,
@461-464,
),
(
Ident(
IdentStr {
string: "Bool",
},
),
`Bool.Bool`,
@403-407,
),
(
Ident(
IdentStr {
string: "U128",
},
),
`Num.U128`,
@471-475,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
72,
97,
115,
104,
104,
97,
115,
104,
72,
97,
115,
104,
101,
114,
97,
100,
100,
66,
121,
116,
101,
115,
97,
100,
100,
85,
56,
97,
100,
100,
85,
49,
54,
97,
100,
100,
85,
51,
50,
97,
100,
100,
85,
54,
52,
97,
100,
100,
85,
49,
50,
56,
104,
97,
115,
104,
66,
111,
111,
108,
104,
97,
115,
104,
73,
56,
104,
97,
115,
104,
73,
49,
54,
104,
97,
115,
104,
73,
51,
50,
104,
97,
115,
104,
73,
54,
52,
104,
97,
115,
104,
73,
49,
50,
56,
104,
97,
115,
104,
85,
110,
111,
114,
100,
101,
114,
101,
100,
105,
49,
50,
56,
79,
102,
68,
101,
99,
104,
97,
115,
104,
68,
101,
99,
99,
111,
109,
112,
108,
101,
116,
101,
104,
97,
115,
104,
83,
116,
114,
66,
121,
116,
101,
115,
104,
97,
115,
104,
76,
105,
115,
116,
72,
97,
115,
104,
101,
114,
72,
97,
115,
104,
72,
97,
115,
104,
101,
114,
76,
105,
115,
116,
85,
56,
72,
97,
115,
104,
101,
114,
85,
56,
72,
97,
115,
104,
101,
114,
85,
49,
54,
72,
97,
115,
104,
101,
114,
85,
51,
50,
72,
97,
115,
104,
101,
114,
85,
54,
52,
72,
97,
115,
104,
101,
114,
85,
49,
50,
56,
72,
97,
115,
104,
101,
114,
85,
54,
52,
104,
97,
115,
104,
101,
114,
115,
108,
115,
116,
52,
50,
97,
99,
99,
117,
109,
72,
97,
115,
104,
101,
114,
101,
108,
101,
109,
98,
97,
115,
85,
56,
110,
99,
111,
110,
116,
97,
105,
110,
101,
114,
119,
97,
108,
107,
54,
51,
97,
99,
99,
117,
109,
120,
110,
101,
120,
116,
65,
99,
99,
117,
109,
54,
56,
],
lengths: [
Interned(4),
Interned(4),
Interned(6),
Interned(8),
Interned(5),
Interned(6),
Interned(6),
Interned(6),
Interned(7),
Interned(8),
Interned(6),
Interned(7),
Interned(7),
Interned(7),
Interned(8),
Interned(13),
Interned(9),
Interned(7),
Interned(8),
Interned(12),
Interned(8),
Interned(6),
Interned(4),
Interned(6),
Interned(4),
Interned(2),
Interned(6),
Interned(2),
Interned(6),
Interned(3),
Interned(6),
Interned(3),
Interned(6),
Interned(3),
Interned(6),
Interned(4),
Interned(6),
Interned(3),
Interned(6),
Interned(1),
Interned(6),
Interned(3),
Generated(2),
Interned(11),
Interned(4),
Interned(6),
Interned(1),
Interned(4),
Interned(6),
Interned(1),
Interned(6),
Interned(1),
Interned(6),
Interned(1),
Interned(6),
Interned(1),
Interned(6),
Interned(1),
Interned(6),
Interned(1),
Interned(6),
Interned(9),
Interned(4),
Generated(2),
Interned(5),
Interned(4),
Interned(1),
Interned(9),
Generated(2),
Interned(5),
],
offsets: [
0,
4,
8,
14,
22,
27,
33,
39,
45,
52,
60,
66,
73,
80,
87,
95,
108,
117,
124,
132,
144,
152,
158,
162,
168,
172,
174,
180,
182,
188,
191,
197,
200,
206,
209,
215,
219,
225,
228,
234,
228,
235,
238,
240,
251,
228,
255,
256,
228,
260,
228,
260,
228,
260,
228,
260,
228,
260,
228,
260,
228,
261,
270,
274,
276,
251,
281,
282,
291,
276,
],
strings: [
"Hash",
"hash",
"Hasher",
"addBytes",
"addU8",
"addU16",
"addU32",
"addU64",
"addU128",
"hashBool",
"hashI8",
"hashI16",
"hashI32",
"hashI64",
"hashI128",
"hashUnordered",
"i128OfDec",
"hashDec",
"complete",
"hashStrBytes",
"hashList",
"Hasher",
"Hash",
"Hasher",
"List",
"U8",
"Hasher",
"U8",
"Hasher",
"U16",
"Hasher",
"U32",
"Hasher",
"U64",
"Hasher",
"U128",
"Hasher",
"U64",
"hasher",
"s",
"hasher",
"lst",
"42",
"accumHasher",
"elem",
"hasher",
"b",
"asU8",
"hasher",
"n",
"hasher",
"n",
"hasher",
"n",
"hasher",
"n",
"hasher",
"n",
"hasher",
"n",
"hasher",
"container",
"walk",
"63",
"accum",
"elem",
"x",
"nextAccum",
"68",
"accum",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffed437a00,
head: 000000,
bits: 70,
capacity: 128,
} [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
regions: [
@547-551,
@742-746,
@1085-1091,
@1150-1158,
@1247-1252,
@1337-1343,
@1429-1435,
@1521-1527,
@1614-1621,
@2203-2211,
@2360-2366,
@2492-2499,
@2627-2634,
@2762-2769,
@2900-2908,
@3375-3388,
@3006-3015,
@3115-3122,
@1761-1769,
@1869-1881,
@2011-2019,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
@1885-1891,
@1893-1894,
@2023-2029,
@2031-2034,
…,
@2064-2075,
@2077-2081,
@2215-2221,
@2223-2224,
@2232-2236,
@2370-2376,
@2378-2379,
@2503-2509,
@2511-2512,
@2638-2644,
@2646-2647,
@2773-2779,
@2781-2782,
@2912-2918,
@2920-2921,
@3126-3132,
@3134-3135,
@3392-3398,
@3400-3409,
@3411-3415,
…,
@3466-3471,
@3473-3477,
@3493-3494,
@3746-3755,
…,
@4007-4012,
],
home: Hash,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`Hash.Hash`,
`Hash.Hasher`,
`Hash.hash`,
`Hash.addBytes`,
`Hash.addU8`,
`Hash.addU16`,
`Hash.addU32`,
`Hash.addU64`,
`Hash.addU128`,
`Hash.hashBool`,
`Hash.hashI8`,
`Hash.hashI16`,
`Hash.hashI32`,
`Hash.hashI64`,
`Hash.hashI128`,
`Hash.hashDec`,
`Hash.complete`,
`Hash.hashStrBytes`,
`Hash.hashList`,
`Hash.hashUnordered`,
],
},
},
<<docs:
Some(
"A [dictionary](https://en.wikipedia.org/wiki/Associative_array) that lets you\nassociate keys with values.\n\n## Inserting\n\nThe most basic way to use a dictionary is to start with an empty one and\nthen:\n1. Call [Dict.insert] passing a key and a value, to associate that key with\nthat value in the dictionary.\n2. Later, call [Dict.get] passing the same key as before, and it will return\nthe value you stored.\n\nHere's an example of a dictionary which uses a city's name as the key, and\nits population as the associated value.\n```\npopulationByCity =\n Dict.empty {}\n |> Dict.insert \"London\" 8_961_989\n |> Dict.insert \"Philadelphia\" 1_603_797\n |> Dict.insert \"Shanghai\" 24_870_895\n |> Dict.insert \"Delhi\" 16_787_941\n |> Dict.insert \"Amsterdam\" 872_680\n```\n## Accessing keys or values\n\nWe can use [Dict.keys] and [Dict.values] functions to get only the keys or\nonly the values.\n\nYou may notice that these lists have the same order as the original insertion\norder. This will be true if all you ever do is [Dict.insert] and [Dict.get] operations\non the dictionary, but [Dict.remove] operations can change this order.\n\n## Removing\n\nWe can remove an element from the dictionary, like so:\n```\npopulationByCity\n |> Dict.remove \"Philadelphia\"\n |> Dict.keys\n ==\n [\"London\", \"Amsterdam\", \"Shanghai\", \"Delhi\"]\n```\nNotice that the order has changed. Philadelphia was not only removed from the\nlist, but Amsterdam - the last entry we inserted - has been moved into the\nspot where Philadelphia was previously. This is exactly what [Dict.remove]\ndoes. It removes an element and moves the most recent insertion into the\nvacated spot.\n\nThis move is done as a performance optimization, and it lets [remove] have\n[constant time complexity](https://en.wikipedia.org/wiki/Time_complexity#Constant_time).\n\nDict is inspired by [IndexMap](https://docs.rs/indexmap/latest/indexmap/map/struct.IndexMap.html).\nThe internal implementation of a dictionary is almost identical to [ankerl::unordered_dense](https://github.com/martinus/unordered_dense).\nIt has a list of keys value pairs that is ordered based on insertion.\nIt uses a list of indices into the data as the backing of a hash map.\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Return an empty dictionary.\n```\nemptyDict = Dict.empty {}\n```\n",
)
docs>>
<<docs:
Some(
"Return a dictionary with space allocated for a number of entries. This\nmay provide a performance optimization if you know how many entries will be\ninserted.\n",
)
docs>>
<<docs:
Some(
"Enlarge the dictionary for at least capacity additional elements\n",
)
docs>>
<<docs:
Some(
"Shrink the memory footprint of a dictionary such that capacity is as small as possible.\nThis function will require regenerating the metadata if the size changes.\nThere will still be some overhead due to dictionary metadata always being a power of 2.\n",
)
docs>>
<<docs:
Some(
"Returns the max number of elements the dictionary can hold before requiring a rehash.\n```\nfoodDict =\n Dict.empty {}\n |> Dict.insert \"apple\" \"fruit\"\n\ncapacityOfDict = Dict.capacity foodDict\n```\n",
)
docs>>
<<docs:
Some(
"Returns a dictionary containing the key and value provided as input.\n```\nexpect\n Dict.single \"A\" \"B\"\n |> Bool.isEq (Dict.insert (Dict.empty {}) \"A\" \"B\")\n```\n",
)
docs>>
<<docs:
Some(
"Returns dictionary with the keys and values specified by the input [List].\n```\nexpect\n Dict.single 1 \"One\"\n |> Dict.insert 2 \"Two\"\n |> Dict.insert 3 \"Three\"\n |> Dict.insert 4 \"Four\"\n |> Bool.isEq (Dict.fromList [(1, \"One\"), (2, \"Two\"), (3, \"Three\"), (4, \"Four\")])\n```\n\n## Performance Details\n\nThis will build up from an empty dictionary to minimize totally memory use.\nIf the list has few duplicate keys, it would be faster to allocate a dictionary\nwith the same capacity of the list and walk it calling [Dict.insert]\n",
)
docs>>
<<docs:
Some(
"Returns the number of values in the dictionary.\n```\nexpect\n Dict.empty {}\n |> Dict.insert \"One\" \"A Song\"\n |> Dict.insert \"Two\" \"Candy Canes\"\n |> Dict.insert \"Three\" \"Boughs of Holly\"\n |> Dict.len\n |> Bool.isEq 3\n```\n",
)
docs>>
<<docs:
Some(
"Check if the dictionary is empty.\n```\nDict.isEmpty (Dict.empty {} |> Dict.insert \"key\" 42)\n\nDict.isEmpty (Dict.empty {})\n```\n",
)
docs>>
<<docs:
Some(
"Clears all elements from a dictionary keeping around the allocation if it isn't huge.\n```\nsongs =\n Dict.empty {}\n |> Dict.insert \"One\" \"A Song\"\n |> Dict.insert \"Two\" \"Candy Canes\"\n |> Dict.insert \"Three\" \"Boughs of Holly\"\n\nclearSongs = Dict.clear songs\n\nexpect Dict.len clearSongs == 0\n```\n",
)
docs>>
<<docs:
Some(
"Convert each value in the dictionary to something new, by calling a conversion\nfunction on each of them which receives both the key and the old value. Then return a\nnew dictionary containing the same keys and the converted values.\n",
)
docs>>
<<docs:
Some(
"Like [Dict.map], except the transformation function wraps the return value\nin a dictionary. At the end, all the dictionaries get joined together\n(using [Dict.insertAll]) into one dictionary.\n\nYou may know a similar function named `concatMap` in other languages.\n",
)
docs>>
<<docs:
Some(
"Iterate through the keys and values in the dictionary and call the provided\nfunction with signature `state, k, v -> state` for each value, with an\ninitial `state` value provided for the first call.\n```\nexpect\n Dict.empty {}\n |> Dict.insert \"Apples\" 12\n |> Dict.insert \"Orange\" 24\n |> Dict.walk 0 (\\count, _, qty -> count + qty)\n |> Bool.isEq 36\n```\n",
)
docs>>
<<docs:
Some(
"Same as [Dict.walk], except you can stop walking early.\n\n## Performance Details\n\nCompared to [Dict.walk], this can potentially visit fewer elements (which can\nimprove performance) at the cost of making each step take longer.\nHowever, the added cost to each step is extremely small, and can easily\nbe outweighed if it results in skipping even a small number of elements.\n\nAs such, it is typically better for performance to use this over [Dict.walk]\nif returning `Break` earlier than the last element is expected to be common.\n```\npeople =\n Dict.empty {}\n |> Dict.insert \"Alice\" 17\n |> Dict.insert \"Bob\" 18\n |> Dict.insert \"Charlie\" 19\n\nisAdult = \\_, _, age ->\n if age >= 18 then\n Break Bool.true\n else\n Continue Bool.false\n\nsomeoneIsAnAdult = Dict.walkUntil people Bool.false isAdult\n\nexpect someoneIsAnAdult == Bool.true\n```\n",
)
docs>>
<<docs:
Some(
"Run the given function on each key-value pair of a dictionary, and return\na dictionary with just the pairs for which the function returned `Bool.true`.\n```\nexpect Dict.empty {}\n |> Dict.insert \"Alice\" 17\n |> Dict.insert \"Bob\" 18\n |> Dict.insert \"Charlie\" 19\n |> Dict.keepIf \\(_k, v) -> v >= 18\n |> Dict.len\n |> Bool.isEq 2\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Run the given function on each key-value pair of a dictionary, and return\na dictionary with just the pairs for which the function returned `Bool.false`.\n```\nexpect Dict.empty {}\n |> Dict.insert \"Alice\" 17\n |> Dict.insert \"Bob\" 18\n |> Dict.insert \"Charlie\" 19\n |> Dict.dropIf \\(_k, v) -> v >= 18\n |> Dict.len\n |> Bool.isEq 1\n```\n",
)
docs>>
<<docs:
Some(
"Get the value for a given key. If there is a value for the specified key it\nwill return [Ok value], otherwise return [Err KeyNotFound].\n```\ndictionary =\n Dict.empty {}\n |> Dict.insert 1 \"Apple\"\n |> Dict.insert 2 \"Orange\"\n\nexpect Dict.get dictionary 1 == Ok \"Apple\"\nexpect Dict.get dictionary 2000 == Err KeyNotFound\n```\n",
)
docs>>
<<docs:
Some(
"Check if the dictionary has a value for a specified key.\n```\nexpect\n Dict.empty {}\n |> Dict.insert 1234 \"5678\"\n |> Dict.contains 1234\n |> Bool.isEq Bool.true\n```\n",
)
docs>>
<<docs:
Some(
"Insert a value into the dictionary at a specified key.\n```\nexpect\n Dict.empty {}\n |> Dict.insert \"Apples\" 12\n |> Dict.get \"Apples\"\n |> Bool.isEq (Ok 12)\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Remove a value from the dictionary for a specified key.\n```\nexpect\n Dict.empty {}\n |> Dict.insert \"Some\" \"Value\"\n |> Dict.remove \"Some\"\n |> Dict.len\n |> Bool.isEq 0\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Insert or remove a value for a specified key. This function enables a\nperformance optimization for the use case of providing a default when a value\nis missing. This is more efficient than doing both a `Dict.get` and then a\n`Dict.insert` call, and supports being piped.\n```\nalterValue : [Present Bool, Missing] -> [Present Bool, Missing]\nalterValue = \\possibleValue ->\n when possibleValue is\n Missing -> Present Bool.false\n Present value -> if value then Missing else Present Bool.true\n\nexpect Dict.update (Dict.empty {}) \"a\" alterValue == Dict.single \"a\" Bool.false\nexpect Dict.update (Dict.single \"a\" Bool.false) \"a\" alterValue == Dict.single \"a\" Bool.true\nexpect Dict.update (Dict.single \"a\" Bool.true) \"a\" alterValue == Dict.empty {}\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Returns the keys and values of a dictionary as a [List].\nThis requires allocating a temporary list, prefer using [Dict.toList] or [Dict.walk] instead.\n```\nexpect\n Dict.single 1 \"One\"\n |> Dict.insert 2 \"Two\"\n |> Dict.insert 3 \"Three\"\n |> Dict.insert 4 \"Four\"\n |> Dict.toList\n |> Bool.isEq [(1, \"One\"), (2, \"Two\"), (3, \"Three\"), (4, \"Four\")]\n```\n",
)
docs>>
<<docs:
Some(
"Returns the keys of a dictionary as a [List].\nThis requires allocating a temporary [List], prefer using [Dict.toList] or [Dict.walk] instead.\n```\nexpect\n Dict.single 1 \"One\"\n |> Dict.insert 2 \"Two\"\n |> Dict.insert 3 \"Three\"\n |> Dict.insert 4 \"Four\"\n |> Dict.keys\n |> Bool.isEq [1,2,3,4]\n```\n",
)
docs>>
<<docs:
Some(
"Returns the values of a dictionary as a [List].\nThis requires allocating a temporary [List], prefer using [Dict.toList] or [Dict.walk] instead.\n```\nexpect\n Dict.single 1 \"One\"\n |> Dict.insert 2 \"Two\"\n |> Dict.insert 3 \"Three\"\n |> Dict.insert 4 \"Four\"\n |> Dict.values\n |> Bool.isEq [\"One\",\"Two\",\"Three\",\"Four\"]\n```\n",
)
docs>>
<<docs:
Some(
"Combine two dictionaries by keeping the [union](https://en.wikipedia.org/wiki/Union_(set_theory))\nof all the key-value pairs. This means that all the key-value pairs in\nboth dictionaries will be combined. Note that where there are pairs\nwith the same key, the value contained in the second input will be\nretained, and the value in the first input will be removed.\n```\nfirst =\n Dict.single 1 \"Not Me\"\n |> Dict.insert 2 \"And Me\"\n\nsecond =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 3 \"Me Too\"\n |> Dict.insert 4 \"And Also Me\"\n\nexpected =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 2 \"And Me\"\n |> Dict.insert 3 \"Me Too\"\n |> Dict.insert 4 \"And Also Me\"\n\nexpect\n Dict.insertAll first second == expected\n```\n",
)
docs>>
<<docs:
Some(
"Combine two dictionaries by keeping the [intersection](https://en.wikipedia.org/wiki/Intersection_(set_theory))\nof all the key-value pairs. This means that we keep only those pairs\nthat are in both dictionaries. Both the key and value must match to be kept.\n```\nfirst =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 2 \"And Me\"\n |> Dict.insert 3 \"Not this one\"\n\nsecond =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 2 \"And Me\"\n |> Dict.insert 3 \"This has a different value\"\n |> Dict.insert 4 \"Or Me\"\n\nexpected =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 2 \"And Me\"\n\nexpect Dict.keepShared first second == expected\n```\n",
)
docs>>
<<docs:
Some(
"Remove the key-value pairs in the first input that are also in the second\nusing the [set difference](https://en.wikipedia.org/wiki/Complement_(set_theory)#Relative_complement)\nof the values. This means that we will be left with only those pairs that\nare in the first dictionary and whose keys are not in the second.\n```\nfirst =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 2 \"And Me\"\n |> Dict.insert 3 \"Remove Me\"\n\nsecond =\n Dict.single 3 \"Remove Me\"\n |> Dict.insert 4 \"I do nothing...\"\n\nexpected =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 2 \"And Me\"\n\nexpect Dict.removeAll first second == expected\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
adding docs for "Dict.roc",
docs ModuleDocumentation {
name: "Dict",
entries: [
DocDef(
DocDef {
name: "Dict",
symbol: `Dict.Dict`,
type_vars: [
"k",
"v",
],
type_annotation: NoTypeAnn,
docs: Some(
"A [dictionary](https://en.wikipedia.org/wiki/Associative_array) that lets you\nassociate keys with values.\n\n## Inserting\n\nThe most basic way to use a dictionary is to start with an empty one and\nthen:\n1. Call [Dict.insert] passing a key and a value, to associate that key with\nthat value in the dictionary.\n2. Later, call [Dict.get] passing the same key as before, and it will return\nthe value you stored.\n\nHere's an example of a dictionary which uses a city's name as the key, and\nits population as the associated value.\n```\npopulationByCity =\n Dict.empty {}\n |> Dict.insert \"London\" 8_961_989\n |> Dict.insert \"Philadelphia\" 1_603_797\n |> Dict.insert \"Shanghai\" 24_870_895\n |> Dict.insert \"Delhi\" 16_787_941\n |> Dict.insert \"Amsterdam\" 872_680\n```\n## Accessing keys or values\n\nWe can use [Dict.keys] and [Dict.values] functions to get only the keys or\nonly the values.\n\nYou may notice that these lists have the same order as the original insertion\norder. This will be true if all you ever do is [Dict.insert] and [Dict.get] operations\non the dictionary, but [Dict.remove] operations can change this order.\n\n## Removing\n\nWe can remove an element from the dictionary, like so:\n```\npopulationByCity\n |> Dict.remove \"Philadelphia\"\n |> Dict.keys\n ==\n [\"London\", \"Amsterdam\", \"Shanghai\", \"Delhi\"]\n```\nNotice that the order has changed. Philadelphia was not only removed from the\nlist, but Amsterdam - the last entry we inserted - has been moved into the\nspot where Philadelphia was previously. This is exactly what [Dict.remove]\ndoes. It removes an element and moves the most recent insertion into the\nvacated spot.\n\nThis move is done as a performance optimization, and it lets [remove] have\n[constant time complexity](https://en.wikipedia.org/wiki/Time_complexity#Constant_time).\n\nDict is inspired by [IndexMap](https://docs.rs/indexmap/latest/indexmap/map/struct.IndexMap.html).\nThe internal implementation of a dictionary is almost identical to [ankerl::unordered_dense](https://github.com/martinus/unordered_dense).\nIt has a list of keys value pairs that is ordered based on insertion.\nIt uses a list of indices into the data as the backing of a hash map.\n",
),
},
),
DocDef(
DocDef {
name: "isEq",
symbol: `Dict.isEq`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
implements: [
ImplementsClause {
name: "v",
abilities: [
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "hashDict",
symbol: `Dict.hashDict`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"hasher",
),
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
],
output: BoundVariable(
"hasher",
),
},
implements: [
ImplementsClause {
name: "v",
abilities: [
Apply {
name: "Hash",
parts: [],
},
],
},
ImplementsClause {
name: "hasher",
abilities: [
Apply {
name: "Hasher",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "toInspectorDict",
symbol: `Dict.toInspectorDict`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
implements: [
ImplementsClause {
name: "k",
abilities: [
Apply {
name: "Inspect",
parts: [],
},
Apply {
name: "Hash",
parts: [],
},
Apply {
name: "Eq",
parts: [],
},
],
},
ImplementsClause {
name: "v",
abilities: [
Apply {
name: "Inspect",
parts: [],
},
],
},
ImplementsClause {
name: "f",
abilities: [
Apply {
name: "InspectFormatter",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "empty",
symbol: `Dict.empty`,
type_vars: [],
type_annotation: Function {
args: [
Record {
fields: [],
extension: NoTypeAnn,
},
],
output: Apply {
name: "Dict",
parts: [
Wildcard,
Wildcard,
],
},
},
docs: Some(
"Return an empty dictionary.\n```\nemptyDict = Dict.empty {}\n```\n",
),
},
),
DocDef(
DocDef {
name: "withCapacity",
symbol: `Dict.withCapacity`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Dict",
parts: [
Wildcard,
Wildcard,
],
},
},
docs: Some(
"Return a dictionary with space allocated for a number of entries. This\nmay provide a performance optimization if you know how many entries will be\ninserted.\n",
),
},
),
DocDef(
DocDef {
name: "reserve",
symbol: `Dict.reserve`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Enlarge the dictionary for at least capacity additional elements\n",
),
},
),
DocDef(
DocDef {
name: "releaseExcessCapacity",
symbol: `Dict.releaseExcessCapacity`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Shrink the memory footprint of a dictionary such that capacity is as small as possible.\nThis function will require regenerating the metadata if the size changes.\nThere will still be some overhead due to dictionary metadata always being a power of 2.\n",
),
},
),
DocDef(
DocDef {
name: "capacity",
symbol: `Dict.capacity`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
Wildcard,
Wildcard,
],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: Some(
"Returns the max number of elements the dictionary can hold before requiring a rehash.\n```\nfoodDict =\n Dict.empty {}\n |> Dict.insert \"apple\" \"fruit\"\n\ncapacityOfDict = Dict.capacity foodDict\n```\n",
),
},
),
DocDef(
DocDef {
name: "single",
symbol: `Dict.single`,
type_vars: [],
type_annotation: Function {
args: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Returns a dictionary containing the key and value provided as input.\n```\nexpect\n Dict.single \"A\" \"B\"\n |> Bool.isEq (Dict.insert (Dict.empty {}) \"A\" \"B\")\n```\n",
),
},
),
DocDef(
DocDef {
name: "fromList",
symbol: `Dict.fromList`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Tuple {
elems: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
extension: NoTypeAnn,
},
],
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Returns dictionary with the keys and values specified by the input [List].\n```\nexpect\n Dict.single 1 \"One\"\n |> Dict.insert 2 \"Two\"\n |> Dict.insert 3 \"Three\"\n |> Dict.insert 4 \"Four\"\n |> Bool.isEq (Dict.fromList [(1, \"One\"), (2, \"Two\"), (3, \"Three\"), (4, \"Four\")])\n```\n\n## Performance Details\n\nThis will build up from an empty dictionary to minimize totally memory use.\nIf the list has few duplicate keys, it would be faster to allocate a dictionary\nwith the same capacity of the list and walk it calling [Dict.insert]\n",
),
},
),
DocDef(
DocDef {
name: "len",
symbol: `Dict.len`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
Wildcard,
Wildcard,
],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: Some(
"Returns the number of values in the dictionary.\n```\nexpect\n Dict.empty {}\n |> Dict.insert \"One\" \"A Song\"\n |> Dict.insert \"Two\" \"Candy Canes\"\n |> Dict.insert \"Three\" \"Boughs of Holly\"\n |> Dict.len\n |> Bool.isEq 3\n```\n",
),
},
),
DocDef(
DocDef {
name: "isEmpty",
symbol: `Dict.isEmpty`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
Wildcard,
Wildcard,
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Check if the dictionary is empty.\n```\nDict.isEmpty (Dict.empty {} |> Dict.insert \"key\" 42)\n\nDict.isEmpty (Dict.empty {})\n```\n",
),
},
),
DocDef(
DocDef {
name: "clear",
symbol: `Dict.clear`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Clears all elements from a dictionary keeping around the allocation if it isn't huge.\n```\nsongs =\n Dict.empty {}\n |> Dict.insert \"One\" \"A Song\"\n |> Dict.insert \"Two\" \"Candy Canes\"\n |> Dict.insert \"Three\" \"Boughs of Holly\"\n\nclearSongs = Dict.clear songs\n\nexpect Dict.len clearSongs == 0\n```\n",
),
},
),
DocDef(
DocDef {
name: "map",
symbol: `Dict.map`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"k",
),
BoundVariable(
"a",
),
],
output: BoundVariable(
"b",
),
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"b",
),
],
},
},
docs: Some(
"Convert each value in the dictionary to something new, by calling a conversion\nfunction on each of them which receives both the key and the old value. Then return a\nnew dictionary containing the same keys and the converted values.\n",
),
},
),
DocDef(
DocDef {
name: "joinMap",
symbol: `Dict.joinMap`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"a",
),
BoundVariable(
"b",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
BoundVariable(
"b",
),
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"x",
),
BoundVariable(
"y",
),
],
},
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"x",
),
BoundVariable(
"y",
),
],
},
},
docs: Some(
"Like [Dict.map], except the transformation function wraps the return value\nin a dictionary. At the end, all the dictionaries get joined together\n(using [Dict.insertAll]) into one dictionary.\n\nYou may know a similar function named `concatMap` in other languages.\n",
),
},
),
DocDef(
DocDef {
name: "walk",
symbol: `Dict.walk`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
output: BoundVariable(
"state",
),
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Iterate through the keys and values in the dictionary and call the provided\nfunction with signature `state, k, v -> state` for each value, with an\ninitial `state` value provided for the first call.\n```\nexpect\n Dict.empty {}\n |> Dict.insert \"Apples\" 12\n |> Dict.insert \"Orange\" 24\n |> Dict.walk 0 (\\count, _, qty -> count + qty)\n |> Bool.isEq 36\n```\n",
),
},
),
DocDef(
DocDef {
name: "walkUntil",
symbol: `Dict.walkUntil`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"state",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"state",
),
],
},
],
extension: NoTypeAnn,
},
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Same as [Dict.walk], except you can stop walking early.\n\n## Performance Details\n\nCompared to [Dict.walk], this can potentially visit fewer elements (which can\nimprove performance) at the cost of making each step take longer.\nHowever, the added cost to each step is extremely small, and can easily\nbe outweighed if it results in skipping even a small number of elements.\n\nAs such, it is typically better for performance to use this over [Dict.walk]\nif returning `Break` earlier than the last element is expected to be common.\n```\npeople =\n Dict.empty {}\n |> Dict.insert \"Alice\" 17\n |> Dict.insert \"Bob\" 18\n |> Dict.insert \"Charlie\" 19\n\nisAdult = \\_, _, age ->\n if age >= 18 then\n Break Bool.true\n else\n Continue Bool.false\n\nsomeoneIsAnAdult = Dict.walkUntil people Bool.false isAdult\n\nexpect someoneIsAnAdult == Bool.true\n```\n",
),
},
),
DocDef(
DocDef {
name: "keepIf",
symbol: `Dict.keepIf`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
Function {
args: [
Tuple {
elems: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
extension: NoTypeAnn,
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Run the given function on each key-value pair of a dictionary, and return\na dictionary with just the pairs for which the function returned `Bool.true`.\n```\nexpect Dict.empty {}\n |> Dict.insert \"Alice\" 17\n |> Dict.insert \"Bob\" 18\n |> Dict.insert \"Charlie\" 19\n |> Dict.keepIf \\(_k, v) -> v >= 18\n |> Dict.len\n |> Bool.isEq 2\n```\n",
),
},
),
DocDef(
DocDef {
name: "keepIfHelp",
symbol: `Dict.keepIfHelp`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
Function {
args: [
Tuple {
elems: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
extension: NoTypeAnn,
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "dropIf",
symbol: `Dict.dropIf`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
Function {
args: [
Tuple {
elems: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
extension: NoTypeAnn,
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Run the given function on each key-value pair of a dictionary, and return\na dictionary with just the pairs for which the function returned `Bool.false`.\n```\nexpect Dict.empty {}\n |> Dict.insert \"Alice\" 17\n |> Dict.insert \"Bob\" 18\n |> Dict.insert \"Charlie\" 19\n |> Dict.dropIf \\(_k, v) -> v >= 18\n |> Dict.len\n |> Bool.isEq 1\n```\n",
),
},
),
DocDef(
DocDef {
name: "get",
symbol: `Dict.get`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
BoundVariable(
"k",
),
],
output: Apply {
name: "Result",
parts: [
BoundVariable(
"v",
),
TagUnion {
tags: [
Tag {
name: "KeyNotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Get the value for a given key. If there is a value for the specified key it\nwill return [Ok value], otherwise return [Err KeyNotFound].\n```\ndictionary =\n Dict.empty {}\n |> Dict.insert 1 \"Apple\"\n |> Dict.insert 2 \"Orange\"\n\nexpect Dict.get dictionary 1 == Ok \"Apple\"\nexpect Dict.get dictionary 2000 == Err KeyNotFound\n```\n",
),
},
),
DocDef(
DocDef {
name: "contains",
symbol: `Dict.contains`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
BoundVariable(
"k",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Check if the dictionary has a value for a specified key.\n```\nexpect\n Dict.empty {}\n |> Dict.insert 1234 \"5678\"\n |> Dict.contains 1234\n |> Bool.isEq Bool.true\n```\n",
),
},
),
DocDef(
DocDef {
name: "insert",
symbol: `Dict.insert`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Insert a value into the dictionary at a specified key.\n```\nexpect\n Dict.empty {}\n |> Dict.insert \"Apples\" 12\n |> Dict.get \"Apples\"\n |> Bool.isEq (Ok 12)\n```\n",
),
},
),
DocDef(
DocDef {
name: "insertHelper",
symbol: `Dict.insertHelper`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Bucket",
parts: [],
},
],
},
Apply {
name: "List",
parts: [
Tuple {
elems: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
extension: NoTypeAnn,
},
],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U32",
parts: [],
},
BoundVariable(
"k",
),
BoundVariable(
"v",
),
Apply {
name: "U64",
parts: [],
},
Apply {
name: "F32",
parts: [],
},
Apply {
name: "U8",
parts: [],
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "remove",
symbol: `Dict.remove`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
BoundVariable(
"k",
),
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Remove a value from the dictionary for a specified key.\n```\nexpect\n Dict.empty {}\n |> Dict.insert \"Some\" \"Value\"\n |> Dict.remove \"Some\"\n |> Dict.len\n |> Bool.isEq 0\n```\n",
),
},
),
DocDef(
DocDef {
name: "removeHelper",
symbol: `Dict.removeHelper`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Bucket",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U32",
parts: [],
},
Apply {
name: "List",
parts: [
Tuple {
elems: [
BoundVariable(
"k",
),
Wildcard,
],
extension: NoTypeAnn,
},
],
},
BoundVariable(
"k",
),
],
output: Tuple {
elems: [
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U32",
parts: [],
},
],
extension: NoTypeAnn,
},
},
implements: [
ImplementsClause {
name: "k",
abilities: [
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "update",
symbol: `Dict.update`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
BoundVariable(
"k",
),
Function {
args: [
TagUnion {
tags: [
Tag {
name: "Present",
values: [
BoundVariable(
"v",
),
],
},
Tag {
name: "Missing",
values: [],
},
],
extension: NoTypeAnn,
},
],
output: TagUnion {
tags: [
Tag {
name: "Present",
values: [
BoundVariable(
"v",
),
],
},
Tag {
name: "Missing",
values: [],
},
],
extension: NoTypeAnn,
},
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Insert or remove a value for a specified key. This function enables a\nperformance optimization for the use case of providing a default when a value\nis missing. This is more efficient than doing both a `Dict.get` and then a\n`Dict.insert` call, and supports being piped.\n```\nalterValue : [Present Bool, Missing] -> [Present Bool, Missing]\nalterValue = \\possibleValue ->\n when possibleValue is\n Missing -> Present Bool.false\n Present value -> if value then Missing else Present Bool.true\n\nexpect Dict.update (Dict.empty {}) \"a\" alterValue == Dict.single \"a\" Bool.false\nexpect Dict.update (Dict.single \"a\" Bool.false) \"a\" alterValue == Dict.single \"a\" Bool.true\nexpect Dict.update (Dict.single \"a\" Bool.true) \"a\" alterValue == Dict.empty {}\n```\n",
),
},
),
DocDef(
DocDef {
name: "toList",
symbol: `Dict.toList`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
],
output: Apply {
name: "List",
parts: [
Tuple {
elems: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
extension: NoTypeAnn,
},
],
},
},
docs: Some(
"Returns the keys and values of a dictionary as a [List].\nThis requires allocating a temporary list, prefer using [Dict.toList] or [Dict.walk] instead.\n```\nexpect\n Dict.single 1 \"One\"\n |> Dict.insert 2 \"Two\"\n |> Dict.insert 3 \"Three\"\n |> Dict.insert 4 \"Four\"\n |> Dict.toList\n |> Bool.isEq [(1, \"One\"), (2, \"Two\"), (3, \"Three\"), (4, \"Four\")]\n```\n",
),
},
),
DocDef(
DocDef {
name: "keys",
symbol: `Dict.keys`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Returns the keys of a dictionary as a [List].\nThis requires allocating a temporary [List], prefer using [Dict.toList] or [Dict.walk] instead.\n```\nexpect\n Dict.single 1 \"One\"\n |> Dict.insert 2 \"Two\"\n |> Dict.insert 3 \"Three\"\n |> Dict.insert 4 \"Four\"\n |> Dict.keys\n |> Bool.isEq [1,2,3,4]\n```\n",
),
},
),
DocDef(
DocDef {
name: "values",
symbol: `Dict.values`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Returns the values of a dictionary as a [List].\nThis requires allocating a temporary [List], prefer using [Dict.toList] or [Dict.walk] instead.\n```\nexpect\n Dict.single 1 \"One\"\n |> Dict.insert 2 \"Two\"\n |> Dict.insert 3 \"Three\"\n |> Dict.insert 4 \"Four\"\n |> Dict.values\n |> Bool.isEq [\"One\",\"Two\",\"Three\",\"Four\"]\n```\n",
),
},
),
DocDef(
DocDef {
name: "insertAll",
symbol: `Dict.insertAll`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Combine two dictionaries by keeping the [union](https://en.wikipedia.org/wiki/Union_(set_theory))\nof all the key-value pairs. This means that all the key-value pairs in\nboth dictionaries will be combined. Note that where there are pairs\nwith the same key, the value contained in the second input will be\nretained, and the value in the first input will be removed.\n```\nfirst =\n Dict.single 1 \"Not Me\"\n |> Dict.insert 2 \"And Me\"\n\nsecond =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 3 \"Me Too\"\n |> Dict.insert 4 \"And Also Me\"\n\nexpected =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 2 \"And Me\"\n |> Dict.insert 3 \"Me Too\"\n |> Dict.insert 4 \"And Also Me\"\n\nexpect\n Dict.insertAll first second == expected\n```\n",
),
},
),
DocDef(
DocDef {
name: "keepShared",
symbol: `Dict.keepShared`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
implements: [
ImplementsClause {
name: "v",
abilities: [
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: Some(
"Combine two dictionaries by keeping the [intersection](https://en.wikipedia.org/wiki/Intersection_(set_theory))\nof all the key-value pairs. This means that we keep only those pairs\nthat are in both dictionaries. Both the key and value must match to be kept.\n```\nfirst =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 2 \"And Me\"\n |> Dict.insert 3 \"Not this one\"\n\nsecond =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 2 \"And Me\"\n |> Dict.insert 3 \"This has a different value\"\n |> Dict.insert 4 \"Or Me\"\n\nexpected =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 2 \"And Me\"\n\nexpect Dict.keepShared first second == expected\n```\n",
),
},
),
DocDef(
DocDef {
name: "removeAll",
symbol: `Dict.removeAll`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: Some(
"Remove the key-value pairs in the first input that are also in the second\nusing the [set difference](https://en.wikipedia.org/wiki/Complement_(set_theory)#Relative_complement)\nof the values. This means that we will be left with only those pairs that\nare in the first dictionary and whose keys are not in the second.\n```\nfirst =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 2 \"And Me\"\n |> Dict.insert 3 \"Remove Me\"\n\nsecond =\n Dict.single 3 \"Remove Me\"\n |> Dict.insert 4 \"I do nothing...\"\n\nexpected =\n Dict.single 1 \"Keep Me\"\n |> Dict.insert 2 \"And Me\"\n\nexpect Dict.removeAll first second == expected\n```\n",
),
},
),
DocDef(
DocDef {
name: "Bucket",
symbol: `Dict.Bucket`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "find",
symbol: `Dict.find`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
BoundVariable(
"k",
),
],
output: Record {
fields: [
RecordField {
name: "bucketIndex",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "result",
type_annotation: Apply {
name: "Result",
parts: [
BoundVariable(
"v",
),
TagUnion {
tags: [
Tag {
name: "KeyNotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "findFirstUnroll",
symbol: `Dict.findFirstUnroll`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Bucket",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U32",
parts: [],
},
Apply {
name: "List",
parts: [
Tuple {
elems: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
extension: NoTypeAnn,
},
],
},
BoundVariable(
"k",
),
],
output: Record {
fields: [
RecordField {
name: "bucketIndex",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "result",
type_annotation: Apply {
name: "Result",
parts: [
BoundVariable(
"v",
),
TagUnion {
tags: [
Tag {
name: "KeyNotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
],
extension: NoTypeAnn,
},
},
implements: [
ImplementsClause {
name: "k",
abilities: [
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "findSecondUnroll",
symbol: `Dict.findSecondUnroll`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Bucket",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U32",
parts: [],
},
Apply {
name: "List",
parts: [
Tuple {
elems: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
extension: NoTypeAnn,
},
],
},
BoundVariable(
"k",
),
],
output: Record {
fields: [
RecordField {
name: "bucketIndex",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "result",
type_annotation: Apply {
name: "Result",
parts: [
BoundVariable(
"v",
),
TagUnion {
tags: [
Tag {
name: "KeyNotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
],
extension: NoTypeAnn,
},
},
implements: [
ImplementsClause {
name: "k",
abilities: [
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "findHelper",
symbol: `Dict.findHelper`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Bucket",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U32",
parts: [],
},
Apply {
name: "List",
parts: [
Tuple {
elems: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
extension: NoTypeAnn,
},
],
},
BoundVariable(
"k",
),
],
output: Record {
fields: [
RecordField {
name: "bucketIndex",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "result",
type_annotation: Apply {
name: "Result",
parts: [
BoundVariable(
"v",
),
TagUnion {
tags: [
Tag {
name: "KeyNotFound",
values: [],
},
],
extension: NoTypeAnn,
},
],
},
},
],
extension: NoTypeAnn,
},
},
implements: [
ImplementsClause {
name: "k",
abilities: [
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "removeBucket",
symbol: `Dict.removeBucket`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "scanForIndex",
symbol: `Dict.scanForIndex`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Bucket",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U32",
parts: [],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "removeBucketHelper",
symbol: `Dict.removeBucketHelper`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Bucket",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Tuple {
elems: [
Apply {
name: "List",
parts: [
Apply {
name: "Bucket",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "increaseSize",
symbol: `Dict.increaseSize`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
],
output: Apply {
name: "Dict",
parts: [
BoundVariable(
"k",
),
BoundVariable(
"v",
),
],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "allocBucketsFromShift",
symbol: `Dict.allocBucketsFromShift`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U8",
parts: [],
},
Apply {
name: "F32",
parts: [],
},
],
output: Tuple {
elems: [
Apply {
name: "List",
parts: [
Apply {
name: "Bucket",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "calcShiftsForSize",
symbol: `Dict.calcShiftsForSize`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
Apply {
name: "F32",
parts: [],
},
],
output: Apply {
name: "U8",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "nextWhileLess",
symbol: `Dict.nextWhileLess`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "Bucket",
parts: [],
},
],
},
BoundVariable(
"k",
),
Apply {
name: "U8",
parts: [],
},
],
output: Tuple {
elems: [
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U32",
parts: [],
},
],
extension: NoTypeAnn,
},
},
implements: [
ImplementsClause {
name: "k",
abilities: [
Apply {
name: "Hash",
parts: [],
},
Apply {
name: "Eq",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "distAndFingerprintFromHash",
symbol: `Dict.distAndFingerprintFromHash`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "U32",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "bucketIndexFromHash",
symbol: `Dict.bucketIndexFromHash`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U8",
parts: [],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "BadKey",
symbol: `Dict.BadKey`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "hashBadKey",
symbol: `Dict.hashBadKey`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"hasher",
),
Apply {
name: "BadKey",
parts: [],
},
],
output: BoundVariable(
"hasher",
),
},
implements: [
ImplementsClause {
name: "hasher",
abilities: [
Apply {
name: "Hasher",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "listGetUnsafe",
symbol: `Dict.listGetUnsafe`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"a",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: BoundVariable(
"a",
),
},
docs: None,
},
),
DocDef(
DocDef {
name: "LowLevelHasher",
symbol: `Dict.LowLevelHasher`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: None,
},
),
DocDef(
DocDef {
name: "pseudoSeed",
symbol: `Dict.pseudoSeed`,
type_vars: [],
type_annotation: Function {
args: [
Record {
fields: [],
extension: NoTypeAnn,
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "createLowLevelHasher",
symbol: `Dict.createLowLevelHasher`,
type_vars: [],
type_annotation: Function {
args: [
TagUnion {
tags: [
Tag {
name: "PseudoRandSeed",
values: [],
},
Tag {
name: "WithSeed",
values: [
Apply {
name: "U64",
parts: [],
},
],
},
],
extension: NoTypeAnn,
},
],
output: Apply {
name: "LowLevelHasher",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "combineState",
symbol: `Dict.combineState`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "LowLevelHasher",
parts: [],
},
Record {
fields: [
RecordField {
name: "a",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "b",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "seed",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "length",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
],
extension: NoTypeAnn,
},
],
output: Apply {
name: "LowLevelHasher",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "addBytes",
symbol: `Dict.addBytes`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "LowLevelHasher",
parts: [],
},
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
],
output: Apply {
name: "LowLevelHasher",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "hashBytesHelper48",
symbol: `Dict.hashBytesHelper48`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Record {
fields: [
RecordField {
name: "a",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "b",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "seed",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "hashBytesHelper16",
symbol: `Dict.hashBytesHelper16`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Record {
fields: [
RecordField {
name: "a",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "b",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "seed",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "wyp0",
symbol: `Dict.wyp0`,
type_vars: [],
type_annotation: Apply {
name: "U64",
parts: [],
},
docs: None,
},
),
DocDef(
DocDef {
name: "wyp1",
symbol: `Dict.wyp1`,
type_vars: [],
type_annotation: Apply {
name: "U64",
parts: [],
},
docs: None,
},
),
DocDef(
DocDef {
name: "wyp2",
symbol: `Dict.wyp2`,
type_vars: [],
type_annotation: Apply {
name: "U64",
parts: [],
},
docs: None,
},
),
DocDef(
DocDef {
name: "wyp3",
symbol: `Dict.wyp3`,
type_vars: [],
type_annotation: Apply {
name: "U64",
parts: [],
},
docs: None,
},
),
DocDef(
DocDef {
name: "wymix",
symbol: `Dict.wymix`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "wymum",
symbol: `Dict.wymum`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Record {
fields: [
RecordField {
name: "lower",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
RecordField {
name: "upper",
type_annotation: Apply {
name: "U64",
parts: [],
},
},
],
extension: NoTypeAnn,
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "wyr8",
symbol: `Dict.wyr8`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "wyr4",
symbol: `Dict.wyr4`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "wyr3",
symbol: `Dict.wyr3`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
Apply {
name: "U8",
parts: [],
},
],
},
Apply {
name: "U64",
parts: [],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: None,
},
),
],
scope: Scope {
aliases: VecMap {
keys: [
`Num.Binary32`,
`Num.F32`,
`Num.FloatingPoint`,
`Str.Utf8ByteProblem`,
`Inspect.Inspector`,
`Inspect.IdentId(34)`,
`Num.Unsigned16`,
`Num.U16`,
`Bool.Bool`,
`Num.U64`,
`Num.Binary64`,
`Num.Int`,
`Num.Signed128`,
`Inspect.ElemWalker`,
`Num.Unsigned8`,
`Num.Frac`,
`Num.U32`,
`Num.Signed64`,
`Num.Signed8`,
`Num.I64`,
`Num.U8`,
`Num.I16`,
`Result.Result`,
`Num.Unsigned128`,
`Num.I8`,
`Num.Num`,
`Num.Decimal`,
`Str.Utf8Problem`,
`Inspect.KeyValWalker`,
`Num.Unsigned32`,
`Num.Signed32`,
`Num.Integer`,
`Num.I128`,
`Num.U128`,
`Num.I32`,
`Num.Signed16`,
`Num.Unsigned64`,
`Num.F64`,
`Num.Dec`,
`Str.IdentId(49)`,
`Dict.Dict`,
`Dict.Bucket`,
`Dict.BadKey`,
`Dict.LowLevelHasher`,
],
values: [
Alias {
region: @17634-17642,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19444-19447,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17650-17669,
type_variables: [
@17664-17669 AliasVar {
name: 'range',
var: 67,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <67>,
kind: Opaque,
},
Alias {
region: @26725-26740,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<63>,
kind: Structural,
},
Alias {
region: @3006-3017,
type_variables: [
@3016-3017 AliasVar {
name: 'f',
var: 74,
opt_bound_abilities: Some(
AbilitySet(
[
`Inspect.InspectFormatter`,
],
),
),
},
],
lambda_set_variables: [
LambdaSet(
<75>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn(<74> |<75>| -> <74>),
kind: Opaque,
},
Alias {
region: @3808-3820,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'data' : RigidRequired((`Str.Str`)) },
kind: Opaque,
},
Alias {
region: @17202-17212,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17544-17547,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @1780-1784,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: ['False', 'True'],
kind: Opaque,
},
Alias {
region: @17482-17485,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17619-17627,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @12895-12904,
type_variables: [
@12899-12904 AliasVar {
name: 'range',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` <64>[ but actually <64> ])[ but actually (Alias `Num.Integer` <64>[ but actually <64> ]) ]),
kind: Structural,
},
Alias {
region: @17074-17083,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @802-834,
type_variables: [
@813-818 AliasVar {
name: 'state',
var: 70,
opt_bound_abilities: None,
},
@819-829 AliasVar {
name: 'collection',
var: 69,
opt_bound_abilities: None,
},
@830-834 AliasVar {
name: 'elem',
var: 71,
opt_bound_abilities: None,
},
],
lambda_set_variables: [
LambdaSet(
<72>,
),
LambdaSet(
<73>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn(<69>, <70>, Fn(<70>, <71> |<72>| -> <70>) |<73>| -> <70>),
kind: Structural,
},
Alias {
region: @17219-17228,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17034-17044,
type_variables: [
@17039-17044 AliasVar {
name: 'range',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` <65>[ but actually <65> ])[ but actually (Alias `Num.FloatingPoint` <65>[ but actually <65> ]) ]),
kind: Structural,
},
Alias {
region: @17513-17516,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17090-17098,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17135-17142,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17291-17294,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17575-17577,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17349-17352,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @241-254,
type_variables: [
@248-250 AliasVar {
name: 'ok',
var: 64,
opt_bound_abilities: None,
},
@251-254 AliasVar {
name: 'err',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['Err' <65>, 'Ok' <64>]<63>,
kind: Structural,
},
Alias {
region: @17150-17161,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17431-17433,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Int` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ]) ]) ]),
kind: Structural,
},
Alias {
region: @5228-5237,
type_variables: [
@5232-5237 AliasVar {
name: 'range',
var: 63,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <63>,
kind: Opaque,
},
Alias {
region: @17605-17612,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @26896-26907,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
64,
],
recursion_variables: {},
typ: { 'problem' : RigidRequired((Alias `Str.Utf8ByteProblem`[ but actually ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<64> ]))'byteIndex' : RigidRequired((DelayedAlias `Num.U64`)), },
kind: Structural,
},
Alias {
region: @707-744,
type_variables: [
@720-725 AliasVar {
name: 'state',
var: 64,
opt_bound_abilities: None,
},
@726-736 AliasVar {
name: 'collection',
var: 63,
opt_bound_abilities: None,
},
@737-740 AliasVar {
name: 'key',
var: 65,
opt_bound_abilities: None,
},
@741-744 AliasVar {
name: 'val',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [
LambdaSet(
<67>,
),
LambdaSet(
<68>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn(<63>, <64>, Fn(<64>, <65>, <66> |<67>| -> <64>) |<68>| -> <64>),
kind: Structural,
},
Alias {
region: @17185-17195,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17105-17113,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17236-17249,
type_variables: [
@17244-17249 AliasVar {
name: 'range',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <66>,
kind: Opaque,
},
Alias {
region: @17260-17264,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17449-17453,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17320-17323,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17120-17128,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17168-17178,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19085-19088,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @23363-23366,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @35465-35479,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
65,
],
recursion_variables: {},
typ: { 'dProblemCode' : RigidRequired((Alias `Str.Utf8ByteProblem`[ but actually ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<65> ]))'cIsOk' : RigidRequired((DelayedAlias `Bool.Bool`)), 'aByteIndex' : RigidRequired((DelayedAlias `Num.U64`)), 'bString' : RigidRequired((`Str.Str`)), },
kind: Structural,
},
Alias {
region: @3079-3087,
type_variables: [
@3084-3085 AliasVar {
name: 'k',
var: 63,
opt_bound_abilities: Some(
AbilitySet(
[
`Hash.Hash`,
`Bool.Eq`,
],
),
),
},
@3086-3087 AliasVar {
name: 'v',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'buckets' : RigidRequired((`List.List` @3112-3118 (Alias `Dict.Bucket`[ but actually { 'distAndFingerprint' : RigidRequired((DelayedAlias `Num.U32`))'dataIndex' : RigidRequired((DelayedAlias `Num.U32`)), } ])))'shifts' : RigidRequired((DelayedAlias `Num.U8`)), 'maxBucketCapacity' : RigidRequired((DelayedAlias `Num.U64`)), 'maxLoadFactor' : RigidRequired((DelayedAlias `Num.F32`)), 'data' : RigidRequired((`List.List` @3136-3142 ( <63><64>, ))), },
kind: Opaque,
},
Alias {
region: @25758-25764,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'distAndFingerprint' : RigidRequired((DelayedAlias `Num.U32`))'dataIndex' : RigidRequired((DelayedAlias `Num.U32`)), },
kind: Structural,
},
Alias {
region: @40231-40237,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (DelayedAlias `Num.U64`),
kind: Opaque,
},
Alias {
region: @41841-41855,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'state' : RigidRequired((DelayedAlias `Num.U64`))'initializedSeed' : RigidRequired((DelayedAlias `Num.U64`)), },
kind: Opaque,
},
],
},
abilities_store: IAbilitiesStore {
members_of_ability: {
`Hash.Hasher`: [
`Hash.addBytes`,
`Hash.addU8`,
`Hash.addU16`,
`Hash.addU32`,
`Hash.addU64`,
`Hash.addU128`,
`Hash.complete`,
],
`Inspect.Inspect`: [
`Inspect.toInspector`,
],
`Inspect.InspectFormatter`: [
`Inspect.init`,
`Inspect.tag`,
`Inspect.tuple`,
`Inspect.record`,
`Inspect.bool`,
`Inspect.str`,
`Inspect.list`,
`Inspect.set`,
`Inspect.dict`,
`Inspect.opaque`,
`Inspect.function`,
`Inspect.u8`,
`Inspect.i8`,
`Inspect.u16`,
`Inspect.i16`,
`Inspect.u32`,
`Inspect.i32`,
`Inspect.u64`,
`Inspect.i64`,
`Inspect.u128`,
`Inspect.i128`,
`Inspect.f32`,
`Inspect.f64`,
`Inspect.dec`,
],
`Bool.Eq`: [
`Bool.isEq`,
],
`Hash.Hash`: [
`Hash.hash`,
],
},
specialization_to_root: {
`Inspect.IdentId(55)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i128`,
},
`Inspect.IdentId(45)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.function`,
},
`Inspect.IdentId(42)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.bool`,
},
`Dict.addU16`: ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.addU16`,
},
`Inspect.IdentId(44)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.opaque`,
},
`Inspect.IdentId(58)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.dec`,
},
`Inspect.IdentId(46)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u8`,
},
`Dict.hashBadKey`: ImplKey {
opaque: `Dict.BadKey`,
ability_member: `Hash.hash`,
},
`Inspect.IdentId(56)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.f32`,
},
`Inspect.IdentId(53)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i64`,
},
`Dict.toInspectorDict`: ImplKey {
opaque: `Dict.Dict`,
ability_member: `Inspect.toInspector`,
},
`Inspect.IdentId(43)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.str`,
},
`Inspect.IdentId(52)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u64`,
},
`Inspect.IdentId(51)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i32`,
},
`Inspect.IdentId(39)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.tag`,
},
`Inspect.IdentId(40)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.tuple`,
},
`Inspect.IdentId(49)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i16`,
},
`Dict.addU8`: ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.addU8`,
},
`Inspect.IdentId(35)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.init`,
},
`Dict.addU32`: ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.addU32`,
},
`Inspect.IdentId(57)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.f64`,
},
`Inspect.IdentId(54)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u128`,
},
`Inspect.IdentId(41)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.record`,
},
`Dict.hashDict`: ImplKey {
opaque: `Dict.Dict`,
ability_member: `Hash.hash`,
},
`Inspect.IdentId(50)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u32`,
},
`Dict.addBytes`: ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.addBytes`,
},
`Dict.addU64`: ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.addU64`,
},
`Inspect.IdentId(38)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.dict`,
},
`Bool.boolIsEq`: ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
},
`Inspect.IdentId(37)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.set`,
},
`Inspect.IdentId(47)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i8`,
},
`Dict.#BadKey_isEq`: ImplKey {
opaque: `Dict.BadKey`,
ability_member: `Bool.isEq`,
},
`Dict.addU128`: ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.addU128`,
},
`Inspect.IdentId(48)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u16`,
},
`Dict.complete`: ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.complete`,
},
`Inspect.IdentId(36)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.list`,
},
`Dict.isEq`: ImplKey {
opaque: `Dict.Dict`,
ability_member: `Bool.isEq`,
},
},
ability_members: {
`Inspect.i16`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2355-2358,
typ: Imported,
},
`Bool.isEq`: AbilityMemberData {
parent_ability: `Bool.Eq`,
region: @1635-1639,
typ: Imported,
},
`Hash.addU128`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1614-1621,
typ: Imported,
},
`Inspect.function`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2095-2103,
typ: Imported,
},
`Inspect.set`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1499-1502,
typ: Imported,
},
`Inspect.f32`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2814-2817,
typ: Imported,
},
`Inspect.i8`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2227-2229,
typ: Imported,
},
`Inspect.u64`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2550-2553,
typ: Imported,
},
`Inspect.i32`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2485-2488,
typ: Imported,
},
`Inspect.u128`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2680-2684,
typ: Imported,
},
`Inspect.tag`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @977-980,
typ: Imported,
},
`Inspect.opaque`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1880-1886,
typ: Imported,
},
`Inspect.u32`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2420-2423,
typ: Imported,
},
`Inspect.u8`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2164-2166,
typ: Imported,
},
`Inspect.i128`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2747-2751,
typ: Imported,
},
`Inspect.dict`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1614-1618,
typ: Imported,
},
`Inspect.list`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1381-1385,
typ: Imported,
},
`Inspect.init`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @921-925,
typ: Imported,
},
`Hash.addU32`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1429-1435,
typ: Imported,
},
`Inspect.toInspector`: AbilityMemberData {
parent_ability: `Inspect.Inspect`,
region: @3291-3302,
typ: Imported,
},
`Inspect.f64`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2879-2882,
typ: Imported,
},
`Hash.addU8`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1247-1252,
typ: Imported,
},
`Hash.addU16`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1337-1343,
typ: Imported,
},
`Hash.addU64`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1521-1527,
typ: Imported,
},
`Inspect.str`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1315-1318,
typ: Imported,
},
`Inspect.dec`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2944-2947,
typ: Imported,
},
`Hash.hash`: AbilityMemberData {
parent_ability: `Hash.Hash`,
region: @742-746,
typ: Imported,
},
`Inspect.bool`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1248-1252,
typ: Imported,
},
`Inspect.u16`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2290-2293,
typ: Imported,
},
`Inspect.record`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1144-1150,
typ: Imported,
},
`Inspect.i64`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2615-2618,
typ: Imported,
},
`Inspect.tuple`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1062-1067,
typ: Imported,
},
`Hash.complete`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1761-1769,
typ: Imported,
},
`Hash.addBytes`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1150-1158,
typ: Imported,
},
},
declared_implementations: {
ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
}: Impl(
`Bool.boolIsEq`,
),
ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.addBytes`,
}: Impl(
`Dict.addBytes`,
),
ImplKey {
opaque: `Dict.Dict`,
ability_member: `Inspect.toInspector`,
}: Impl(
`Dict.toInspectorDict`,
),
ImplKey {
opaque: `Dict.Dict`,
ability_member: `Bool.isEq`,
}: Impl(
`Dict.isEq`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.f64`,
}: Impl(
`Inspect.IdentId(57)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i32`,
}: Impl(
`Inspect.IdentId(51)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i64`,
}: Impl(
`Inspect.IdentId(53)`,
),
ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.addU128`,
}: Impl(
`Dict.addU128`,
),
ImplKey {
opaque: `Dict.BadKey`,
ability_member: `Bool.isEq`,
}: Impl(
`Dict.#BadKey_isEq`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.tuple`,
}: Impl(
`Inspect.IdentId(40)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.list`,
}: Impl(
`Inspect.IdentId(36)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.set`,
}: Impl(
`Inspect.IdentId(37)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i8`,
}: Impl(
`Inspect.IdentId(47)`,
),
ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.addU32`,
}: Impl(
`Dict.addU32`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i16`,
}: Impl(
`Inspect.IdentId(49)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u16`,
}: Impl(
`Inspect.IdentId(48)`,
),
ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.addU64`,
}: Impl(
`Dict.addU64`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.str`,
}: Impl(
`Inspect.IdentId(43)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u32`,
}: Impl(
`Inspect.IdentId(50)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.function`,
}: Impl(
`Inspect.IdentId(45)`,
),
ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.addU16`,
}: Impl(
`Dict.addU16`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.dec`,
}: Impl(
`Inspect.IdentId(58)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.init`,
}: Impl(
`Inspect.IdentId(35)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.bool`,
}: Impl(
`Inspect.IdentId(42)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.opaque`,
}: Impl(
`Inspect.IdentId(44)`,
),
ImplKey {
opaque: `Dict.Dict`,
ability_member: `Hash.hash`,
}: Impl(
`Dict.hashDict`,
),
ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.addU8`,
}: Impl(
`Dict.addU8`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u64`,
}: Impl(
`Inspect.IdentId(52)`,
),
ImplKey {
opaque: `Dict.LowLevelHasher`,
ability_member: `Hash.complete`,
}: Impl(
`Dict.complete`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.tag`,
}: Impl(
`Inspect.IdentId(39)`,
),
ImplKey {
opaque: `Dict.BadKey`,
ability_member: `Hash.hash`,
}: Impl(
`Dict.hashBadKey`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.dict`,
}: Impl(
`Inspect.IdentId(38)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u8`,
}: Impl(
`Inspect.IdentId(46)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.f32`,
}: Impl(
`Inspect.IdentId(56)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i128`,
}: Impl(
`Inspect.IdentId(55)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u128`,
}: Impl(
`Inspect.IdentId(54)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.record`,
}: Impl(
`Inspect.IdentId(41)`,
),
},
specializations: {},
next_specialization_id: 82,
resolved_specializations: {},
},
home: Dict,
exposed_ident_count: 31,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "U8",
},
),
`Num.U8`,
@633-635,
),
(
Ident(
IdentStr {
string: "Result",
},
),
`Result.Result`,
@567-573,
),
(
Ident(
IdentStr {
string: "Eq",
},
),
`Bool.Eq`,
@544-546,
),
(
Ident(
IdentStr {
string: "Hash",
},
),
`Hash.Hash`,
@666-670,
),
(
Ident(
IdentStr {
string: "I8",
},
),
`Num.I8`,
@637-639,
),
(
Ident(
IdentStr {
string: "U64",
},
),
`Num.U64`,
@618-621,
),
(
Ident(
IdentStr {
string: "Hasher",
},
),
`Hash.Hasher`,
@658-664,
),
(
Ident(
IdentStr {
string: "Bool",
},
),
`Bool.Bool`,
@538-542,
),
(
Ident(
IdentStr {
string: "InspectFormatter",
},
),
`Inspect.InspectFormatter`,
@712-728,
),
(
Ident(
IdentStr {
string: "Inspector",
},
),
`Inspect.Inspector`,
@701-710,
),
(
Ident(
IdentStr {
string: "F32",
},
),
`Num.F32`,
@623-626,
),
(
Ident(
IdentStr {
string: "Inspect",
},
),
`Inspect.Inspect`,
@692-699,
),
(
Ident(
IdentStr {
string: "U32",
},
),
`Num.U32`,
@628-631,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
68,
105,
99,
116,
101,
109,
112,
116,
121,
115,
105,
110,
103,
108,
101,
99,
108,
101,
97,
114,
108,
101,
110,
103,
101,
116,
35,
103,
101,
116,
95,
114,
101,
115,
117,
108,
116,
99,
111,
110,
116,
97,
105,
110,
115,
105,
110,
115,
101,
114,
116,
114,
101,
109,
111,
118,
101,
119,
97,
108,
107,
119,
97,
108,
107,
85,
110,
116,
105,
108,
102,
114,
111,
109,
76,
105,
115,
116,
116,
111,
76,
105,
115,
116,
107,
101,
121,
115,
118,
97,
108,
117,
101,
115,
105,
110,
115,
101,
114,
116,
65,
108,
108,
107,
101,
101,
112,
83,
104,
97,
114,
101,
100,
114,
101,
109,
111,
118,
101,
65,
108,
108,
119,
105,
116,
104,
67,
97,
112,
97,
99,
105,
116,
121,
99,
97,
112,
97,
99,
105,
116,
121,
117,
112,
100,
97,
116,
101,
108,
105,
115,
116,
71,
101,
116,
85,
110,
115,
97,
102,
101,
112,
115,
101,
117,
100,
111,
83,
101,
101,
100,
105,
115,
69,
109,
112,
116,
121,
109,
97,
112,
106,
111,
105,
110,
77,
97,
112,
107,
101,
101,
112,
73,
102,
100,
114,
111,
112,
73,
102,
114,
101,
115,
101,
114,
118,
101,
114,
101,
108,
101,
97,
115,
101,
69,
120,
99,
101,
115,
115,
67,
97,
112,
97,
99,
105,
116,
121,
66,
117,
99,
107,
101,
116,
66,
97,
100,
75,
101,
121,
76,
111,
119,
76,
101,
118,
101,
108,
72,
97,
115,
104,
101,
114,
105,
115,
69,
113,
104,
97,
115,
104,
68,
105,
99,
116,
116,
111,
73,
110,
115,
112,
101,
99,
116,
111,
114,
68,
105,
99,
116,
107,
101,
101,
112,
73,
102,
72,
101,
108,
112,
105,
110,
115,
101,
114,
116,
72,
101,
108,
112,
101,
114,
114,
101,
109,
111,
118,
101,
72,
101,
108,
112,
101,
114,
99,
105,
114,
99,
117,
108,
97,
114,
68,
105,
115,
116,
101,
109,
112,
116,
121,
66,
117,
99,
107,
101,
116,
100,
105,
115,
116,
73,
110,
99,
102,
105,
110,
103,
101,
114,
112,
114,
105,
110,
116,
77,
97,
115,
107,
100,
101,
102,
97,
117,
108,
116,
77,
97,
120,
76,
111,
97,
100,
70,
97,
99,
116,
111,
114,
105,
110,
105,
116,
105,
97,
108,
83,
104,
105,
102,
116,
115,
109,
97,
120,
83,
105,
122,
101,
109,
97,
120,
66,
117,
99,
107,
101,
116,
67,
111,
117,
110,
116,
105,
110,
99,
114,
101,
109,
101,
110,
116,
68,
105,
115,
116,
105,
110,
99,
114,
101,
109,
101,
110,
116,
68,
105,
115,
116,
78,
100,
101,
99,
114,
101,
109,
101,
110,
116,
68,
105,
115,
116,
102,
105,
110,
100,
102,
105,
110,
100,
77,
97,
110,
117,
97,
108,
85,
110,
114,
111,
108,
108,
115,
102,
105,
110,
100,
70,
105,
114,
115,
116,
85,
110,
114,
111,
108,
108,
102,
105,
110,
100,
83,
101,
99,
111,
110,
100,
85,
110,
114,
111,
108,
108,
102,
105,
110,
100,
72,
101,
108,
112,
101,
114,
114,
101,
109,
111,
118,
101,
66,
117,
99,
107,
101,
116,
115,
99,
97,
110,
70,
111,
114,
73,
110,
100,
101,
120,
114,
101,
109,
111,
118,
101,
66,
117,
99,
107,
101,
116,
72,
101,
108,
112,
101,
114,
105,
110,
99,
114,
101,
97,
115,
101,
83,
105,
122,
101,
97,
108,
108,
111,
99,
66,
117,
99,
107,
101,
116,
115,
70,
114,
111,
109,
83,
104,
105,
102,
116,
99,
97,
108,
99,
83,
104,
105,
102,
116,
115,
70,
111,
114,
83,
105,
122,
101,
99,
97,
108,
99,
83,
104,
105,
102,
116,
115,
70,
111,
114,
83,
105,
122,
101,
72,
101,
108,
112,
101,
114,
99,
97,
108,
99,
78,
117,
109,
66,
117,
99,
107,
101,
116,
115,
102,
105,
108,
108,
66,
117,
99,
107,
101,
116,
115,
70,
114,
111,
109,
68,
97,
116,
97,
110,
101,
120,
116,
87,
104,
105,
108,
101,
76,
101,
115,
115,
110,
101,
120,
116,
87,
104,
105,
108,
101,
76,
101,
115,
115,
72,
101,
108,
112,
101,
114,
112,
108,
97,
99,
101,
65,
110,
100,
83,
104,
105,
102,
116,
85,
112,
110,
101,
120,
116,
66,
117,
99,
107,
101,
116,
73,
110,
100,
101,
120,
104,
97,
115,
104,
75,
101,
121,
100,
105,
115,
116,
65,
110,
100,
70,
105,
110,
103,
101,
114,
112,
114,
105,
110,
116,
70,
114,
111,
109,
72,
97,
115,
104,
98,
117,
99,
107,
101,
116,
73,
110,
100,
101,
120,
70,
114,
111,
109,
72,
97,
115,
104,
104,
97,
115,
104,
66,
97,
100,
75,
101,
121,
99,
114,
101,
97,
116,
101,
76,
111,
119,
76,
101,
118,
101,
108,
72,
97,
115,
104,
101,
114,
99,
111,
109,
98,
105,
110,
101,
83,
116,
97,
116,
101,
105,
110,
105,
116,
83,
101,
101,
100,
99,
111,
109,
112,
108,
101,
116,
101,
97,
100,
100,
85,
56,
97,
100,
100,
85,
49,
54,
97,
100,
100,
85,
51,
50,
97,
100,
100,
85,
54,
52,
97,
100,
100,
85,
49,
50,
56,
97,
100,
100,
66,
121,
116,
101,
115,
104,
97,
115,
104,
66,
121,
116,
101,
115,
72,
101,
108,
112,
101,
114,
52,
56,
104,
97,
115,
104,
66,
121,
116,
101,
115,
72,
101,
108,
112,
101,
114,
49,
54,
119,
121,
112,
48,
119,
121,
112,
49,
119,
121,
112,
50,
119,
121,
112,
51,
119,
121,
109,
105,
120,
119,
121,
109,
117,
109,
119,
121,
114,
56,
119,
121,
114,
52,
119,
121,
114,
51,
116,
101,
115,
116,
83,
101,
101,
100,
69,
113,
72,
97,
115,
104,
76,
105,
115,
116,
66,
117,
99,
107,
101,
116,
76,
105,
115,
116,
85,
54,
52,
70,
51,
50,
85,
56,
85,
51,
50,
85,
51,
50,
85,
54,
52,
85,
54,
52,
85,
54,
52,
35,
66,
97,
100,
75,
101,
121,
95,
105,
115,
69,
113,
120,
115,
121,
115,
49,
49,
49,
107,
120,
86,
97,
108,
121,
86,
97,
108,
49,
49,
53,
49,
49,
54,
104,
97,
115,
104,
101,
114,
100,
105,
99,
116,
49,
50,
48,
102,
109,
116,
114,
101,
113,
117,
101,
115,
116,
101,
100,
98,
117,
99,
107,
101,
116,
115,
100,
97,
116,
97,
109,
97,
120,
66,
117,
99,
107,
101,
116,
67,
97,
112,
97,
99,
105,
116,
121,
111,
114,
105,
103,
105,
110,
97,
108,
77,
97,
120,
66,
117,
99,
107,
101,
116,
67,
97,
112,
97,
99,
105,
116,
121,
109,
97,
120,
76,
111,
97,
100,
70,
97,
99,
116,
111,
114,
115,
104,
105,
102,
116,
115,
99,
117,
114,
114,
101,
110,
116,
83,
105,
122,
101,
114,
101,
113,
117,
101,
115,
116,
101,
100,
83,
105,
122,
101,
115,
105,
122,
101,
114,
101,
113,
117,
101,
115,
116,
101,
100,
83,
104,
105,
102,
116,
115,
98,
117,
99,
107,
101,
116,
115,
48,
98,
117,
99,
107,
101,
116,
115,
49,
109,
97,
120,
66,
117,
99,
107,
101,
116,
67,
97,
112,
97,
99,
105,
116,
121,
109,
105,
110,
83,
104,
105,
102,
116,
115,
118,
49,
53,
50,
49,
54,
51,
116,
114,
97,
110,
115,
102,
111,
114,
109,
105,
110,
105,
116,
49,
54,
55,
97,
110,
115,
119,
101,
114,
49,
55,
52,
105,
110,
105,
116,
105,
97,
108,
83,
116,
97,
116,
101,
49,
56,
49,
115,
116,
97,
116,
101,
49,
56,
56,
112,
114,
101,
100,
105,
99,
97,
116,
101,
105,
110,
100,
101,
120,
108,
101,
110,
103,
116,
104,
107,
101,
121,
118,
97,
108,
117,
101,
50,
48,
50,
101,
50,
48,
54,
50,
48,
57,
104,
97,
115,
104,
100,
105,
115,
116,
65,
110,
100,
70,
105,
110,
103,
101,
114,
112,
114,
105,
110,
116,
98,
117,
99,
107,
101,
116,
73,
110,
100,
101,
120,
100,
97,
116,
97,
48,
98,
117,
99,
107,
101,
116,
73,
110,
100,
101,
120,
48,
100,
105,
115,
116,
65,
110,
100,
70,
105,
110,
103,
101,
114,
112,
114,
105,
110,
116,
48,
108,
111,
97,
100,
101,
100,
102,
111,
117,
110,
100,
75,
101,
121,
100,
97,
116,
97,
49,
98,
117,
99,
107,
101,
116,
73,
110,
100,
101,
120,
49,
100,
105,
115,
116,
65,
110,
100,
70,
105,
110,
103,
101,
114,
112,
114,
105,
110,
116,
49,
100,
97,
116,
97,
73,
110,
100,
101,
120,
98,
117,
99,
107,
101,
116,
97,
108,
116,
101,
114,
114,
101,
115,
117,
108,
116,
50,
54,
56,
110,
101,
119,
86,
97,
108,
117,
101,
110,
101,
119,
68,
97,
116,
97,
50,
55,
50,
98,
97,
115,
101,
68,
105,
115,
116,
65,
110,
100,
70,
105,
110,
103,
101,
114,
112,
114,
105,
110,
116,
98,
97,
115,
101,
66,
117,
99,
107,
101,
116,
73,
110,
100,
101,
120,
100,
105,
115,
116,
115,
116,
97,
114,
116,
101,
110,
100,
99,
111,
114,
114,
101,
99,
116,
105,
111,
110,
50,
56,
53,
50,
56,
56,
120,
115,
48,
121,
115,
48,
120,
115,
49,
121,
115,
49,
50,
57,
54,
121,
118,
51,
48,
51,
110,
51,
49,
55,
51,
49,
56,
51,
50,
55,
51,
51,
54,
51,
52,
53,
51,
52,
54,
51,
52,
55,
98,
117,
99,
107,
101,
116,
115,
100,
97,
116,
97,
100,
97,
116,
97,
73,
110,
100,
101,
120,
84,
111,
82,
101,
109,
111,
118,
101,
100,
97,
116,
97,
73,
110,
100,
101,
120,
84,
111,
82,
101,
109,
111,
118,
101,
85,
54,
52,
98,
117,
99,
107,
101,
116,
115,
50,
108,
97,
115,
116,
68,
97,
116,
97,
73,
110,
100,
101,
120,
98,
117,
99,
107,
101,
116,
73,
110,
100,
101,
120,
50,
98,
117,
99,
107,
101,
116,
73,
110,
100,
101,
120,
51,
115,
119,
97,
112,
66,
117,
99,
107,
101,
116,
110,
101,
120,
116,
73,
110,
100,
101,
120,
110,
101,
120,
116,
66,
117,
99,
107,
101,
116,
110,
101,
119,
83,
104,
105,
102,
116,
115,
110,
101,
119,
77,
97,
120,
66,
117,
99,
107,
101,
116,
67,
97,
112,
97,
99,
105,
116,
121,
98,
117,
99,
107,
101,
116,
67,
111,
117,
110,
116,
51,
57,
56,
109,
97,
120,
66,
117,
99,
107,
101,
116,
115,
52,
50,
50,
115,
101,
101,
100,
79,
112,
116,
115,
101,
101,
100,
115,
105,
110,
105,
116,
105,
97,
108,
105,
122,
101,
100,
83,
101,
101,
100,
97,
98,
109,
117,
109,
110,
101,
120,
116,
97,
110,
101,
120,
116,
98,
117,
56,
112,
48,
117,
49,
54,
112,
49,
117,
51,
50,
117,
54,
52,
117,
49,
50,
56,
108,
111,
119,
101,
114,
117,
112,
112,
101,
114,
112,
50,
112,
51,
108,
105,
115,
116,
97,
98,
115,
120,
115,
101,
101,
49,
115,
101,
101,
50,
114,
101,
109,
97,
105,
110,
105,
110,
103,
110,
101,
119,
83,
101,
101,
100,
110,
101,
119,
83,
101,
101,
49,
110,
101,
119,
83,
101,
101,
50,
110,
101,
119,
82,
101,
109,
97,
105,
110,
105,
110,
103,
110,
101,
119,
73,
110,
100,
101,
120,
102,
105,
110,
97,
108,
83,
101,
101,
100,
114,
112,
52,
112,
53,
112,
54,
112,
55,
112,
56,
99,
100,
53,
52,
52,
35,
112,
97,
121,
108,
111,
97,
100,
49,
35,
112,
97,
121,
108,
111,
97,
100,
50,
118,
97,
108,
53,
52,
56,
100,
105,
99,
116,
49,
100,
105,
99,
116,
50,
105,
110,
110,
101,
114,
49,
105,
110,
110,
101,
114,
50,
111,
117,
116,
101,
114,
53,
53,
54,
111,
117,
116,
101,
114,
49,
111,
117,
116,
101,
114,
50,
53,
54,
50,
53,
54,
52,
53,
54,
53,
53,
55,
49,
53,
55,
50,
53,
55,
51,
53,
55,
52,
53,
55,
53,
53,
55,
54,
53,
55,
55,
53,
55,
56,
53,
55,
57,
53,
56,
48,
53,
56,
49,
53,
56,
50,
53,
56,
53,
53,
56,
54,
53,
56,
55,
53,
56,
56,
53,
56,
57,
53,
57,
48,
53,
57,
49,
53,
57,
50,
53,
57,
51,
53,
57,
52,
53,
57,
53,
53,
57,
54,
53,
57,
55,
98,
97,
100,
75,
101,
121,
115,
97,
108,
108,
73,
110,
115,
101,
114,
116,
101,
100,
67,
111,
114,
114,
101,
99,
116,
108,
121,
54,
48,
49,
97,
99,
99,
54,
48,
52,
112,
54,
48,
55,
54,
48,
56,
54,
48,
57,
104,
97,
115,
104,
49,
104,
97,
115,
104,
50,
54,
51,
52,
97,
103,
101,
54,
51,
54,
54,
51,
55,
100,
49,
100,
50,
54,
52,
48,
54,
52,
52,
107,
101,
121,
115,
84,
111,
68,
101,
108,
101,
116,
101,
54,
52,
57,
54,
53,
52,
54,
53,
54,
54,
53,
55,
54,
53,
56,
54,
53,
57,
54,
54,
48,
54,
54,
49,
54,
54,
50,
54,
54,
51,
54,
54,
52,
54,
54,
53,
54,
54,
54,
54,
54,
55,
54,
54,
56,
54,
54,
57,
54,
55,
48,
54,
55,
49,
54,
55,
50,
54,
55,
51,
54,
55,
52,
54,
55,
53,
54,
55,
54,
54,
55,
55,
54,
55,
56,
54,
55,
57,
54,
56,
48,
54,
56,
49,
54,
56,
50,
54,
56,
51,
54,
56,
52,
54,
56,
53,
54,
56,
54,
54,
56,
55,
54,
56,
56,
54,
56,
57,
54,
57,
48,
54,
57,
49,
54,
57,
50,
54,
57,
51,
54,
57,
52,
54,
57,
53,
54,
57,
54,
54,
57,
55,
54,
57,
56,
54,
57,
57,
],
lengths: [
Interned(4),
Interned(5),
Interned(6),
Interned(5),
Interned(3),
Interned(3),
Interned(11),
Interned(8),
Interned(6),
Interned(6),
Interned(4),
Interned(9),
Interned(8),
Interned(6),
Interned(4),
Interned(6),
Interned(9),
Interned(10),
Interned(9),
Interned(12),
Interned(8),
Interned(6),
Interned(13),
Interned(10),
Interned(7),
Interned(3),
Interned(7),
Interned(6),
Interned(6),
Interned(7),
Interned(21),
Interned(6),
Interned(6),
Interned(14),
Interned(4),
Interned(8),
Interned(15),
Interned(10),
Interned(12),
Interned(12),
Interned(12),
Interned(11),
Interned(7),
Interned(15),
Interned(20),
Interned(13),
Interned(7),
Interned(14),
Interned(13),
Interned(14),
Interned(13),
Interned(4),
Interned(17),
Interned(15),
Interned(16),
Interned(10),
Interned(12),
Interned(12),
Interned(18),
Interned(12),
Interned(21),
Interned(17),
Interned(23),
Interned(14),
Interned(19),
Interned(13),
Interned(19),
Interned(15),
Interned(15),
Interned(7),
Interned(26),
Interned(19),
Interned(10),
Interned(20),
Interned(12),
Interned(8),
Interned(8),
Interned(5),
Interned(6),
Interned(6),
Interned(6),
Interned(7),
Interned(8),
Interned(17),
Interned(17),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(5),
Interned(5),
Interned(4),
Interned(4),
Interned(4),
Interned(8),
Interned(2),
Interned(4),
Interned(4),
Interned(6),
Interned(4),
Interned(3),
Interned(3),
Interned(2),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Interned(12),
Interned(2),
Interned(2),
Generated(3),
Interned(1),
Interned(4),
Interned(4),
Generated(3),
Generated(3),
Interned(6),
Interned(4),
Interned(4),
Generated(3),
Interned(3),
Interned(9),
Interned(7),
Interned(4),
Interned(17),
Interned(25),
Interned(13),
Interned(6),
Interned(9),
Interned(11),
Interned(13),
Interned(4),
Interned(15),
Interned(8),
Interned(17),
Interned(8),
Interned(7),
Interned(4),
Interned(17),
Interned(25),
Interned(13),
Interned(6),
Interned(4),
Interned(9),
Interned(8),
Interned(17),
Interned(8),
Interned(17),
Interned(1),
Interned(1),
Interned(4),
Generated(3),
Interned(4),
Interned(1),
Interned(1),
Interned(4),
Interned(4),
Interned(7),
Interned(4),
Interned(17),
Interned(13),
Interned(6),
Generated(3),
Interned(4),
Interned(9),
Interned(4),
Generated(3),
Interned(6),
Interned(1),
Interned(1),
Interned(4),
Interned(9),
Interned(4),
Generated(3),
Interned(6),
Interned(1),
Interned(1),
Interned(4),
Interned(12),
Interned(9),
Generated(3),
Interned(5),
Interned(1),
Interned(1),
Interned(4),
Interned(12),
Interned(9),
Generated(3),
Interned(5),
Interned(1),
Interned(1),
Interned(4),
Interned(9),
Interned(4),
Interned(9),
Interned(5),
Interned(6),
Interned(3),
Interned(5),
Interned(4),
Interned(9),
Generated(3),
Interned(1),
Interned(4),
Interned(3),
Generated(3),
Interned(4),
Interned(3),
Generated(3),
Interned(4),
Interned(3),
Interned(5),
Interned(7),
Interned(4),
Interned(17),
Interned(13),
Interned(6),
Interned(4),
Interned(18),
Interned(11),
Interned(8),
Interned(5),
Interned(12),
Interned(19),
Interned(3),
Interned(5),
Interned(17),
Interned(13),
Interned(6),
Interned(6),
Interned(8),
Interned(5),
Interned(12),
Interned(19),
Interned(5),
Interned(9),
Interned(8),
Interned(12),
Interned(19),
Interned(7),
Interned(4),
Interned(17),
Interned(13),
Interned(6),
Interned(3),
Interned(12),
Interned(19),
Interned(12),
Interned(19),
Interned(6),
Interned(7),
Interned(11),
Interned(18),
Interned(4),
Interned(3),
Interned(6),
Interned(8),
Interned(7),
Interned(4),
Interned(17),
Interned(13),
Interned(6),
Interned(3),
Interned(5),
Interned(11),
Interned(6),
Interned(5),
Generated(3),
Interned(8),
Interned(6),
Interned(7),
Generated(3),
Interned(8),
Interned(4),
Interned(22),
Interned(15),
Interned(4),
Interned(18),
Interned(5),
Interned(3),
Interned(4),
Interned(10),
Interned(4),
Interned(4),
Generated(3),
Interned(1),
Interned(4),
Generated(3),
Interned(1),
Interned(2),
Interned(2),
Interned(3),
Interned(3),
Interned(3),
Interned(3),
Generated(3),
Interned(5),
Interned(1),
Interned(1),
Interned(2),
Interned(2),
Interned(2),
Generated(3),
Interned(5),
Interned(1),
Interned(18),
Interned(18),
Interned(1),
Interned(18),
Interned(7),
Interned(4),
Interned(6),
Interned(3),
Interned(4),
Interned(18),
Interned(11),
Generated(3),
Generated(3),
Interned(7),
Interned(11),
Interned(18),
Interned(4),
Interned(3),
Interned(6),
Interned(8),
Interned(5),
Generated(3),
Interned(7),
Interned(11),
Interned(18),
Interned(4),
Interned(3),
Interned(6),
Interned(8),
Interned(5),
Generated(3),
Interned(7),
Interned(11),
Interned(18),
Interned(4),
Interned(3),
Interned(6),
Interned(8),
Interned(5),
Generated(3),
Generated(3),
Generated(3),
Interned(7),
Interned(8),
Interned(4),
Interned(5),
Interned(17),
Interned(13),
Interned(6),
Interned(12),
Interned(17),
Interned(20),
Interned(8),
Interned(12),
Interned(8),
Interned(13),
Interned(5),
Interned(3),
Interned(4),
Interned(12),
Interned(12),
Interned(10),
Interned(7),
Interned(11),
Interned(9),
Interned(6),
Interned(7),
Interned(11),
Interned(9),
Interned(10),
Interned(4),
Interned(17),
Interned(13),
Interned(6),
Interned(9),
Interned(8),
Interned(20),
Interned(8),
Interned(6),
Interned(13),
Interned(11),
Interned(17),
Interned(4),
Interned(13),
Interned(6),
Interned(4),
Interned(13),
Interned(17),
Interned(6),
Interned(8),
Interned(4),
Interned(6),
Generated(3),
Interned(8),
Interned(3),
Interned(9),
Interned(11),
Interned(18),
Interned(7),
Interned(3),
Interned(6),
Interned(4),
Interned(18),
Interned(11),
Interned(7),
Interned(11),
Interned(18),
Interned(6),
Interned(8),
Interned(6),
Interned(11),
Interned(6),
Interned(8),
Interned(11),
Interned(10),
Interned(3),
Generated(3),
Interned(4),
Interned(4),
Interned(6),
Interned(6),
Interned(7),
Interned(4),
Interned(1),
Interned(15),
Interned(5),
Interned(1),
Interned(1),
Interned(4),
Interned(6),
Interned(3),
Interned(5),
Interned(5),
Interned(4),
Interned(4),
Interned(5),
Interned(15),
Interned(5),
Interned(2),
Interned(2),
Interned(1),
Interned(1),
Interned(15),
Interned(5),
Interned(3),
Interned(2),
Interned(2),
Interned(1),
Interned(1),
Interned(15),
Interned(5),
Interned(3),
Interned(2),
Interned(1),
Interned(15),
Interned(5),
Interned(3),
Interned(2),
Interned(2),
Interned(1),
Interned(1),
Interned(15),
Interned(5),
Interned(4),
Interned(5),
Interned(5),
Interned(2),
Interned(2),
Interned(2),
Interned(2),
Interned(1),
Interned(1),
Interned(15),
Interned(5),
Interned(4),
Interned(6),
Interned(3),
Interned(1),
Interned(1),
Interned(1),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(5),
Interned(9),
Interned(7),
Interned(7),
Interned(7),
Interned(12),
Interned(8),
Interned(9),
Interned(9),
Interned(4),
Interned(4),
Interned(5),
Interned(9),
Interned(7),
Interned(12),
Interned(8),
Interned(1),
Interned(1),
Interned(5),
Interned(5),
Interned(1),
Interned(1),
Interned(1),
Interned(5),
Interned(5),
Interned(4),
Interned(5),
Interned(2),
Interned(2),
Interned(2),
Interned(2),
Interned(2),
Interned(2),
Interned(2),
Interned(2),
Interned(1),
Interned(1),
Interned(1),
Interned(1),
Interned(4),
Interned(5),
Interned(2),
Interned(2),
Interned(2),
Interned(2),
Interned(1),
Interned(1),
Interned(4),
Interned(5),
Interned(1),
Interned(2),
Interned(2),
Interned(2),
Interned(1),
Generated(3),
Interned(9),
Interned(9),
Interned(3),
Generated(3),
Interned(5),
Interned(5),
Interned(5),
Interned(5),
Interned(6),
Interned(6),
Interned(5),
Generated(3),
Interned(6),
Interned(6),
Interned(6),
Interned(6),
Interned(3),
Generated(3),
Interned(3),
Generated(3),
Generated(3),
Interned(4),
Interned(4),
Interned(4),
Interned(3),
Interned(4),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Interned(3),
Interned(4),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Interned(7),
Interned(4),
Interned(20),
Generated(3),
Interned(3),
Interned(1),
Generated(3),
Interned(3),
Interned(1),
Generated(3),
Generated(3),
Generated(3),
Interned(3),
Interned(1),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(5),
Interned(5),
Interned(5),
Interned(5),
Generated(3),
Interned(3),
Generated(3),
Generated(3),
Interned(2),
Interned(2),
Generated(3),
Interned(1),
Interned(2),
Interned(2),
Generated(3),
Interned(1),
Interned(12),
Interned(2),
Interned(2),
Generated(3),
Interned(1),
Interned(12),
Interned(2),
Interned(2),
Generated(3),
Interned(1),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
],
offsets: [
0,
4,
9,
15,
20,
23,
26,
37,
45,
51,
57,
61,
70,
78,
84,
88,
94,
103,
113,
122,
134,
142,
148,
161,
171,
178,
181,
188,
194,
200,
207,
228,
234,
240,
254,
258,
266,
281,
291,
303,
315,
327,
338,
345,
360,
380,
393,
400,
414,
427,
441,
454,
458,
475,
490,
506,
516,
528,
540,
558,
570,
591,
608,
631,
645,
664,
677,
696,
711,
726,
733,
759,
778,
788,
808,
820,
828,
836,
841,
847,
853,
859,
866,
874,
891,
908,
912,
916,
920,
924,
929,
934,
938,
942,
946,
954,
956,
960,
964,
970,
974,
977,
980,
982,
985,
988,
991,
994,
997,
1009,
1011,
1013,
1016,
1017,
1021,
1025,
1028,
1031,
1037,
1037,
1041,
1044,
1047,
1056,
1063,
1067,
1084,
1109,
1122,
1047,
1128,
1139,
1152,
1156,
1171,
1067,
1179,
1056,
1063,
1187,
1084,
1109,
1122,
1152,
1204,
1171,
1187,
1179,
1187,
1016,
1213,
1063,
1214,
1037,
1016,
1213,
1063,
1063,
1056,
1063,
1187,
1109,
1122,
1217,
1037,
1220,
1229,
1233,
1236,
1016,
1213,
1037,
1220,
1229,
1242,
1236,
1016,
1213,
1063,
1245,
1220,
1257,
1260,
1016,
1213,
1063,
1245,
1220,
1265,
1260,
1016,
1213,
1037,
1268,
1037,
1268,
1277,
1282,
1288,
1291,
1037,
1268,
1296,
1299,
1037,
1288,
1300,
1037,
1288,
1303,
1037,
1288,
1291,
1056,
1063,
1187,
1109,
1122,
1306,
1310,
1328,
1171,
1339,
1344,
1356,
1288,
1291,
1187,
1109,
1122,
1375,
1381,
1389,
1394,
1406,
1389,
1425,
1179,
1394,
1406,
1056,
1063,
1187,
1109,
1122,
1288,
1344,
1356,
1394,
1406,
1434,
1056,
1328,
1310,
1063,
1288,
1434,
1381,
1056,
1063,
1187,
1109,
1122,
1288,
1440,
1328,
1445,
1291,
1451,
1454,
1434,
1462,
1469,
1454,
1306,
1472,
1494,
1509,
1310,
1513,
1518,
1152,
1521,
1063,
1063,
1531,
1016,
1063,
1534,
1213,
1009,
1011,
1537,
1540,
1543,
1546,
1549,
1260,
1016,
1213,
1552,
1009,
1011,
1554,
1260,
1016,
1310,
1310,
1557,
1310,
1056,
1063,
1122,
1288,
1306,
1310,
1328,
1558,
1561,
1056,
1328,
1310,
1063,
1288,
1434,
1381,
1291,
1564,
1056,
1328,
1310,
1063,
1288,
1434,
1381,
1291,
1567,
1056,
1328,
1310,
1063,
1288,
1434,
1381,
1291,
1570,
1573,
1576,
1579,
1171,
1586,
1339,
1187,
1109,
1122,
1344,
1590,
1607,
1179,
1394,
1627,
1635,
1389,
1288,
1306,
1648,
1660,
1672,
1579,
1328,
1425,
1434,
1579,
1328,
1682,
1691,
1586,
1187,
1109,
1122,
1701,
1171,
1710,
1179,
1122,
1109,
1730,
1187,
1152,
1109,
1122,
1152,
1109,
1187,
1122,
1171,
1586,
1122,
1741,
1179,
1288,
1425,
1328,
1310,
1579,
1288,
1122,
1306,
1310,
1328,
1579,
1328,
1310,
1375,
1171,
1434,
1328,
1375,
1179,
1328,
1744,
1288,
1754,
1306,
1306,
1122,
1031,
1757,
1764,
1768,
1769,
1260,
1784,
1785,
1764,
1282,
1786,
1789,
1794,
1306,
1764,
1260,
1769,
1260,
1799,
1801,
1784,
1785,
1769,
1260,
1803,
1801,
1806,
1784,
1785,
1769,
1260,
1808,
1801,
1784,
1769,
1260,
1811,
1801,
1806,
1784,
1785,
1769,
1260,
1814,
1818,
1823,
1801,
1806,
1828,
1830,
1784,
1785,
1769,
1260,
1832,
1282,
1836,
1839,
1784,
1785,
1764,
1840,
1844,
1832,
1277,
1848,
1857,
1864,
1871,
1878,
1890,
1898,
1898,
1764,
1832,
1277,
1848,
1857,
1878,
1890,
1784,
1785,
1818,
1823,
1784,
1785,
1907,
1818,
1823,
1832,
1277,
1806,
1828,
1830,
1908,
1910,
1912,
1914,
1916,
1784,
1785,
1918,
1919,
1832,
1277,
1806,
1828,
1830,
1908,
1784,
1785,
1832,
1277,
1016,
1806,
1828,
1830,
1784,
1920,
1923,
1932,
1941,
1944,
1947,
1952,
1947,
1952,
1957,
1963,
1969,
1974,
1957,
1963,
1977,
1983,
1941,
1989,
1941,
1992,
1995,
1037,
1037,
1832,
1941,
1037,
1998,
2001,
2004,
2007,
2010,
2013,
2016,
2019,
2022,
2025,
2028,
2031,
1941,
1037,
2034,
2037,
2040,
2043,
2046,
2049,
2052,
2055,
2058,
2061,
2064,
2067,
2070,
2073,
1037,
2080,
2100,
2103,
1016,
2106,
1941,
2109,
2110,
2113,
2116,
2103,
1016,
1306,
1306,
1306,
1306,
1306,
1306,
1306,
1306,
1306,
1306,
1306,
1306,
1306,
1306,
1306,
1306,
1306,
1306,
2119,
2124,
2119,
2124,
2129,
2132,
2135,
2138,
2141,
2143,
2145,
1213,
2141,
2143,
2148,
1016,
2151,
2141,
2143,
2163,
1016,
2151,
2141,
2143,
2166,
1016,
2169,
2172,
2175,
2178,
2181,
2184,
2187,
2190,
2193,
2196,
2199,
2202,
2205,
2208,
2211,
2214,
2217,
2220,
2223,
2226,
2229,
2232,
2235,
2238,
2241,
2244,
2247,
2250,
2253,
2256,
2259,
2262,
2265,
2268,
2271,
2274,
2277,
2280,
2283,
2286,
2289,
2292,
2295,
2298,
],
strings: [
"Dict",
"empty",
"single",
"clear",
"len",
"get",
"#get_result",
"contains",
"insert",
"remove",
"walk",
"walkUntil",
"fromList",
"toList",
"keys",
"values",
"insertAll",
"keepShared",
"removeAll",
"withCapacity",
"capacity",
"update",
"listGetUnsafe",
"pseudoSeed",
"isEmpty",
"map",
"joinMap",
"keepIf",
"dropIf",
"reserve",
"releaseExcessCapacity",
"Bucket",
"BadKey",
"LowLevelHasher",
"isEq",
"hashDict",
"toInspectorDict",
"keepIfHelp",
"insertHelper",
"removeHelper",
"circularDist",
"emptyBucket",
"distInc",
"fingerprintMask",
"defaultMaxLoadFactor",
"initialShifts",
"maxSize",
"maxBucketCount",
"incrementDist",
"incrementDistN",
"decrementDist",
"find",
"findManualUnrolls",
"findFirstUnroll",
"findSecondUnroll",
"findHelper",
"removeBucket",
"scanForIndex",
"removeBucketHelper",
"increaseSize",
"allocBucketsFromShift",
"calcShiftsForSize",
"calcShiftsForSizeHelper",
"calcNumBuckets",
"fillBucketsFromData",
"nextWhileLess",
"nextWhileLessHelper",
"placeAndShiftUp",
"nextBucketIndex",
"hashKey",
"distAndFingerprintFromHash",
"bucketIndexFromHash",
"hashBadKey",
"createLowLevelHasher",
"combineState",
"initSeed",
"complete",
"addU8",
"addU16",
"addU32",
"addU64",
"addU128",
"addBytes",
"hashBytesHelper48",
"hashBytesHelper16",
"wyp0",
"wyp1",
"wyp2",
"wyp3",
"wymix",
"wymum",
"wyr8",
"wyr4",
"wyr3",
"testSeed",
"Eq",
"Hash",
"List",
"Bucket",
"List",
"U64",
"F32",
"U8",
"U32",
"U32",
"U64",
"U64",
"U64",
"#BadKey_isEq",
"xs",
"ys",
"111",
"k",
"xVal",
"yVal",
"115",
"116",
"hasher",
"dict",
"dict",
"120",
"fmt",
"requested",
"buckets",
"data",
"maxBucketCapacity",
"originalMaxBucketCapacity",
"maxLoadFactor",
"shifts",
"requested",
"currentSize",
"requestedSize",
"size",
"requestedShifts",
"buckets0",
"maxBucketCapacity",
"buckets1",
"buckets",
"data",
"maxBucketCapacity",
"originalMaxBucketCapacity",
"maxLoadFactor",
"shifts",
"size",
"minShifts",
"buckets0",
"maxBucketCapacity",
"buckets1",
"maxBucketCapacity",
"k",
"v",
"data",
"152",
"dict",
"k",
"v",
"data",
"data",
"buckets",
"data",
"maxBucketCapacity",
"maxLoadFactor",
"shifts",
"163",
"dict",
"transform",
"init",
"167",
"answer",
"k",
"v",
"dict",
"transform",
"init",
"174",
"answer",
"k",
"v",
"data",
"initialState",
"transform",
"181",
"state",
"k",
"v",
"data",
"initialState",
"transform",
"188",
"state",
"k",
"v",
"dict",
"predicate",
"dict",
"predicate",
"index",
"length",
"key",
"value",
"dict",
"predicate",
"202",
"e",
"dict",
"key",
"206",
"dict",
"key",
"209",
"dict",
"key",
"value",
"buckets",
"data",
"maxBucketCapacity",
"maxLoadFactor",
"shifts",
"hash",
"distAndFingerprint",
"bucketIndex",
"buckets0",
"data0",
"bucketIndex0",
"distAndFingerprint0",
"key",
"value",
"maxBucketCapacity",
"maxLoadFactor",
"shifts",
"loaded",
"foundKey",
"data1",
"bucketIndex1",
"distAndFingerprint1",
"data1",
"dataIndex",
"buckets1",
"bucketIndex1",
"distAndFingerprint1",
"buckets",
"data",
"maxBucketCapacity",
"maxLoadFactor",
"shifts",
"key",
"bucketIndex0",
"distAndFingerprint0",
"bucketIndex1",
"distAndFingerprint1",
"bucket",
"buckets",
"bucketIndex",
"distAndFingerprint",
"data",
"key",
"bucket",
"foundKey",
"buckets",
"data",
"maxBucketCapacity",
"maxLoadFactor",
"shifts",
"key",
"alter",
"bucketIndex",
"result",
"value",
"268",
"newValue",
"bucket",
"newData",
"272",
"newValue",
"hash",
"baseDistAndFingerprint",
"baseBucketIndex",
"dist",
"distAndFingerprint",
"start",
"end",
"size",
"correction",
"data",
"data",
"285",
"k",
"data",
"288",
"v",
"xs",
"ys",
"xs0",
"ys0",
"xs1",
"ys1",
"296",
"state",
"k",
"v",
"yv",
"xs",
"ys",
"303",
"state",
"k",
"distAndFingerprint",
"distAndFingerprint",
"n",
"distAndFingerprint",
"buckets",
"data",
"shifts",
"key",
"hash",
"distAndFingerprint",
"bucketIndex",
"317",
"318",
"buckets",
"bucketIndex",
"distAndFingerprint",
"data",
"key",
"bucket",
"foundKey",
"value",
"327",
"buckets",
"bucketIndex",
"distAndFingerprint",
"data",
"key",
"bucket",
"foundKey",
"value",
"336",
"buckets",
"bucketIndex",
"distAndFingerprint",
"data",
"key",
"bucket",
"foundKey",
"value",
"345",
"346",
"347",
"buckets",
"buckets0",
"data",
"data0",
"maxBucketCapacity",
"maxLoadFactor",
"shifts",
"bucketIndex0",
"dataIndexToRemove",
"dataIndexToRemoveU64",
"buckets1",
"bucketIndex1",
"buckets2",
"lastDataIndex",
"data1",
"key",
"hash",
"bucketIndex2",
"bucketIndex3",
"swapBucket",
"buckets",
"bucketIndex",
"dataIndex",
"bucket",
"buckets",
"bucketIndex",
"nextIndex",
"nextBucket",
"data",
"maxBucketCapacity",
"maxLoadFactor",
"shifts",
"newShifts",
"buckets0",
"newMaxBucketCapacity",
"buckets1",
"shifts",
"maxLoadFactor",
"bucketCount",
"maxBucketCapacity",
"size",
"maxLoadFactor",
"shifts",
"size",
"maxLoadFactor",
"maxBucketCapacity",
"shifts",
"buckets0",
"data",
"shifts",
"398",
"buckets1",
"key",
"dataIndex",
"bucketIndex",
"distAndFingerprint",
"buckets",
"key",
"shifts",
"hash",
"distAndFingerprint",
"bucketIndex",
"buckets",
"bucketIndex",
"distAndFingerprint",
"loaded",
"buckets0",
"bucket",
"bucketIndex",
"loaded",
"buckets1",
"bucketIndex",
"maxBuckets",
"key",
"422",
"hash",
"hash",
"shifts",
"hasher",
"seedOpt",
"seed",
"s",
"initializedSeed",
"state",
"a",
"b",
"seed",
"length",
"mum",
"nexta",
"nextb",
"hash",
"seed",
"state",
"initializedSeed",
"state",
"u8",
"p0",
"a",
"b",
"initializedSeed",
"state",
"u16",
"p0",
"p1",
"a",
"b",
"initializedSeed",
"state",
"u32",
"p0",
"a",
"initializedSeed",
"state",
"u64",
"p0",
"p1",
"a",
"b",
"initializedSeed",
"state",
"u128",
"lower",
"upper",
"p0",
"p1",
"p2",
"p3",
"a",
"b",
"initializedSeed",
"state",
"list",
"length",
"abs",
"x",
"a",
"b",
"seed",
"see1",
"see2",
"list",
"index",
"remaining",
"newSeed",
"newSee1",
"newSee2",
"newRemaining",
"newIndex",
"finalSeed",
"finalSeed",
"seed",
"list",
"index",
"remaining",
"newSeed",
"newRemaining",
"newIndex",
"a",
"b",
"lower",
"upper",
"a",
"b",
"r",
"lower",
"upper",
"list",
"index",
"p1",
"p2",
"p3",
"p4",
"p5",
"p6",
"p7",
"p8",
"a",
"b",
"c",
"d",
"list",
"index",
"p1",
"p2",
"p3",
"p4",
"a",
"b",
"list",
"index",
"k",
"p1",
"p2",
"p3",
"a",
"544",
"#payload1",
"#payload2",
"val",
"548",
"dict1",
"dict2",
"dict1",
"dict2",
"inner1",
"inner2",
"outer",
"556",
"inner1",
"inner2",
"outer1",
"outer2",
"val",
"562",
"val",
"564",
"565",
"dict",
"dict",
"list",
"val",
"dict",
"571",
"572",
"573",
"574",
"575",
"576",
"577",
"578",
"579",
"580",
"581",
"582",
"val",
"dict",
"585",
"586",
"587",
"588",
"589",
"590",
"591",
"592",
"593",
"594",
"595",
"596",
"597",
"badKeys",
"dict",
"allInsertedCorrectly",
"601",
"acc",
"k",
"604",
"val",
"p",
"607",
"608",
"609",
"acc",
"k",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash",
"hash1",
"hash2",
"hash1",
"hash2",
"634",
"age",
"636",
"637",
"d1",
"d2",
"640",
"v",
"d1",
"d2",
"644",
"k",
"keysToDelete",
"d1",
"d2",
"649",
"k",
"keysToDelete",
"d1",
"d2",
"654",
"k",
"656",
"657",
"658",
"659",
"660",
"661",
"662",
"663",
"664",
"665",
"666",
"667",
"668",
"669",
"670",
"671",
"672",
"673",
"674",
"675",
"676",
"677",
"678",
"679",
"680",
"681",
"682",
"683",
"684",
"685",
"686",
"687",
"688",
"689",
"690",
"691",
"692",
"693",
"694",
"695",
"696",
"697",
"698",
"699",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffed5b84a0,
head: 000000,
bits: 700,
capacity: 704,
} [
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
regions: [
@3079-3245,
@4324-4329,
@7361-7367,
@9031-9036,
@8389-8392,
@13879-13882,
…,
@14162-14170,
@14469-14475,
@16687-16693,
@10716-10720,
@11876-11885,
@8017-8025,
@21883-21889,
@22289-22293,
@22742-22748,
@23643-23652,
@24514-24524,
@25611-25620,
@4700-4712,
@7088-7096,
@18882-18888,
@41220-41233,
@42187-42197,
@8602-8609,
@9616-9619,
@10087-10094,
@12436-12442,
@13392-13398,
@4872-4879,
@6041-6062,
@25758-25928,
@40231-40244,
@41841-41897,
@3493-3497,
@3873-3881,
@4086-4101,
@12576-12586,
@14999-15011,
@17480-17492,
@21266-21278,
@25930-25941,
@25984-25991,
@26043-26058,
@26116-26136,
@26143-26156,
@26213-26220,
@26247-26261,
@26273-26286,
@26356-26370,
@26459-26472,
@26622-26626,
@27131-27148,
@27290-27305,
@28203-28219,
@28937-28947,
@29688-29700,
@31080-31092,
@31398-31416,
@31935-31947,
@32598-32619,
@33108-33125,
@33214-33237,
@33565-33579,
@33684-33703,
@34052-34065,
@34288-34307,
@34633-34648,
@35079-35094,
@35449-35456,
@35585-35611,
@35754-35773,
@40402-40412,
@42283-42303,
@42590-42602,
@43019-43027,
@43121-43129,
@43563-43568,
@43875-43881,
@44260-44266,
@44504-44510,
@44847-44854,
@45471-45479,
@46598-46615,
@47739-47756,
@48263-48267,
@48300-48304,
@48337-48341,
@48374-48378,
@48425-48430,
@48557-48562,
@48915-48919,
@50092-50096,
@50591-50595,
@50985-50993,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
@3501-3503,
@3505-3507,
…,
@3603-3604,
@3606-3610,
@3662-3666,
…,
…,
@3885-3891,
@3893-3897,
@4105-4109,
…,
@4117-4120,
@4716-4725,
@4889-4975,
@4889-4975,
@4906-4950,
@4925-4950,
@4889-4975,
@4889-4975,
@4977-4986,
@4994-5005,
@5026-5039,
@5080-5084,
@5122-5137,
@5249-5257,
@5259-5276,
@5340-5348,
@6072-6158,
@6072-6158,
@6089-6133,
@6108-6133,
@6072-6158,
@6072-6158,
@6166-6170,
@6302-6311,
@6391-6399,
@6401-6418,
@6476-6484,
@7106-7127,
@7371-7372,
@7374-7375,
@8029-8033,
…,
@8069-8073,
@8076-8077,
@8079-8080,
@8402-8410,
@8619-8627,
@9046-9105,
@9046-9105,
@9046-9105,
@9046-9105,
@9046-9105,
…,
@9623-9627,
@9629-9638,
@9646-9650,
…,
@9703-9709,
@9711-9712,
@9714-9715,
@10098-10102,
@10104-10113,
@10121-10125,
…,
@10205-10211,
@10213-10214,
@10216-10217,
@10730-10738,
@10740-10752,
@10754-10763,
…,
@10801-10806,
@10809-10810,
@10812-10813,
@11895-11903,
@11905-11917,
@11919-11928,
…,
@11971-11976,
@11979-11980,
@11982-11983,
@12446-12450,
@12452-12461,
@12596-12600,
@12602-12611,
@12613-12618,
@12620-12626,
@12666-12669,
@12671-12676,
@13402-13406,
@13408-13417,
…,
@13444-13445,
@13886-13890,
@13892-13895,
…,
@14174-14178,
@14180-14183,
…,
@14479-14483,
@14485-14488,
@14490-14495,
@14510-14569,
@14510-14569,
@14510-14569,
@14510-14569,
@14510-14569,
@14679-14683,
@14702-14720,
@14759-14770,
@15015-15023,
@15025-15030,
@15032-15044,
@15046-15065,
@15067-15070,
@15072-15077,
@15079-15096,
@15098-15111,
@15113-15119,
@15127-15133,
@15242-15250,
@15350-15355,
@15535-15547,
@15611-15630,
@15862-15867,
@15909-15918,
@15963-15971,
@16196-16208,
@16268-16287,
@16703-16762,
@16703-16762,
@16703-16762,
@16703-16762,
@16703-16762,
@16764-16767,
@16813-16825,
@16827-16846,
@16892-16904,
@16906-16925,
@17001-17007,
@17496-17503,
@17505-17516,
@17518-17536,
@17538-17542,
@17544-17547,
@17555-17561,
@17667-17675,
@18898-18957,
@18898-18957,
@18898-18957,
@18898-18957,
@18898-18957,
@18959-18962,
@18964-18969,
@18977-19000,
@18977-19000,
@19110-19115,
…,
@19185-19193,
@19217-19223,
@19280-19287,
…,
@19671-19679,
@20138-20142,
@20181-20203,
@20262-20277,
@20611-20615,
@20938-20956,
@21282-21287,
@21289-21292,
@21294-21298,
@21306-21316,
@21899-21907,
@22303-22311,
…,
@22336-22337,
@22758-22766,
…,
@22794-22795,
@23656-23658,
@23660-23662,
@24528-24531,
@24533-24536,
@24545-24548,
@24550-24553,
…,
@24714-24719,
@24721-24722,
@24724-24725,
@24778-24780,
@25624-25626,
@25628-25630,
…,
@25651-25656,
@25658-25659,
@26290-26308,
@26374-26392,
@26394-26395,
@26476-26494,
@26636-26661,
@26636-26661,
@26636-26661,
@26663-26666,
@26674-26678,
@26697-26715,
@26754-26765,
…,
…,
@27309-27316,
@27318-27329,
@27331-27349,
@27351-27355,
@27357-27360,
@27530-27536,
@27642-27650,
@27652-27657,
…,
@28223-28230,
@28232-28243,
@28245-28263,
@28265-28269,
@28271-28274,
@28282-28288,
@28394-28402,
@28404-28409,
…,
@28951-28958,
@28960-28971,
@28973-28991,
@28993-28997,
@28999-29002,
@29010-29016,
@29122-29130,
@29132-29137,
…,
…,
…,
@29712-29729,
@29721-29729,
@29731-29742,
@29737-29742,
@29710-29786,
@29710-29786,
@29710-29786,
@29788-29800,
@29808-29825,
@29880-29900,
@29937-29945,
@29947-29959,
@30008-30016,
@30067-30080,
@30212-30217,
@30280-30283,
@30390-30394,
@30417-30429,
@30473-30485,
@30557-30567,
@31096-31103,
@31105-31116,
@31118-31127,
@31135-31141,
@31420-31427,
@31429-31440,
@31448-31457,
@31511-31521,
@31957-32007,
@31957-32007,
@31957-32007,
@31957-32007,
@32067-32076,
@32112-32120,
@32122-32142,
@32200-32208,
@32623-32629,
@32631-32644,
@32652-32663,
@32876-32893,
@33129-33133,
@33135-33148,
@33241-33247,
@33249-33253,
@33255-33268,
@33276-33293,
@33583-33589,
@33707-33715,
@33717-33721,
@33723-33729,
…,
@33737-33745,
@33748-33751,
@33757-33766,
@33808-33819,
@33821-33839,
@34069-34076,
@34078-34081,
@34083-34089,
@34097-34101,
@34120-34138,
@34177-34188,
@34311-34318,
@34320-34331,
@34333-34351,
@34359-34365,
@34652-34660,
@34662-34668,
@34670-34681,
@34689-34695,
@34784-34792,
@35098-35109,
@35111-35121,
@35460-35463,
…,
@35615-35619,
@35777-35781,
@35783-35789,
@40416-40422,
@42307-42314,
@42322-42326,
@42418-42419,
@42622-42648,
@42622-42648,
@42650-42672,
@42650-42672,
@42650-42672,
@42650-42672,
@42680-42683,
@42772-42777,
@42866-42871,
@42927-42931,
@43031-43035,
@43149-43158,
@43588-43614,
@43588-43614,
@43616-43618,
@43626-43628,
@43648-43649,
@43762-43763,
@43901-43927,
@43901-43927,
@43929-43932,
@43940-43942,
@43986-43988,
@44033-44034,
@44147-44148,
@44286-44312,
@44286-44312,
@44314-44317,
@44325-44327,
@44348-44349,
@44530-44556,
@44530-44556,
@44558-44561,
@44569-44571,
@44609-44611,
@44644-44645,
@44694-44695,
@44874-44900,
@44874-44900,
@44902-44906,
@44914-44919,
@44944-44949,
@44996-44998,
@45038-45040,
@45105-45107,
@45147-45149,
@45214-45215,
@45264-45265,
@45499-45525,
@45499-45525,
@45527-45531,
@45539-45545,
@45566-45569,
@45649-45650,
@45718-45719,
@45802-45803,
@46619-46623,
@46625-46629,
@46631-46635,
@46637-46641,
@46643-46648,
@46650-46659,
@46667-46674,
@46783-46790,
@46917-46924,
@47051-47063,
@47095-47103,
@47278-47287,
@47427-47436,
@47760-47764,
@47766-47770,
@47772-47777,
@47779-47788,
@47796-47803,
@47912-47924,
@47956-47964,
@48434-48435,
@48437-48438,
@48446-48462,
@48446-48462,
@48566-48567,
@48569-48570,
@48578-48579,
@48628-48633,
@48652-48657,
@48923-48927,
@48929-48934,
@49211-49213,
@49258-49260,
@49321-49323,
@49384-49386,
@49447-49449,
@49510-49512,
@49573-49575,
@49636-49638,
@49699-49700,
@49747-49748,
@49817-49818,
@49887-49888,
@50100-50104,
@50106-50111,
@50119-50121,
@50166-50168,
@50229-50231,
@50292-50294,
@50355-50356,
@50403-50404,
@50599-50603,
@50605-50610,
@50612-50613,
@50681-50683,
@50728-50730,
@50815-50817,
@50895-50896,
…,
…,
…,
@35847-35850,
…,
@35954-35959,
@36036-36041,
@36145-36150,
@36227-36232,
@36337-36343,
@36420-36426,
@36503-36508,
…,
@36642-36648,
@36725-36731,
@36808-36814,
@36870-36876,
@36961-36964,
…,
@37098-37101,
…,
…,
@37278-37282,
@37456-37460,
@37583-37587,
@37779-37782,
@38182-38186,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
@38884-38887,
@39310-39314,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
@40460-40467,
@40731-40735,
@40948-40968,
…,
@40746-40749,
@40751-40752,
…,
@40817-40820,
@40872-40873,
…,
…,
…,
@40979-40982,
@40984-40985,
@51235-51239,
@51367-51371,
@51503-51507,
@51634-51638,
@51776-51780,
@51910-51914,
@52052-52056,
@52186-52190,
@52340-52344,
@52479-52483,
@52633-52637,
@52772-52776,
@52998-53002,
@53168-53172,
@53335-53339,
@53538-53542,
@53749-53753,
@54034-54038,
@54211-54216,
@54350-54355,
@54514-54519,
@54651-54656,
…,
@55183-55186,
…,
…,
@55289-55291,
@55466-55468,
…,
@55447-55448,
@55587-55589,
@55775-55777,
…,
@55741-55742,
@55898-55910,
@55924-55926,
@56169-56171,
…,
@56112-56113,
@56303-56315,
@56329-56331,
@56574-56576,
…,
@56517-56518,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
],
home: Dict,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`Dict.Dict`,
`Dict.empty`,
`Dict.withCapacity`,
`Dict.single`,
`Dict.clear`,
`Dict.capacity`,
`Dict.reserve`,
`Dict.releaseExcessCapacity`,
`Dict.len`,
`Dict.isEmpty`,
`Dict.get`,
`Dict.contains`,
`Dict.insert`,
`Dict.remove`,
`Dict.update`,
`Dict.walk`,
`Dict.walkUntil`,
`Dict.keepIf`,
`Dict.dropIf`,
`Dict.toList`,
`Dict.fromList`,
`Dict.keys`,
`Dict.values`,
`Dict.insertAll`,
`Dict.keepShared`,
`Dict.removeAll`,
`Dict.map`,
`Dict.joinMap`,
],
},
},
<<docs:
Some(
"Provides a [set](https://en.wikipedia.org/wiki/Set_(abstract_data_type))\ntype which stores a collection of unique values, without any ordering\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Creates a new empty `Set`.\n```\nemptySet = Set.empty {}\ncountValues = Set.len emptySet\n\nexpect countValues == 0\n```\n",
)
docs>>
<<docs:
Some(
"Return a set with space allocated for a number of entries. This\nmay provide a performance optimization if you know how many entries will be\ninserted.\n",
)
docs>>
<<docs:
Some(
"Enlarge the set for at least capacity additional elements\n",
)
docs>>
<<docs:
Some(
"Shrink the memory footprint of a set such that capacity is as small as possible.\nThis function will require regenerating the metadata if the size changes.\nThere will still be some overhead due to dictionary metadata always being a power of 2.\n",
)
docs>>
<<docs:
Some(
"Creates a new `Set` with a single value.\n```\nsingleItemSet = Set.single \"Apple\"\ncountValues = Set.len singleItemSet\n\nexpect countValues == 1\n```\n",
)
docs>>
<<docs:
Some(
"Insert a value into a `Set`.\n```\nfewItemSet =\n Set.empty {}\n |> Set.insert \"Apple\"\n |> Set.insert \"Pear\"\n |> Set.insert \"Banana\"\n\ncountValues = Set.len fewItemSet\n\nexpect countValues == 3\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Counts the number of values in a given `Set`.\n```\nfewItemSet =\n Set.empty {}\n |> Set.insert \"Apple\"\n |> Set.insert \"Pear\"\n |> Set.insert \"Banana\"\n\ncountValues = Set.len fewItemSet\n\nexpect countValues == 3\n```\n",
)
docs>>
<<docs:
Some(
"Returns the max number of elements the set can hold before requiring a rehash.\n```\nfoodSet =\n Set.empty {}\n |> Set.insert \"apple\"\n\ncapacityOfSet = Set.capacity foodSet\n```\n",
)
docs>>
<<docs:
Some(
"Check if the set is empty.\n```\nSet.isEmpty (Set.empty {} |> Set.insert 42)\n\nSet.isEmpty (Set.empty {})\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
Some(
"Removes the value from the given `Set`.\n```\nnumbers =\n Set.empty {}\n |> Set.insert 10\n |> Set.insert 20\n |> Set.remove 10\n\nhas10 = Set.contains numbers 10\nhas20 = Set.contains numbers 20\n\nexpect has10 == Bool.false\nexpect has20 == Bool.true\n```\n",
)
docs>>
<<docs:
Some(
"Test if a value is in the `Set`.\n```\nFruit : [Apple, Pear, Banana]\n\nfruit : Set Fruit\nfruit =\n Set.single Apple\n |> Set.insert Pear\n\nhasApple = Set.contains fruit Apple\nhasBanana = Set.contains fruit Banana\n\nexpect hasApple == Bool.true\nexpect hasBanana == Bool.false\n```\n",
)
docs>>
<<docs:
Some(
"Retrieve the values in a `Set` as a `List`.\n```\nnumbers : Set U64\nnumbers = Set.fromList [1,2,3,4,5]\n\nvalues = [1,2,3,4,5]\n\nexpect Set.toList numbers == values\n```\n",
)
docs>>
<<docs:
Some(
"Create a `Set` from a `List` of values.\n```\nvalues =\n Set.empty {}\n |> Set.insert Banana\n |> Set.insert Apple\n |> Set.insert Pear\n\nexpect Set.fromList [Pear, Apple, Banana] == values\n```\n",
)
docs>>
<<docs:
Some(
"Combine two `Set` collection by keeping the\n[union](https://en.wikipedia.org/wiki/Union_(set_theory))\nof all the values pairs. This means that all of the values in both `Set`s\nwill be combined.\n```\nset1 = Set.single Left\nset2 = Set.single Right\n\nexpect Set.union set1 set2 == Set.fromList [Left, Right]\n```\n",
)
docs>>
<<docs:
Some(
"Combine two `Set`s by keeping the [intersection](https://en.wikipedia.org/wiki/Intersection_(set_theory))\nof all the values pairs. This means that we keep only those values that are\nin both `Set`s.\n```\nset1 = Set.fromList [Left, Other]\nset2 = Set.fromList [Left, Right]\n\nexpect Set.intersection set1 set2 == Set.single Left\n```\n",
)
docs>>
<<docs:
Some(
"Remove the values in the first `Set` that are also in the second `Set`\nusing the [set difference](https://en.wikipedia.org/wiki/Complement_(set_theory)#Relative_complement)\nof the values. This means that we will be left with only those values that\nare in the first and not in the second.\n```\nfirst = Set.fromList [Left, Right, Up, Down]\nsecond = Set.fromList [Left, Right]\n\nexpect Set.difference first second == Set.fromList [Up, Down]\n```\n",
)
docs>>
<<docs:
Some(
"Iterate through the values of a given `Set` and build a value.\n```\nvalues = Set.fromList [\"March\", \"April\", \"May\"]\n\nstartsWithLetterM = \\month ->\n when Str.toUtf8 month is\n ['M', ..] -> Bool.true\n _ -> Bool.false\n\nreduce = \\state, k ->\n if startsWithLetterM k then\n state + 1\n else\n state\n\nresult = Set.walk values 0 reduce\n\nexpect result == 2\n```\n",
)
docs>>
<<docs:
Some(
"Convert each value in the set to something new, by calling a conversion\nfunction on each of them which receives the old value. Then return a\nnew set containing the converted values.\n",
)
docs>>
<<docs:
Some(
"Like [Set.map], except the transformation function wraps the return value\nin a set. At the end, all the sets get joined together\n(using [Set.union]) into one set.\n\nYou may know a similar function named `concatMap` in other languages.\n",
)
docs>>
<<docs:
Some(
"Iterate through the values of a given `Set` and build a value, can stop\niterating part way through the collection.\n```\nnumbers = Set.fromList [1,2,3,4,5,6,42,7,8,9,10]\n\nfind42 = \\state, k ->\n if k == 42 then\n Break FoundTheAnswer\n else\n Continue state\n\nresult = Set.walkUntil numbers NotFound find42\n\nexpect result == FoundTheAnswer\n```\n",
)
docs>>
<<docs:
Some(
"Run the given function on each element in the `Set`, and return\na `Set` with just the elements for which the function returned `Bool.true`.\n```\nexpect Set.fromList [1,2,3,4,5]\n |> Set.keepIf \\k -> k >= 3\n |> Bool.isEq (Set.fromList [3,4,5])\n```\n",
)
docs>>
<<docs:
Some(
"Run the given function on each element in the `Set`, and return\na `Set` with just the elements for which the function returned `Bool.false`.\n```\nexpect Set.fromList [1,2,3,4,5]\n |> Set.dropIf \\k -> k >= 3\n |> Bool.isEq (Set.fromList [1,2])\n```\n",
)
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
<<docs:
None
docs>>
adding docs for "Set.roc",
docs ModuleDocumentation {
name: "Set",
entries: [
DocDef(
DocDef {
name: "Set",
symbol: `Set.Set`,
type_vars: [
"k",
],
type_annotation: NoTypeAnn,
docs: Some(
"Provides a [set](https://en.wikipedia.org/wiki/Set_(abstract_data_type))\ntype which stores a collection of unique values, without any ordering\n",
),
},
),
DocDef(
DocDef {
name: "isEq",
symbol: `Set.isEq`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: None,
},
),
DocDef(
DocDef {
name: "hashSet",
symbol: `Set.hashSet`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
BoundVariable(
"hasher",
),
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
],
output: BoundVariable(
"hasher",
),
},
implements: [
ImplementsClause {
name: "hasher",
abilities: [
Apply {
name: "Hasher",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "toInspectorSet",
symbol: `Set.toInspectorSet`,
type_vars: [],
type_annotation: Where {
ann: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
],
output: Apply {
name: "Inspector",
parts: [
BoundVariable(
"f",
),
],
},
},
implements: [
ImplementsClause {
name: "k",
abilities: [
Apply {
name: "Inspect",
parts: [],
},
Apply {
name: "Hash",
parts: [],
},
Apply {
name: "Eq",
parts: [],
},
],
},
ImplementsClause {
name: "f",
abilities: [
Apply {
name: "InspectFormatter",
parts: [],
},
],
},
],
},
docs: None,
},
),
DocDef(
DocDef {
name: "empty",
symbol: `Set.empty`,
type_vars: [],
type_annotation: Function {
args: [
Record {
fields: [],
extension: NoTypeAnn,
},
],
output: Apply {
name: "Set",
parts: [
Wildcard,
],
},
},
docs: Some(
"Creates a new empty `Set`.\n```\nemptySet = Set.empty {}\ncountValues = Set.len emptySet\n\nexpect countValues == 0\n```\n",
),
},
),
DocDef(
DocDef {
name: "withCapacity",
symbol: `Set.withCapacity`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Set",
parts: [
Wildcard,
],
},
},
docs: Some(
"Return a set with space allocated for a number of entries. This\nmay provide a performance optimization if you know how many entries will be\ninserted.\n",
),
},
),
DocDef(
DocDef {
name: "reserve",
symbol: `Set.reserve`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
Apply {
name: "U64",
parts: [],
},
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Enlarge the set for at least capacity additional elements\n",
),
},
),
DocDef(
DocDef {
name: "releaseExcessCapacity",
symbol: `Set.releaseExcessCapacity`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Shrink the memory footprint of a set such that capacity is as small as possible.\nThis function will require regenerating the metadata if the size changes.\nThere will still be some overhead due to dictionary metadata always being a power of 2.\n",
),
},
),
DocDef(
DocDef {
name: "single",
symbol: `Set.single`,
type_vars: [],
type_annotation: Function {
args: [
BoundVariable(
"k",
),
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Creates a new `Set` with a single value.\n```\nsingleItemSet = Set.single \"Apple\"\ncountValues = Set.len singleItemSet\n\nexpect countValues == 1\n```\n",
),
},
),
DocDef(
DocDef {
name: "insert",
symbol: `Set.insert`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
BoundVariable(
"k",
),
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Insert a value into a `Set`.\n```\nfewItemSet =\n Set.empty {}\n |> Set.insert \"Apple\"\n |> Set.insert \"Pear\"\n |> Set.insert \"Banana\"\n\ncountValues = Set.len fewItemSet\n\nexpect countValues == 3\n```\n",
),
},
),
DocDef(
DocDef {
name: "len",
symbol: `Set.len`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: Some(
"Counts the number of values in a given `Set`.\n```\nfewItemSet =\n Set.empty {}\n |> Set.insert \"Apple\"\n |> Set.insert \"Pear\"\n |> Set.insert \"Banana\"\n\ncountValues = Set.len fewItemSet\n\nexpect countValues == 3\n```\n",
),
},
),
DocDef(
DocDef {
name: "capacity",
symbol: `Set.capacity`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "U64",
parts: [],
},
},
docs: Some(
"Returns the max number of elements the set can hold before requiring a rehash.\n```\nfoodSet =\n Set.empty {}\n |> Set.insert \"apple\"\n\ncapacityOfSet = Set.capacity foodSet\n```\n",
),
},
),
DocDef(
DocDef {
name: "isEmpty",
symbol: `Set.isEmpty`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
Wildcard,
],
},
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Check if the set is empty.\n```\nSet.isEmpty (Set.empty {} |> Set.insert 42)\n\nSet.isEmpty (Set.empty {})\n```\n",
),
},
),
DocDef(
DocDef {
name: "remove",
symbol: `Set.remove`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
BoundVariable(
"k",
),
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Removes the value from the given `Set`.\n```\nnumbers =\n Set.empty {}\n |> Set.insert 10\n |> Set.insert 20\n |> Set.remove 10\n\nhas10 = Set.contains numbers 10\nhas20 = Set.contains numbers 20\n\nexpect has10 == Bool.false\nexpect has20 == Bool.true\n```\n",
),
},
),
DocDef(
DocDef {
name: "contains",
symbol: `Set.contains`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
BoundVariable(
"k",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
docs: Some(
"Test if a value is in the `Set`.\n```\nFruit : [Apple, Pear, Banana]\n\nfruit : Set Fruit\nfruit =\n Set.single Apple\n |> Set.insert Pear\n\nhasApple = Set.contains fruit Apple\nhasBanana = Set.contains fruit Banana\n\nexpect hasApple == Bool.true\nexpect hasBanana == Bool.false\n```\n",
),
},
),
DocDef(
DocDef {
name: "toList",
symbol: `Set.toList`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
],
output: Apply {
name: "List",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Retrieve the values in a `Set` as a `List`.\n```\nnumbers : Set U64\nnumbers = Set.fromList [1,2,3,4,5]\n\nvalues = [1,2,3,4,5]\n\nexpect Set.toList numbers == values\n```\n",
),
},
),
DocDef(
DocDef {
name: "fromList",
symbol: `Set.fromList`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "List",
parts: [
BoundVariable(
"k",
),
],
},
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Create a `Set` from a `List` of values.\n```\nvalues =\n Set.empty {}\n |> Set.insert Banana\n |> Set.insert Apple\n |> Set.insert Pear\n\nexpect Set.fromList [Pear, Apple, Banana] == values\n```\n",
),
},
),
DocDef(
DocDef {
name: "union",
symbol: `Set.union`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Combine two `Set` collection by keeping the\n[union](https://en.wikipedia.org/wiki/Union_(set_theory))\nof all the values pairs. This means that all of the values in both `Set`s\nwill be combined.\n```\nset1 = Set.single Left\nset2 = Set.single Right\n\nexpect Set.union set1 set2 == Set.fromList [Left, Right]\n```\n",
),
},
),
DocDef(
DocDef {
name: "intersection",
symbol: `Set.intersection`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Combine two `Set`s by keeping the [intersection](https://en.wikipedia.org/wiki/Intersection_(set_theory))\nof all the values pairs. This means that we keep only those values that are\nin both `Set`s.\n```\nset1 = Set.fromList [Left, Other]\nset2 = Set.fromList [Left, Right]\n\nexpect Set.intersection set1 set2 == Set.single Left\n```\n",
),
},
),
DocDef(
DocDef {
name: "difference",
symbol: `Set.difference`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Remove the values in the first `Set` that are also in the second `Set`\nusing the [set difference](https://en.wikipedia.org/wiki/Complement_(set_theory)#Relative_complement)\nof the values. This means that we will be left with only those values that\nare in the first and not in the second.\n```\nfirst = Set.fromList [Left, Right, Up, Down]\nsecond = Set.fromList [Left, Right]\n\nexpect Set.difference first second == Set.fromList [Up, Down]\n```\n",
),
},
),
DocDef(
DocDef {
name: "walk",
symbol: `Set.walk`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"k",
),
],
output: BoundVariable(
"state",
),
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Iterate through the values of a given `Set` and build a value.\n```\nvalues = Set.fromList [\"March\", \"April\", \"May\"]\n\nstartsWithLetterM = \\month ->\n when Str.toUtf8 month is\n ['M', ..] -> Bool.true\n _ -> Bool.false\n\nreduce = \\state, k ->\n if startsWithLetterM k then\n state + 1\n else\n state\n\nresult = Set.walk values 0 reduce\n\nexpect result == 2\n```\n",
),
},
),
DocDef(
DocDef {
name: "map",
symbol: `Set.map`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: BoundVariable(
"b",
),
},
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"b",
),
],
},
},
docs: Some(
"Convert each value in the set to something new, by calling a conversion\nfunction on each of them which receives the old value. Then return a\nnew set containing the converted values.\n",
),
},
),
DocDef(
DocDef {
name: "joinMap",
symbol: `Set.joinMap`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"a",
),
],
},
Function {
args: [
BoundVariable(
"a",
),
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"b",
),
],
},
},
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"b",
),
],
},
},
docs: Some(
"Like [Set.map], except the transformation function wraps the return value\nin a set. At the end, all the sets get joined together\n(using [Set.union]) into one set.\n\nYou may know a similar function named `concatMap` in other languages.\n",
),
},
),
DocDef(
DocDef {
name: "walkUntil",
symbol: `Set.walkUntil`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
BoundVariable(
"state",
),
Function {
args: [
BoundVariable(
"state",
),
BoundVariable(
"k",
),
],
output: TagUnion {
tags: [
Tag {
name: "Continue",
values: [
BoundVariable(
"state",
),
],
},
Tag {
name: "Break",
values: [
BoundVariable(
"state",
),
],
},
],
extension: NoTypeAnn,
},
},
],
output: BoundVariable(
"state",
),
},
docs: Some(
"Iterate through the values of a given `Set` and build a value, can stop\niterating part way through the collection.\n```\nnumbers = Set.fromList [1,2,3,4,5,6,42,7,8,9,10]\n\nfind42 = \\state, k ->\n if k == 42 then\n Break FoundTheAnswer\n else\n Continue state\n\nresult = Set.walkUntil numbers NotFound find42\n\nexpect result == FoundTheAnswer\n```\n",
),
},
),
DocDef(
DocDef {
name: "keepIf",
symbol: `Set.keepIf`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
Function {
args: [
BoundVariable(
"k",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Run the given function on each element in the `Set`, and return\na `Set` with just the elements for which the function returned `Bool.true`.\n```\nexpect Set.fromList [1,2,3,4,5]\n |> Set.keepIf \\k -> k >= 3\n |> Bool.isEq (Set.fromList [3,4,5])\n```\n",
),
},
),
DocDef(
DocDef {
name: "dropIf",
symbol: `Set.dropIf`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
Function {
args: [
BoundVariable(
"k",
),
],
output: Apply {
name: "Bool",
parts: [],
},
},
],
output: Apply {
name: "Set",
parts: [
BoundVariable(
"k",
),
],
},
},
docs: Some(
"Run the given function on each element in the `Set`, and return\na `Set` with just the elements for which the function returned `Bool.false`.\n```\nexpect Set.fromList [1,2,3,4,5]\n |> Set.dropIf \\k -> k >= 3\n |> Bool.isEq (Set.fromList [1,2])\n```\n",
),
},
),
],
scope: Scope {
aliases: VecMap {
keys: [
`Num.Binary32`,
`Num.F32`,
`Num.FloatingPoint`,
`Inspect.Inspector`,
`Inspect.IdentId(34)`,
`Num.Signed128`,
`Bool.Bool`,
`Inspect.ElemWalker`,
`Num.Unsigned16`,
`Num.U16`,
`Num.U64`,
`Num.Binary64`,
`Num.Int`,
`Num.Unsigned8`,
`Dict.BadKey`,
`Num.Frac`,
`Num.U32`,
`Num.Signed64`,
`Num.Signed8`,
`Num.I64`,
`Num.I16`,
`Num.U8`,
`Num.Unsigned128`,
`Dict.Dict`,
`Num.I8`,
`Inspect.KeyValWalker`,
`Num.Num`,
`Num.Decimal`,
`Num.Unsigned32`,
`Num.Signed32`,
`Num.Integer`,
`Num.I128`,
`Num.U128`,
`Dict.Bucket`,
`Num.I32`,
`Num.Signed16`,
`Num.Unsigned64`,
`Num.F64`,
`Dict.LowLevelHasher`,
`Num.Dec`,
`Set.Set`,
],
values: [
Alias {
region: @17634-17642,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19444-19447,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17650-17669,
type_variables: [
@17664-17669 AliasVar {
name: 'range',
var: 67,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <67>,
kind: Opaque,
},
Alias {
region: @3006-3017,
type_variables: [
@3016-3017 AliasVar {
name: 'f',
var: 74,
opt_bound_abilities: Some(
AbilitySet(
[
`Inspect.InspectFormatter`,
],
),
),
},
],
lambda_set_variables: [
LambdaSet(
<75>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn(<74> |<75>| -> <74>),
kind: Opaque,
},
Alias {
region: @3808-3820,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'data' : RigidRequired((`Str.Str`)) },
kind: Opaque,
},
Alias {
region: @17074-17083,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @1780-1784,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: ['False', 'True'],
kind: Opaque,
},
Alias {
region: @802-834,
type_variables: [
@813-818 AliasVar {
name: 'state',
var: 70,
opt_bound_abilities: None,
},
@819-829 AliasVar {
name: 'collection',
var: 69,
opt_bound_abilities: None,
},
@830-834 AliasVar {
name: 'elem',
var: 71,
opt_bound_abilities: None,
},
],
lambda_set_variables: [
LambdaSet(
<72>,
),
LambdaSet(
<73>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn(<69>, <70>, Fn(<70>, <71> |<72>| -> <70>) |<73>| -> <70>),
kind: Structural,
},
Alias {
region: @17202-17212,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17544-17547,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17482-17485,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17619-17627,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @12895-12904,
type_variables: [
@12899-12904 AliasVar {
name: 'range',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` <64>[ but actually <64> ])[ but actually (Alias `Num.Integer` <64>[ but actually <64> ]) ]),
kind: Structural,
},
Alias {
region: @17219-17228,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @40231-40237,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (DelayedAlias `Num.U64`),
kind: Opaque,
},
Alias {
region: @17034-17044,
type_variables: [
@17039-17044 AliasVar {
name: 'range',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` <65>[ but actually <65> ])[ but actually (Alias `Num.FloatingPoint` <65>[ but actually <65> ]) ]),
kind: Structural,
},
Alias {
region: @17513-17516,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17090-17098,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17135-17142,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17291-17294,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17349-17352,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17575-17577,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17150-17161,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @3079-3087,
type_variables: [
@3084-3085 AliasVar {
name: 'k',
var: 63,
opt_bound_abilities: Some(
AbilitySet(
[
`Hash.Hash`,
`Bool.Eq`,
],
),
),
},
@3086-3087 AliasVar {
name: 'v',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'buckets' : RigidRequired((`List.List` @3112-3118 (Alias `Dict.Bucket`[ but actually { 'distAndFingerprint' : RigidRequired((DelayedAlias `Num.U32`))'dataIndex' : RigidRequired((DelayedAlias `Num.U32`)), } ])))'shifts' : RigidRequired((DelayedAlias `Num.U8`)), 'maxBucketCapacity' : RigidRequired((DelayedAlias `Num.U64`)), 'maxLoadFactor' : RigidRequired((DelayedAlias `Num.F32`)), 'data' : RigidRequired((`List.List` @3136-3142 ( <63><64>, ))), },
kind: Opaque,
},
Alias {
region: @17431-17433,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Int` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ]) ]) ]),
kind: Structural,
},
Alias {
region: @707-744,
type_variables: [
@720-725 AliasVar {
name: 'state',
var: 64,
opt_bound_abilities: None,
},
@726-736 AliasVar {
name: 'collection',
var: 63,
opt_bound_abilities: None,
},
@737-740 AliasVar {
name: 'key',
var: 65,
opt_bound_abilities: None,
},
@741-744 AliasVar {
name: 'val',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [
LambdaSet(
<67>,
),
LambdaSet(
<68>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn(<63>, <64>, Fn(<64>, <65>, <66> |<67>| -> <64>) |<68>| -> <64>),
kind: Structural,
},
Alias {
region: @5228-5237,
type_variables: [
@5232-5237 AliasVar {
name: 'range',
var: 63,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <63>,
kind: Opaque,
},
Alias {
region: @17605-17612,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17185-17195,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17105-17113,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17236-17249,
type_variables: [
@17244-17249 AliasVar {
name: 'range',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <66>,
kind: Opaque,
},
Alias {
region: @17260-17264,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17449-17453,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @25758-25764,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'distAndFingerprint' : RigidRequired((DelayedAlias `Num.U32`))'dataIndex' : RigidRequired((DelayedAlias `Num.U32`)), },
kind: Structural,
},
Alias {
region: @17320-17323,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17120-17128,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17168-17178,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19085-19088,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @41841-41855,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'state' : RigidRequired((DelayedAlias `Num.U64`))'initializedSeed' : RigidRequired((DelayedAlias `Num.U64`)), },
kind: Opaque,
},
Alias {
region: @23363-23366,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @776-781,
type_variables: [
@780-781 AliasVar {
name: 'k',
var: 63,
opt_bound_abilities: Some(
AbilitySet(
[
`Hash.Hash`,
`Bool.Eq`,
],
),
),
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (DelayedAlias `Dict.Dict` @795-796 OptAbleType { typ: <63>, opt_abilities: Some(AbilitySet([`Hash.Hash`, `Bool.Eq`])) } @797-799 OptAbleType { typ: {}, opt_abilities: None }),
kind: Opaque,
},
],
},
abilities_store: IAbilitiesStore {
members_of_ability: {
`Hash.Hasher`: [
`Hash.addBytes`,
`Hash.addU8`,
`Hash.addU16`,
`Hash.addU32`,
`Hash.addU64`,
`Hash.addU128`,
`Hash.complete`,
],
`Inspect.Inspect`: [
`Inspect.toInspector`,
],
`Inspect.InspectFormatter`: [
`Inspect.init`,
`Inspect.tag`,
`Inspect.tuple`,
`Inspect.record`,
`Inspect.bool`,
`Inspect.str`,
`Inspect.list`,
`Inspect.set`,
`Inspect.dict`,
`Inspect.opaque`,
`Inspect.function`,
`Inspect.u8`,
`Inspect.i8`,
`Inspect.u16`,
`Inspect.i16`,
`Inspect.u32`,
`Inspect.i32`,
`Inspect.u64`,
`Inspect.i64`,
`Inspect.u128`,
`Inspect.i128`,
`Inspect.f32`,
`Inspect.f64`,
`Inspect.dec`,
],
`Bool.Eq`: [
`Bool.isEq`,
],
`Hash.Hash`: [
`Hash.hash`,
],
},
specialization_to_root: {
`Inspect.IdentId(35)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.init`,
},
`Inspect.IdentId(55)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i128`,
},
`Inspect.IdentId(45)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.function`,
},
`Inspect.IdentId(42)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.bool`,
},
`Inspect.IdentId(57)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.f64`,
},
`Inspect.IdentId(54)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u128`,
},
`Inspect.IdentId(41)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.record`,
},
`Set.isEq`: ImplKey {
opaque: `Set.Set`,
ability_member: `Bool.isEq`,
},
`Inspect.IdentId(44)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.opaque`,
},
`Set.hashSet`: ImplKey {
opaque: `Set.Set`,
ability_member: `Hash.hash`,
},
`Set.toInspectorSet`: ImplKey {
opaque: `Set.Set`,
ability_member: `Inspect.toInspector`,
},
`Inspect.IdentId(50)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u32`,
},
`Inspect.IdentId(58)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.dec`,
},
`Inspect.IdentId(46)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u8`,
},
`Inspect.IdentId(38)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.dict`,
},
`Inspect.IdentId(56)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.f32`,
},
`Inspect.IdentId(53)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i64`,
},
`Bool.boolIsEq`: ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
},
`Inspect.IdentId(37)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.set`,
},
`Inspect.IdentId(43)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.str`,
},
`Inspect.IdentId(47)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i8`,
},
`Inspect.IdentId(48)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u16`,
},
`Inspect.IdentId(52)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u64`,
},
`Inspect.IdentId(51)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i32`,
},
`Inspect.IdentId(39)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.tag`,
},
`Inspect.IdentId(40)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.tuple`,
},
`Inspect.IdentId(49)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i16`,
},
`Inspect.IdentId(36)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.list`,
},
},
ability_members: {
`Inspect.i16`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2355-2358,
typ: Imported,
},
`Bool.isEq`: AbilityMemberData {
parent_ability: `Bool.Eq`,
region: @1635-1639,
typ: Imported,
},
`Hash.addU128`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1614-1621,
typ: Imported,
},
`Inspect.function`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2095-2103,
typ: Imported,
},
`Inspect.set`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1499-1502,
typ: Imported,
},
`Inspect.f32`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2814-2817,
typ: Imported,
},
`Inspect.i8`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2227-2229,
typ: Imported,
},
`Inspect.u64`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2550-2553,
typ: Imported,
},
`Inspect.i32`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2485-2488,
typ: Imported,
},
`Inspect.u128`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2680-2684,
typ: Imported,
},
`Inspect.tag`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @977-980,
typ: Imported,
},
`Inspect.opaque`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1880-1886,
typ: Imported,
},
`Inspect.u32`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2420-2423,
typ: Imported,
},
`Inspect.u8`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2164-2166,
typ: Imported,
},
`Inspect.i128`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2747-2751,
typ: Imported,
},
`Inspect.dict`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1614-1618,
typ: Imported,
},
`Inspect.list`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1381-1385,
typ: Imported,
},
`Inspect.init`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @921-925,
typ: Imported,
},
`Hash.addU32`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1429-1435,
typ: Imported,
},
`Inspect.toInspector`: AbilityMemberData {
parent_ability: `Inspect.Inspect`,
region: @3291-3302,
typ: Imported,
},
`Inspect.f64`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2879-2882,
typ: Imported,
},
`Hash.addU8`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1247-1252,
typ: Imported,
},
`Hash.addU16`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1337-1343,
typ: Imported,
},
`Hash.addU64`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1521-1527,
typ: Imported,
},
`Inspect.str`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1315-1318,
typ: Imported,
},
`Inspect.dec`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2944-2947,
typ: Imported,
},
`Hash.hash`: AbilityMemberData {
parent_ability: `Hash.Hash`,
region: @742-746,
typ: Imported,
},
`Inspect.bool`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1248-1252,
typ: Imported,
},
`Inspect.u16`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2290-2293,
typ: Imported,
},
`Inspect.record`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1144-1150,
typ: Imported,
},
`Inspect.i64`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2615-2618,
typ: Imported,
},
`Inspect.tuple`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1062-1067,
typ: Imported,
},
`Hash.complete`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1761-1769,
typ: Imported,
},
`Hash.addBytes`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1150-1158,
typ: Imported,
},
},
declared_implementations: {
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i16`,
}: Impl(
`Inspect.IdentId(49)`,
),
ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
}: Impl(
`Bool.boolIsEq`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.str`,
}: Impl(
`Inspect.IdentId(43)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u32`,
}: Impl(
`Inspect.IdentId(50)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u128`,
}: Impl(
`Inspect.IdentId(54)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.function`,
}: Impl(
`Inspect.IdentId(45)`,
),
ImplKey {
opaque: `Set.Set`,
ability_member: `Bool.isEq`,
}: Impl(
`Set.IdentId(25)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.dec`,
}: Impl(
`Inspect.IdentId(58)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.init`,
}: Impl(
`Inspect.IdentId(35)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.bool`,
}: Impl(
`Inspect.IdentId(42)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.opaque`,
}: Impl(
`Inspect.IdentId(44)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.f64`,
}: Impl(
`Inspect.IdentId(57)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u64`,
}: Impl(
`Inspect.IdentId(52)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i32`,
}: Impl(
`Inspect.IdentId(51)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i64`,
}: Impl(
`Inspect.IdentId(53)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.tag`,
}: Impl(
`Inspect.IdentId(39)`,
),
ImplKey {
opaque: `Set.Set`,
ability_member: `Inspect.toInspector`,
}: Impl(
`Set.IdentId(27)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.dict`,
}: Impl(
`Inspect.IdentId(38)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u8`,
}: Impl(
`Inspect.IdentId(46)`,
),
ImplKey {
opaque: `Set.Set`,
ability_member: `Hash.hash`,
}: Impl(
`Set.IdentId(26)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.tuple`,
}: Impl(
`Inspect.IdentId(40)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.f32`,
}: Impl(
`Inspect.IdentId(56)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.list`,
}: Impl(
`Inspect.IdentId(36)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i128`,
}: Impl(
`Inspect.IdentId(55)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.set`,
}: Impl(
`Inspect.IdentId(37)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i8`,
}: Impl(
`Inspect.IdentId(47)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u16`,
}: Impl(
`Inspect.IdentId(48)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.record`,
}: Impl(
`Inspect.IdentId(41)`,
),
},
specializations: {},
next_specialization_id: 14,
resolved_specializations: {},
},
home: Set,
exposed_ident_count: 25,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
@502-506,
),
(
Ident(
IdentStr {
string: "Eq",
},
),
`Bool.Eq`,
@481-483,
),
(
Ident(
IdentStr {
string: "Hash",
},
),
`Hash.Hash`,
@546-550,
),
(
Ident(
IdentStr {
string: "U64",
},
),
`Num.U64`,
@524-527,
),
(
Ident(
IdentStr {
string: "Hasher",
},
),
`Hash.Hasher`,
@552-558,
),
(
Ident(
IdentStr {
string: "Bool",
},
),
`Bool.Bool`,
@475-479,
),
(
Ident(
IdentStr {
string: "InspectFormatter",
},
),
`Inspect.InspectFormatter`,
@600-616,
),
(
Ident(
IdentStr {
string: "Inspector",
},
),
`Inspect.Inspector`,
@589-598,
),
(
Ident(
IdentStr {
string: "Inspect",
},
),
`Inspect.Inspect`,
@580-587,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
83,
101,
116,
101,
109,
112,
116,
121,
115,
105,
110,
103,
108,
101,
108,
101,
110,
105,
110,
115,
101,
114,
116,
114,
101,
109,
111,
118,
101,
117,
110,
105,
111,
110,
100,
105,
102,
102,
101,
114,
101,
110,
99,
101,
105,
110,
116,
101,
114,
115,
101,
99,
116,
105,
111,
110,
116,
111,
76,
105,
115,
116,
102,
114,
111,
109,
76,
105,
115,
116,
119,
97,
108,
107,
119,
97,
108,
107,
85,
110,
116,
105,
108,
35,
119,
97,
108,
107,
95,
117,
115,
101,
114,
95,
102,
117,
110,
99,
116,
105,
111,
110,
99,
111,
110,
116,
97,
105,
110,
115,
116,
111,
68,
105,
99,
116,
99,
97,
112,
97,
99,
105,
116,
121,
105,
115,
69,
109,
112,
116,
121,
109,
97,
112,
106,
111,
105,
110,
77,
97,
112,
107,
101,
101,
112,
73,
102,
100,
114,
111,
112,
73,
102,
119,
105,
116,
104,
67,
97,
112,
97,
99,
105,
116,
121,
114,
101,
115,
101,
114,
118,
101,
114,
101,
108,
101,
97,
115,
101,
69,
120,
99,
101,
115,
115,
67,
97,
112,
97,
99,
105,
116,
121,
105,
115,
69,
113,
104,
97,
115,
104,
83,
101,
116,
116,
111,
73,
110,
115,
112,
101,
99,
116,
111,
114,
83,
101,
116,
69,
113,
72,
97,
115,
104,
68,
105,
99,
116,
120,
115,
121,
115,
51,
51,
101,
108,
101,
109,
51,
53,
51,
54,
104,
97,
115,
104,
101,
114,
105,
110,
110,
101,
114,
115,
101,
116,
52,
48,
102,
109,
116,
99,
97,
112,
100,
105,
99,
116,
114,
101,
113,
117,
101,
115,
116,
101,
100,
107,
101,
121,
108,
105,
115,
116,
53,
56,
107,
100,
105,
99,
116,
49,
100,
105,
99,
116,
50,
115,
116,
97,
116,
101,
115,
116,
101,
112,
54,
57,
115,
116,
114,
97,
110,
115,
102,
111,
114,
109,
105,
110,
105,
116,
55,
53,
97,
110,
115,
119,
101,
114,
56,
49,
56,
55,
112,
114,
101,
100,
105,
99,
97,
116,
101,
57,
50,
57,
54,
97,
99,
116,
117,
97,
108,
101,
120,
112,
101,
99,
116,
101,
100,
102,
105,
114,
115,
116,
115,
101,
99,
111,
110,
100,
98,
97,
115,
101,
120,
111,
114,
100,
101,
114,
79,
110,
101,
111,
114,
100,
101,
114,
84,
119,
111,
119,
114,
97,
112,
112,
101,
114,
79,
110,
101,
119,
114,
97,
112,
112,
101,
114,
84,
119,
111,
49,
49,
55,
49,
49,
57,
49,
50,
49,
49,
50,
50,
49,
50,
51,
49,
50,
52,
49,
50,
53,
49,
50,
54,
49,
50,
55,
49,
50,
56,
49,
50,
57,
49,
51,
48,
],
lengths: [
Interned(3),
Interned(5),
Interned(6),
Interned(3),
Interned(6),
Interned(6),
Interned(5),
Interned(10),
Interned(12),
Interned(6),
Interned(8),
Interned(4),
Interned(9),
Interned(19),
Interned(8),
Interned(6),
Interned(8),
Interned(7),
Interned(3),
Interned(7),
Interned(6),
Interned(6),
Interned(12),
Interned(7),
Interned(21),
Interned(4),
Interned(7),
Interned(14),
Interned(2),
Interned(4),
Interned(4),
Interned(2),
Interned(2),
Generated(2),
Interned(4),
Generated(2),
Generated(2),
Interned(6),
Interned(5),
Interned(3),
Generated(2),
Interned(3),
Interned(3),
Interned(4),
Interned(9),
Interned(4),
Interned(3),
Interned(4),
Interned(3),
Interned(4),
Interned(4),
Interned(4),
Interned(4),
Interned(3),
Interned(4),
Interned(3),
Interned(4),
Interned(4),
Generated(2),
Interned(1),
Interned(5),
Interned(5),
Interned(5),
Interned(5),
Interned(5),
Interned(5),
Interned(4),
Interned(5),
Interned(4),
Generated(2),
Interned(1),
Interned(1),
Interned(3),
Interned(9),
Interned(4),
Generated(2),
Interned(6),
Interned(1),
Interned(3),
Interned(9),
Interned(4),
Generated(2),
Interned(6),
Interned(1),
Interned(4),
Interned(5),
Interned(4),
Generated(2),
Interned(1),
Interned(1),
Interned(4),
Interned(9),
Generated(2),
Interned(1),
Interned(4),
Interned(9),
Generated(2),
Interned(1),
Interned(6),
Interned(8),
Interned(6),
Interned(5),
Interned(6),
Interned(8),
Interned(5),
Interned(6),
Interned(8),
Interned(5),
Interned(6),
Interned(8),
Interned(4),
Interned(8),
Interned(1),
Interned(8),
Interned(8),
Interned(10),
Interned(10),
Generated(3),
Interned(1),
Generated(3),
Interned(1),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
Generated(3),
],
offsets: [
0,
3,
8,
14,
17,
23,
29,
34,
44,
56,
62,
70,
74,
83,
102,
110,
116,
124,
131,
134,
141,
147,
153,
165,
172,
193,
197,
204,
218,
220,
224,
228,
230,
232,
234,
238,
240,
242,
248,
253,
256,
258,
261,
264,
268,
264,
277,
264,
277,
264,
264,
264,
264,
277,
264,
277,
264,
280,
284,
286,
287,
292,
287,
292,
287,
292,
264,
297,
302,
306,
308,
286,
253,
309,
318,
322,
324,
286,
253,
309,
318,
330,
324,
286,
264,
297,
302,
332,
308,
286,
264,
334,
343,
286,
264,
334,
345,
286,
347,
353,
347,
361,
366,
353,
361,
366,
353,
361,
366,
353,
372,
353,
376,
377,
385,
393,
403,
413,
286,
416,
286,
419,
422,
425,
428,
431,
434,
437,
440,
443,
446,
],
strings: [
"Set",
"empty",
"single",
"len",
"insert",
"remove",
"union",
"difference",
"intersection",
"toList",
"fromList",
"walk",
"walkUntil",
"#walk_user_function",
"contains",
"toDict",
"capacity",
"isEmpty",
"map",
"joinMap",
"keepIf",
"dropIf",
"withCapacity",
"reserve",
"releaseExcessCapacity",
"isEq",
"hashSet",
"toInspectorSet",
"Eq",
"Hash",
"Dict",
"xs",
"ys",
"33",
"elem",
"35",
"36",
"hasher",
"inner",
"set",
"40",
"fmt",
"cap",
"dict",
"requested",
"dict",
"key",
"dict",
"key",
"dict",
"dict",
"dict",
"dict",
"key",
"dict",
"key",
"dict",
"list",
"58",
"k",
"dict1",
"dict2",
"dict1",
"dict2",
"dict1",
"dict2",
"dict",
"state",
"step",
"69",
"s",
"k",
"set",
"transform",
"init",
"75",
"answer",
"k",
"set",
"transform",
"init",
"81",
"answer",
"k",
"dict",
"state",
"step",
"87",
"s",
"k",
"dict",
"predicate",
"92",
"k",
"dict",
"predicate",
"96",
"k",
"actual",
"expected",
"actual",
"first",
"second",
"expected",
"first",
"second",
"expected",
"first",
"second",
"expected",
"base",
"expected",
"x",
"orderOne",
"orderTwo",
"wrapperOne",
"wrapperTwo",
"117",
"k",
"119",
"k",
"121",
"122",
"123",
"124",
"125",
"126",
"127",
"128",
"129",
"130",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffee117870,
head: 000000,
bits: 131,
capacity: 192,
} [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
regions: [
@776-828,
@1789-1794,
@2794-2800,
@3753-3756,
@3108-3114,
@4804-4810,
@6243-6248,
@7296-7306,
@6709-6721,
@5486-5492,
@5784-5792,
@7864-7868,
@9232-9241,
…,
@5214-5222,
…,
@4017-4025,
@4214-4221,
@8169-8172,
@8590-8597,
@9634-9640,
@10031-10037,
@2013-2025,
@2161-2168,
@2527-2548,
@1046-1050,
@1352-1359,
@1517-1531,
…,
…,
…,
@1054-1056,
@1058-1060,
…,
@1156-1160,
…,
…,
@1363-1369,
@1376-1381,
@1535-1538,
…,
@1546-1549,
@2029-2032,
@2177-2181,
@2183-2192,
@2557-2561,
@2804-2807,
@3123-3127,
@3129-3132,
@3765-3769,
@4034-4038,
@4230-4234,
@4819-4823,
@4825-4828,
@5231-5235,
@5237-5240,
@5501-5505,
@5796-5800,
…,
@5830-5831,
@6257-6262,
@6269-6274,
@6730-6735,
@6742-6747,
@7315-7320,
@7327-7332,
@7877-7881,
@7883-7888,
@7890-7894,
…,
@7925-7926,
@7928-7929,
@8176-8179,
@8181-8190,
@8198-8202,
…,
@8253-8259,
@8261-8262,
@8601-8604,
@8606-8615,
@8623-8627,
…,
@8705-8711,
@8713-8714,
@9250-9254,
@9256-9261,
@9263-9267,
…,
@9303-9304,
@9306-9307,
@9649-9653,
@9655-9664,
…,
@9698-9699,
@10046-10050,
@10052-10061,
…,
@10095-10096,
@3227-3233,
@3354-3362,
@4325-4331,
@10131-10136,
@10226-10232,
@10303-10311,
@10419-10424,
@10514-10520,
@10591-10599,
@10707-10712,
@10757-10763,
@10828-10836,
@10964-10968,
@11058-11066,
@11174-11175,
@11440-11448,
@11516-11524,
@11600-11610,
@11700-11710,
…,
@11854-11855,
…,
@11968-11969,
…,
…,
…,
…,
…,
…,
…,
…,
…,
…,
],
home: Set,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`Set.Set`,
`Set.empty`,
`Set.withCapacity`,
`Set.reserve`,
`Set.releaseExcessCapacity`,
`Set.single`,
`Set.walk`,
`Set.walkUntil`,
`Set.keepIf`,
`Set.dropIf`,
`Set.insert`,
`Set.len`,
`Set.isEmpty`,
`Set.capacity`,
`Set.remove`,
`Set.contains`,
`Set.toList`,
`Set.fromList`,
`Set.union`,
`Set.intersection`,
`Set.difference`,
`Set.map`,
`Set.joinMap`,
],
},
},
<<docs:
"An interface for docs tests\n"
docs>>
<<docs:
Some(
"This is a user\n",
)
docs>>
<<docs:
Some(
"Makes a user\n",
)
docs>>
<<docs:
Some(
"gets the users name\n",
)
docs>>
adding docs for "tests/fixtures/build/no_deps/Docs.roc",
docs ModuleDocumentation {
name: "Docs",
entries: [
DetachedDoc(
"An interface for docs tests\n",
),
DocDef(
DocDef {
name: "User",
symbol: `find module name somehow?.User`,
type_vars: [],
type_annotation: NoTypeAnn,
docs: Some(
"This is a user\n",
),
},
),
DocDef(
DocDef {
name: "makeUser",
symbol: `find module name somehow?.makeUser`,
type_vars: [],
type_annotation: Function {
args: [
Apply {
name: "Str",
parts: [],
},
],
output: Apply {
name: "User",
parts: [],
},
},
docs: Some(
"Makes a user\n",
),
},
),
],
scope: Scope {
aliases: VecMap {
keys: [
`Num.Binary32`,
`Num.F32`,
`Num.FloatingPoint`,
`Str.Utf8ByteProblem`,
`Inspect.Inspector`,
`Decode.DecodeError`,
`Inspect.IdentId(34)`,
`Num.Signed128`,
`Bool.Bool`,
`Inspect.ElemWalker`,
`Decode.DecodeResult`,
`Num.Unsigned16`,
`Num.U16`,
`Num.U64`,
`Num.Binary64`,
`Num.Int`,
`Set.Set`,
`Num.Unsigned8`,
`Num.Frac`,
`Num.U32`,
`Num.Signed64`,
`Num.Signed8`,
`Num.I64`,
`Num.U8`,
`Num.I16`,
`Result.Result`,
`Dict.BadKey`,
`Num.Unsigned128`,
`Num.I8`,
`Num.Num`,
`Inspect.KeyValWalker`,
`Str.Utf8Problem`,
`Num.Decimal`,
`Num.Unsigned32`,
`Num.Signed32`,
`Dict.Dict`,
`Num.Integer`,
`Num.I128`,
`Num.U128`,
`Dict.Bucket`,
`Decode.Decoder`,
`Num.I32`,
`Num.Signed16`,
`Num.Unsigned64`,
`Num.F64`,
`Encode.Encoder`,
`Num.Dec`,
`Str.IdentId(49)`,
`Dict.LowLevelHasher`,
`find module name somehow?.User`,
],
values: [
Alias {
region: @17634-17642,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19444-19447,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17650-17669,
type_variables: [
@17664-17669 AliasVar {
name: 'range',
var: 67,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <67>,
kind: Opaque,
},
Alias {
region: @26725-26740,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<63>,
kind: Structural,
},
Alias {
region: @3006-3017,
type_variables: [
@3016-3017 AliasVar {
name: 'f',
var: 74,
opt_bound_abilities: Some(
AbilitySet(
[
`Inspect.InspectFormatter`,
],
),
),
},
],
lambda_set_variables: [
LambdaSet(
<75>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn(<74> |<75>| -> <74>),
kind: Opaque,
},
Alias {
region: @908-919,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['TooShort']<63>,
kind: Structural,
},
Alias {
region: @3808-3820,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'data' : RigidRequired((`Str.Str`)) },
kind: Opaque,
},
Alias {
region: @17074-17083,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @1780-1784,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: ['False', 'True'],
kind: Opaque,
},
Alias {
region: @802-834,
type_variables: [
@813-818 AliasVar {
name: 'state',
var: 70,
opt_bound_abilities: None,
},
@819-829 AliasVar {
name: 'collection',
var: 69,
opt_bound_abilities: None,
},
@830-834 AliasVar {
name: 'elem',
var: 71,
opt_bound_abilities: None,
},
],
lambda_set_variables: [
LambdaSet(
<72>,
),
LambdaSet(
<73>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn(<69>, <70>, Fn(<70>, <71> |<72>| -> <70>) |<73>| -> <70>),
kind: Structural,
},
Alias {
region: @1320-1336,
type_variables: [
@1333-1336 AliasVar {
name: 'val',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [
65,
69,
],
recursion_variables: {},
typ: { 'result' : RigidRequired((DelayedAlias `Result.Result` @1357-1360 OptAbleType { typ: <64>, opt_abilities: None } @1361-1372 OptAbleType { typ: (Alias `Decode.DecodeError`[ but actually ['TooShort']<69> ]), opt_abilities: None } `0@<65>))'rest' : RigidRequired((`List.List` @1386-1388 (DelayedAlias `Num.U8`))), },
kind: Structural,
},
Alias {
region: @17202-17212,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17544-17547,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17482-17485,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17619-17627,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @12895-12904,
type_variables: [
@12899-12904 AliasVar {
name: 'range',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` <64>[ but actually <64> ])[ but actually (Alias `Num.Integer` <64>[ but actually <64> ]) ]),
kind: Structural,
},
Alias {
region: @776-781,
type_variables: [
@780-781 AliasVar {
name: 'k',
var: 63,
opt_bound_abilities: Some(
AbilitySet(
[
`Hash.Hash`,
`Bool.Eq`,
],
),
),
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (DelayedAlias `Dict.Dict` @795-796 OptAbleType { typ: <63>, opt_abilities: Some(AbilitySet([`Hash.Hash`, `Bool.Eq`])) } @797-799 OptAbleType { typ: {}, opt_abilities: None }),
kind: Opaque,
},
Alias {
region: @17219-17228,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17034-17044,
type_variables: [
@17039-17044 AliasVar {
name: 'range',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` <65>[ but actually <65> ])[ but actually (Alias `Num.FloatingPoint` <65>[ but actually <65> ]) ]),
kind: Structural,
},
Alias {
region: @17513-17516,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17090-17098,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17135-17142,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17291-17294,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17575-17577,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17349-17352,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @241-254,
type_variables: [
@248-250 AliasVar {
name: 'ok',
var: 64,
opt_bound_abilities: None,
},
@251-254 AliasVar {
name: 'err',
var: 65,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [
63,
],
recursion_variables: {},
typ: ['Err' <65>, 'Ok' <64>]<63>,
kind: Structural,
},
Alias {
region: @40231-40237,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (DelayedAlias `Num.U64`),
kind: Opaque,
},
Alias {
region: @17150-17161,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17431-17433,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Int` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ]) ]) ]),
kind: Structural,
},
Alias {
region: @5228-5237,
type_variables: [
@5232-5237 AliasVar {
name: 'range',
var: 63,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <63>,
kind: Opaque,
},
Alias {
region: @707-744,
type_variables: [
@720-725 AliasVar {
name: 'state',
var: 64,
opt_bound_abilities: None,
},
@726-736 AliasVar {
name: 'collection',
var: 63,
opt_bound_abilities: None,
},
@737-740 AliasVar {
name: 'key',
var: 65,
opt_bound_abilities: None,
},
@741-744 AliasVar {
name: 'val',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [
LambdaSet(
<67>,
),
LambdaSet(
<68>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn(<63>, <64>, Fn(<64>, <65>, <66> |<67>| -> <64>) |<68>| -> <64>),
kind: Structural,
},
Alias {
region: @26896-26907,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
64,
],
recursion_variables: {},
typ: { 'problem' : RigidRequired((Alias `Str.Utf8ByteProblem`[ but actually ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<64> ]))'byteIndex' : RigidRequired((DelayedAlias `Num.U64`)), },
kind: Structural,
},
Alias {
region: @17605-17612,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17185-17195,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17105-17113,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @3079-3087,
type_variables: [
@3084-3085 AliasVar {
name: 'k',
var: 63,
opt_bound_abilities: Some(
AbilitySet(
[
`Hash.Hash`,
`Bool.Eq`,
],
),
),
},
@3086-3087 AliasVar {
name: 'v',
var: 64,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'buckets' : RigidRequired((`List.List` @3112-3118 (Alias `Dict.Bucket`[ but actually { 'distAndFingerprint' : RigidRequired((DelayedAlias `Num.U32`))'dataIndex' : RigidRequired((DelayedAlias `Num.U32`)), } ])))'shifts' : RigidRequired((DelayedAlias `Num.U8`)), 'maxBucketCapacity' : RigidRequired((DelayedAlias `Num.U64`)), 'maxLoadFactor' : RigidRequired((DelayedAlias `Num.F32`)), 'data' : RigidRequired((`List.List` @3136-3142 ( <63><64>, ))), },
kind: Opaque,
},
Alias {
region: @17236-17249,
type_variables: [
@17244-17249 AliasVar {
name: 'range',
var: 66,
opt_bound_abilities: None,
},
],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: <66>,
kind: Opaque,
},
Alias {
region: @17260-17264,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17449-17453,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @25758-25764,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'distAndFingerprint' : RigidRequired((DelayedAlias `Num.U32`))'dataIndex' : RigidRequired((DelayedAlias `Num.U32`)), },
kind: Structural,
},
Alias {
region: @1556-1571,
type_variables: [
@1564-1567 AliasVar {
name: 'val',
var: 67,
opt_bound_abilities: None,
},
@1568-1571 AliasVar {
name: 'fmt',
var: 66,
opt_bound_abilities: Some(
AbilitySet(
[
`Decode.DecoderFormatting`,
],
),
),
},
],
lambda_set_variables: [
LambdaSet(
<68>,
),
],
infer_ext_in_output_variables: [
70,
71,
],
recursion_variables: {},
typ: Fn((`List.List` @1580-1582 (DelayedAlias `Num.U8`)), <66> |<68>| -> (Alias `Decode.DecodeResult` <67>[ but actually { 'result' : RigidRequired((DelayedAlias `Result.Result` @1357-1360 OptAbleType { typ: <67>, opt_abilities: None } @1361-1372 OptAbleType { typ: (Alias `Decode.DecodeError`[ but actually ['TooShort']<71> ]), opt_abilities: None } `0@<70>))'rest' : RigidRequired((`List.List` @1386-1388 (DelayedAlias `Num.U8`))), } ])),
kind: Opaque,
},
Alias {
region: @17320-17323,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @17120-17128,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @17168-17178,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: [],
kind: Opaque,
},
Alias {
region: @19085-19088,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @734-745,
type_variables: [
@742-745 AliasVar {
name: 'fmt',
var: 63,
opt_bound_abilities: Some(
AbilitySet(
[
`Encode.EncoderFormatting`,
],
),
),
},
],
lambda_set_variables: [
LambdaSet(
<64>,
),
],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: Fn((`List.List` @754-756 (DelayedAlias `Num.U8`)), <63> |<64>| -> (`List.List` @770-772 (DelayedAlias `Num.U8`))),
kind: Opaque,
},
Alias {
region: @23363-23366,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ]) ]),
kind: Structural,
},
Alias {
region: @35465-35479,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [
65,
],
recursion_variables: {},
typ: { 'dProblemCode' : RigidRequired((Alias `Str.Utf8ByteProblem`[ but actually ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<65> ]))'cIsOk' : RigidRequired((DelayedAlias `Bool.Bool`)), 'aByteIndex' : RigidRequired((DelayedAlias `Num.U64`)), 'bString' : RigidRequired((`Str.Str`)), },
kind: Structural,
},
Alias {
region: @41841-41855,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'state' : RigidRequired((DelayedAlias `Num.U64`))'initializedSeed' : RigidRequired((DelayedAlias `Num.U64`)), },
kind: Opaque,
},
Alias {
region: @112-116,
type_variables: [],
lambda_set_variables: [],
infer_ext_in_output_variables: [],
recursion_variables: {},
typ: { 'name' : RigidRequired((`Str.Str`)) },
kind: Structural,
},
],
},
abilities_store: IAbilitiesStore {
members_of_ability: {
`Hash.Hash`: [
`Hash.hash`,
],
`Decode.DecoderFormatting`: [
`Decode.u8`,
`Decode.u16`,
`Decode.u32`,
`Decode.u64`,
`Decode.u128`,
`Decode.i8`,
`Decode.i16`,
`Decode.i32`,
`Decode.i64`,
`Decode.i128`,
`Decode.f32`,
`Decode.f64`,
`Decode.dec`,
`Decode.bool`,
`Decode.string`,
`Decode.list`,
`Decode.record`,
`Decode.tuple`,
],
`Inspect.Inspect`: [
`Inspect.toInspector`,
],
`Encode.Encoding`: [
`Encode.toEncoder`,
],
`Hash.Hasher`: [
`Hash.addBytes`,
`Hash.addU8`,
`Hash.addU16`,
`Hash.addU32`,
`Hash.addU64`,
`Hash.addU128`,
`Hash.complete`,
],
`Encode.EncoderFormatting`: [
`Encode.u8`,
`Encode.u16`,
`Encode.u32`,
`Encode.u64`,
`Encode.u128`,
`Encode.i8`,
`Encode.i16`,
`Encode.i32`,
`Encode.i64`,
`Encode.i128`,
`Encode.f32`,
`Encode.f64`,
`Encode.dec`,
`Encode.bool`,
`Encode.string`,
`Encode.list`,
`Encode.record`,
`Encode.tuple`,
`Encode.tag`,
],
`Decode.Decoding`: [
`Decode.decoder`,
],
`Bool.Eq`: [
`Bool.isEq`,
],
`Inspect.InspectFormatter`: [
`Inspect.init`,
`Inspect.tag`,
`Inspect.tuple`,
`Inspect.record`,
`Inspect.bool`,
`Inspect.str`,
`Inspect.list`,
`Inspect.set`,
`Inspect.dict`,
`Inspect.opaque`,
`Inspect.function`,
`Inspect.u8`,
`Inspect.i8`,
`Inspect.u16`,
`Inspect.i16`,
`Inspect.u32`,
`Inspect.i32`,
`Inspect.u64`,
`Inspect.i64`,
`Inspect.u128`,
`Inspect.i128`,
`Inspect.f32`,
`Inspect.f64`,
`Inspect.dec`,
],
},
specialization_to_root: {
`Inspect.IdentId(35)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.init`,
},
`Inspect.IdentId(55)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i128`,
},
`Inspect.IdentId(45)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.function`,
},
`Inspect.IdentId(42)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.bool`,
},
`Inspect.IdentId(57)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.f64`,
},
`Inspect.IdentId(54)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u128`,
},
`Inspect.IdentId(41)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.record`,
},
`Inspect.IdentId(44)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.opaque`,
},
`Inspect.IdentId(50)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u32`,
},
`Inspect.IdentId(58)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.dec`,
},
`Inspect.IdentId(46)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u8`,
},
`Inspect.IdentId(38)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.dict`,
},
`Inspect.IdentId(56)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.f32`,
},
`Inspect.IdentId(53)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i64`,
},
`Bool.boolIsEq`: ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
},
`Inspect.IdentId(37)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.set`,
},
`Inspect.IdentId(43)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.str`,
},
`Inspect.IdentId(47)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i8`,
},
`Inspect.IdentId(48)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u16`,
},
`Inspect.IdentId(52)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u64`,
},
`Inspect.IdentId(51)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i32`,
},
`Inspect.IdentId(39)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.tag`,
},
`Inspect.IdentId(40)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.tuple`,
},
`Inspect.IdentId(49)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i16`,
},
`Inspect.IdentId(36)`: ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.list`,
},
},
ability_members: {
`Decode.i16`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2273-2276,
typ: Imported,
},
`Inspect.i16`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2355-2358,
typ: Imported,
},
`Decode.dec`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2665-2668,
typ: Imported,
},
`Inspect.set`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1499-1502,
typ: Imported,
},
`Encode.u128`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1236-1240,
typ: Imported,
},
`Decode.u32`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2013-2016,
typ: Imported,
},
`Decode.i128`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2468-2472,
typ: Imported,
},
`Encode.f64`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1714-1717,
typ: Imported,
},
`Inspect.i32`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2485-2488,
typ: Imported,
},
`Decode.string`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2797-2803,
typ: Imported,
},
`Encode.record`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @2089-2095,
typ: Imported,
},
`Decode.u64`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2078-2081,
typ: Imported,
},
`Inspect.i128`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2747-2751,
typ: Imported,
},
`Decode.bool`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2730-2734,
typ: Imported,
},
`Encode.i128`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1576-1580,
typ: Imported,
},
`Inspect.dec`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2944-2947,
typ: Imported,
},
`Encode.toEncoder`: AbilityMemberData {
parent_ability: `Encode.Encoding`,
region: @837-846,
typ: Imported,
},
`Hash.addU16`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1337-1343,
typ: Imported,
},
`Encode.f32`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1646-1649,
typ: Imported,
},
`Encode.tuple`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @2196-2201,
typ: Imported,
},
`Inspect.bool`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1248-1252,
typ: Imported,
},
`Encode.i8`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1306-1308,
typ: Imported,
},
`Decode.record`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @3265-3271,
typ: Imported,
},
`Encode.i16`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1372-1375,
typ: Imported,
},
`Encode.u64`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1168-1171,
typ: Imported,
},
`Encode.u8`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @966-968,
typ: Imported,
},
`Decode.i64`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2403-2406,
typ: Imported,
},
`Hash.addBytes`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1150-1158,
typ: Imported,
},
`Inspect.f32`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2814-2817,
typ: Imported,
},
`Bool.isEq`: AbilityMemberData {
parent_ability: `Bool.Eq`,
region: @1635-1639,
typ: Imported,
},
`Inspect.function`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2095-2103,
typ: Imported,
},
`Encode.u32`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1100-1103,
typ: Imported,
},
`Hash.addU128`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1614-1621,
typ: Imported,
},
`Decode.f64`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2600-2603,
typ: Imported,
},
`Inspect.i8`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2227-2229,
typ: Imported,
},
`Inspect.u64`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2550-2553,
typ: Imported,
},
`Encode.string`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1920-1926,
typ: Imported,
},
`Inspect.u128`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2680-2684,
typ: Imported,
},
`Inspect.tag`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @977-980,
typ: Imported,
},
`Decode.i8`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2210-2212,
typ: Imported,
},
`Decode.decoder`: AbilityMemberData {
parent_ability: `Decode.Decoding`,
region: @1712-1719,
typ: Imported,
},
`Decode.f32`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2535-2538,
typ: Imported,
},
`Inspect.opaque`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1880-1886,
typ: Imported,
},
`Decode.i32`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2338-2341,
typ: Imported,
},
`Inspect.u32`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2420-2423,
typ: Imported,
},
`Decode.u8`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @1885-1887,
typ: Imported,
},
`Inspect.u8`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2164-2166,
typ: Imported,
},
`Decode.u16`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @1948-1951,
typ: Imported,
},
`Encode.u16`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1032-1035,
typ: Imported,
},
`Inspect.dict`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1614-1618,
typ: Imported,
},
`Inspect.list`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1381-1385,
typ: Imported,
},
`Inspect.init`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @921-925,
typ: Imported,
},
`Encode.i32`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1440-1443,
typ: Imported,
},
`Encode.bool`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1850-1854,
typ: Imported,
},
`Encode.tag`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @2281-2284,
typ: Imported,
},
`Hash.addU32`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1429-1435,
typ: Imported,
},
`Inspect.toInspector`: AbilityMemberData {
parent_ability: `Inspect.Inspect`,
region: @3291-3302,
typ: Imported,
},
`Inspect.f64`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2879-2882,
typ: Imported,
},
`Inspect.str`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1315-1318,
typ: Imported,
},
`Encode.list`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1991-1995,
typ: Imported,
},
`Hash.addU8`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1247-1252,
typ: Imported,
},
`Decode.list`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2865-2869,
typ: Imported,
},
`Decode.tuple`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @3794-3799,
typ: Imported,
},
`Encode.dec`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1782-1785,
typ: Imported,
},
`Decode.u128`: AbilityMemberData {
parent_ability: `Decode.DecoderFormatting`,
region: @2143-2147,
typ: Imported,
},
`Encode.i64`: AbilityMemberData {
parent_ability: `Encode.EncoderFormatting`,
region: @1508-1511,
typ: Imported,
},
`Hash.addU64`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1521-1527,
typ: Imported,
},
`Hash.hash`: AbilityMemberData {
parent_ability: `Hash.Hash`,
region: @742-746,
typ: Imported,
},
`Inspect.u16`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2290-2293,
typ: Imported,
},
`Inspect.record`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1144-1150,
typ: Imported,
},
`Inspect.i64`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @2615-2618,
typ: Imported,
},
`Inspect.tuple`: AbilityMemberData {
parent_ability: `Inspect.InspectFormatter`,
region: @1062-1067,
typ: Imported,
},
`Hash.complete`: AbilityMemberData {
parent_ability: `Hash.Hasher`,
region: @1761-1769,
typ: Imported,
},
},
declared_implementations: {
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i16`,
}: Impl(
`Inspect.IdentId(49)`,
),
ImplKey {
opaque: `Bool.Bool`,
ability_member: `Bool.isEq`,
}: Impl(
`Bool.boolIsEq`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.str`,
}: Impl(
`Inspect.IdentId(43)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u32`,
}: Impl(
`Inspect.IdentId(50)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u128`,
}: Impl(
`Inspect.IdentId(54)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.function`,
}: Impl(
`Inspect.IdentId(45)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.dec`,
}: Impl(
`Inspect.IdentId(58)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.init`,
}: Impl(
`Inspect.IdentId(35)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.bool`,
}: Impl(
`Inspect.IdentId(42)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.opaque`,
}: Impl(
`Inspect.IdentId(44)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.f64`,
}: Impl(
`Inspect.IdentId(57)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u64`,
}: Impl(
`Inspect.IdentId(52)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i32`,
}: Impl(
`Inspect.IdentId(51)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i64`,
}: Impl(
`Inspect.IdentId(53)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.tag`,
}: Impl(
`Inspect.IdentId(39)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.dict`,
}: Impl(
`Inspect.IdentId(38)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u8`,
}: Impl(
`Inspect.IdentId(46)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.tuple`,
}: Impl(
`Inspect.IdentId(40)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.f32`,
}: Impl(
`Inspect.IdentId(56)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.list`,
}: Impl(
`Inspect.IdentId(36)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i128`,
}: Impl(
`Inspect.IdentId(55)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.set`,
}: Impl(
`Inspect.IdentId(37)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.i8`,
}: Impl(
`Inspect.IdentId(47)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.u16`,
}: Impl(
`Inspect.IdentId(48)`,
),
ImplKey {
opaque: `Inspect.IdentId(34)`,
ability_member: `Inspect.record`,
}: Impl(
`Inspect.IdentId(41)`,
),
},
specializations: {},
next_specialization_id: 1,
resolved_specializations: {},
},
home: find module name somehow?,
exposed_ident_count: 2,
imports: [
(
Ident(
IdentStr {
string: "Str",
},
),
`Str.Str`,
…,
),
(
Ident(
IdentStr {
string: "List",
},
),
`List.List`,
…,
),
(
Ident(
IdentStr {
string: "Box",
},
),
`Box.Box`,
…,
),
(
Ident(
IdentStr {
string: "Ok",
},
),
`Result.Ok`,
…,
),
(
Ident(
IdentStr {
string: "Err",
},
),
`Result.Err`,
…,
),
(
Ident(
IdentStr {
string: "U8",
},
),
`Num.U8`,
…,
),
(
Ident(
IdentStr {
string: "F64",
},
),
`Num.F64`,
…,
),
(
Ident(
IdentStr {
string: "Integer",
},
),
`Num.Integer`,
…,
),
(
Ident(
IdentStr {
string: "Binary32",
},
),
`Num.Binary32`,
…,
),
(
Ident(
IdentStr {
string: "DecoderFormatting",
},
),
`Decode.DecoderFormatting`,
…,
),
(
Ident(
IdentStr {
string: "I128",
},
),
`Num.I128`,
…,
),
(
Ident(
IdentStr {
string: "Signed8",
},
),
`Num.Signed8`,
…,
),
(
Ident(
IdentStr {
string: "Frac",
},
),
`Num.Frac`,
…,
),
(
Ident(
IdentStr {
string: "Decimal",
},
),
`Num.Decimal`,
…,
),
(
Ident(
IdentStr {
string: "Binary64",
},
),
`Num.Binary64`,
…,
),
(
Ident(
IdentStr {
string: "Dec",
},
),
`Num.Dec`,
…,
),
(
Ident(
IdentStr {
string: "Result",
},
),
`Result.Result`,
…,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "DecodeError",
},
),
`Decode.DecodeError`,
…,
),
(
Ident(
IdentStr {
string: "I64",
},
),
`Num.I64`,
…,
),
(
Ident(
IdentStr {
string: "U64",
},
),
`Num.U64`,
…,
),
(
Ident(
IdentStr {
string: "F32",
},
),
`Num.F32`,
…,
),
(
Ident(
IdentStr {
string: "FloatingPoint",
},
),
`Num.FloatingPoint`,
…,
),
(
Ident(
IdentStr {
string: "Eq",
},
),
`Bool.Eq`,
…,
),
(
Ident(
IdentStr {
string: "DecodeResult",
},
),
`Decode.DecodeResult`,
…,
),
(
Ident(
IdentStr {
string: "Decoding",
},
),
`Decode.Decoding`,
…,
),
(
Ident(
IdentStr {
string: "ElemWalker",
},
),
`Inspect.ElemWalker`,
…,
),
(
Ident(
IdentStr {
string: "KeyValWalker",
},
),
`Inspect.KeyValWalker`,
…,
),
(
Ident(
IdentStr {
string: "Unsigned8",
},
),
`Num.Unsigned8`,
…,
),
(
Ident(
IdentStr {
string: "Decoder",
},
),
`Decode.Decoder`,
…,
),
(
Ident(
IdentStr {
string: "Signed16",
},
),
`Num.Signed16`,
…,
),
(
Ident(
IdentStr {
string: "Encoding",
},
),
`Encode.Encoding`,
…,
),
(
Ident(
IdentStr {
string: "Signed64",
},
),
`Num.Signed64`,
…,
),
(
Ident(
IdentStr {
string: "Int",
},
),
`Num.Int`,
…,
),
(
Ident(
IdentStr {
string: "Num",
},
),
`Num.Num`,
…,
),
(
Ident(
IdentStr {
string: "Inspect",
},
),
`Inspect.Inspect`,
…,
),
(
Ident(
IdentStr {
string: "U16",
},
),
`Num.U16`,
…,
),
(
Ident(
IdentStr {
string: "InspectFormatter",
},
),
`Inspect.InspectFormatter`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
(
Ident(
IdentStr {
string: "EncoderFormatting",
},
),
`Encode.EncoderFormatting`,
…,
),
(
Ident(
IdentStr {
string: "I32",
},
),
`Num.I32`,
…,
),
(
Ident(
IdentStr {
string: "Hash",
},
),
`Hash.Hash`,
…,
),
(
Ident(
IdentStr {
string: "Hasher",
},
),
`Hash.Hasher`,
…,
),
(
Ident(
IdentStr {
string: "Unsigned32",
},
),
`Num.Unsigned32`,
…,
),
(
Ident(
IdentStr {
string: "Signed128",
},
),
`Num.Signed128`,
…,
),
(
Ident(
IdentStr {
string: "Inspector",
},
),
`Inspect.Inspector`,
…,
),
(
Ident(
IdentStr {
string: "Unsigned16",
},
),
`Num.Unsigned16`,
…,
),
(
Ident(
IdentStr {
string: "Signed32",
},
),
`Num.Signed32`,
…,
),
(
Ident(
IdentStr {
string: "U32",
},
),
`Num.U32`,
…,
),
(
Ident(
IdentStr {
string: "Unsigned128",
},
),
`Num.Unsigned128`,
…,
),
(
Ident(
IdentStr {
string: "Unsigned64",
},
),
`Num.Unsigned64`,
…,
),
(
Ident(
IdentStr {
string: "Bool",
},
),
`Bool.Bool`,
…,
),
(
Ident(
IdentStr {
string: "Encoder",
},
),
`Encode.Encoder`,
…,
),
(
Ident(
IdentStr {
string: "I16",
},
),
`Num.I16`,
…,
),
(
Ident(
IdentStr {
string: "I8",
},
),
`Num.I8`,
…,
),
(
Ident(
IdentStr {
string: "U128",
},
),
`Num.U128`,
…,
),
(
Ident(
IdentStr {
string: "Dict",
},
),
`Dict.Dict`,
…,
),
(
Ident(
IdentStr {
string: "Set",
},
),
`Set.Set`,
…,
),
],
shadows: VecMap {
keys: [],
values: [],
},
locals: ScopedIdentIds {
ident_ids: IdentIds {
interner: SmallStringInterner {
buffer: [
109,
97,
107,
101,
85,
115,
101,
114,
103,
101,
116,
78,
97,
109,
101,
85,
115,
101,
114,
83,
116,
114,
110,
97,
109,
101,
],
lengths: [
Interned(8),
Interned(7),
Interned(4),
Interned(3),
Interned(4),
],
offsets: [
0,
8,
15,
19,
22,
],
strings: [
"makeUser",
"getName",
"User",
"Str",
"name",
],
},
},
in_scope: BitVec<usize, bitvec::order::Lsb0> {
addr: 0x00007fffed7a26c0,
head: 000000,
bits: 5,
capacity: 64,
} [
1,
1,
1,
0,
0,
],
regions: [
@174-182,
@231-238,
@112-133,
…,
@186-190,
],
home: find module name somehow?,
},
ignored_locals: VecMap {
keys: [],
values: [],
},
},
exposed_symbols: VecSet {
elements: [
`find module name somehow?.makeUser`,
`find module name somehow?.getName`,
],
},
},
thread 'load_docs' panicked at 'assertion failed: `(left == right)`
Diff < left / right > :
>ModuleDocumentation {
> name: "Docs",
> entries: [
> DetachedDoc(
> "An interface for docs tests\n",
> ),
> DocDef(
> DocDef {
> name: "User",
> symbol: `find module name somehow?.IdentId(2)`,
> type_vars: [],
> type_annotation: NoTypeAnn,
> docs: Some(
> "This is a user\n",
> ),
> },
> ),
> DocDef(
> DocDef {
> name: "makeUser",
> symbol: `find module name somehow?.identity`,
> type_vars: [],
> type_annotation: Function {
> args: [
> Apply {
> name: "Str",
> parts: [],
> },
> ],
> output: Apply {
> name: "User",
> parts: [],
> },
> },
> docs: Some(
> "Makes a user\n",
> ),
> },
> ),
> ],
> scope: Scope {
> aliases: VecMap {
> keys: [
> `Num.Binary32`,
> `Num.F32`,
> `Num.FloatingPoint`,
> `Str.Utf8ByteProblem`,
> `Inspect.Inspector`,
> `Decode.DecodeError`,
> `Inspect.IdentId(34)`,
> `Num.Signed128`,
> `Bool.Bool`,
> `Inspect.ElemWalker`,
> `Decode.DecodeResult`,
> `Num.Unsigned16`,
> `Num.U16`,
> `Num.U64`,
> `Num.Binary64`,
> `Num.Int`,
> `Set.Set`,
> `Num.Unsigned8`,
> `Num.Frac`,
> `Num.U32`,
> `Num.Signed64`,
> `Num.Signed8`,
> `Num.I64`,
> `Num.U8`,
> `Num.I16`,
> `Result.Result`,
> `Dict.IdentId(32)`,
> `Num.Unsigned128`,
> `Num.I8`,
> `Num.Num`,
> `Inspect.KeyValWalker`,
> `Str.Utf8Problem`,
> `Num.Decimal`,
> `Num.Unsigned32`,
> `Num.Signed32`,
> `Dict.Dict`,
> `Num.Integer`,
> `Num.I128`,
> `Num.U128`,
> `Dict.IdentId(31)`,
> `Decode.Decoder`,
> `Num.I32`,
> `Num.Signed16`,
> `Num.Unsigned64`,
> `Num.F64`,
> `Encode.Encoder`,
> `Num.Dec`,
> `Str.IdentId(49)`,
> `Dict.IdentId(33)`,
> `find module name somehow?.IdentId(2)`,
> ],
> values: [
> Alias {
> region: @17634-17642,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @19444-19447,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary32`[ but actually [] ])[ but actually (Alias `Num.Binary32`[ but actually [] ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @17650-17669,
> type_variables: [
> @17664-17669 AliasVar {
> name: 'range',
> var: 67,
> opt_bound_abilities: None,
> },
> ],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: <67>,
> kind: Opaque,
> },
> Alias {
> region: @26725-26740,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [
> 63,
> ],
> recursion_variables: {},
> typ: ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<63>,
> kind: Structural,
> },
> Alias {
> region: @3006-3017,
> type_variables: [
> @3016-3017 AliasVar {
> name: 'f',
> var: 74,
> opt_bound_abilities: Some(
> AbilitySet(
> [
> `Inspect.InspectFormatter`,
> ],
> ),
> ),
> },
> ],
> lambda_set_variables: [
> LambdaSet(
> <75>,
> ),
> ],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: Fn(<74> |<75>| -> <74>),
> kind: Opaque,
> },
> Alias {
> region: @908-919,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [
> 63,
> ],
> recursion_variables: {},
> typ: ['TooShort']<63>,
> kind: Structural,
> },
> Alias {
> region: @3808-3820,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: { 'data' : RigidRequired((`Str.Str`)) },
> kind: Opaque,
> },
> Alias {
> region: @17074-17083,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @1780-1784,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: ['False', 'True'],
> kind: Opaque,
> },
> Alias {
> region: @802-834,
> type_variables: [
> @813-818 AliasVar {
> name: 'state',
> var: 70,
> opt_bound_abilities: None,
> },
> @819-829 AliasVar {
> name: 'collection',
> var: 69,
> opt_bound_abilities: None,
> },
> @830-834 AliasVar {
> name: 'elem',
> var: 71,
> opt_bound_abilities: None,
> },
> ],
> lambda_set_variables: [
> LambdaSet(
> <72>,
> ),
> LambdaSet(
> <73>,
> ),
> ],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: Fn(<69>, <70>, Fn(<70>, <71> |<72>| -> <70>) |<73>| -> <70>),
> kind: Structural,
> },
> Alias {
> region: @1320-1336,
> type_variables: [
> @1333-1336 AliasVar {
> name: 'val',
> var: 64,
> opt_bound_abilities: None,
> },
> ],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [
> 65,
> 69,
> ],
> recursion_variables: {},
> typ: { 'result' : RigidRequired((DelayedAlias `Result.Result` @1357-1360 OptAbleType { typ: <64>, opt_abilities: None } @1361-1372 OptAbleType { typ: (Alias `Decode.DecodeError`[ but actually ['TooShort']<69> ]), opt_abilities: None } `0@<65>))'rest' : RigidRequired((`List.List` @1386-1388 (DelayedAlias `Num.U8`))), },
> kind: Structural,
> },
> Alias {
> region: @17202-17212,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @17544-17547,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned16`[ but actually [] ])[ but actually (Alias `Num.Unsigned16`[ but actually [] ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @17482-17485,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned64`[ but actually [] ])[ but actually (Alias `Num.Unsigned64`[ but actually [] ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @17619-17627,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @12895-12904,
> type_variables: [
> @12899-12904 AliasVar {
> name: 'range',
> var: 64,
> opt_bound_abilities: None,
> },
> ],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.Integer` <64>[ but actually <64> ])[ but actually (Alias `Num.Integer` <64>[ but actually <64> ]) ]),
> kind: Structural,
> },
> Alias {
> region: @776-781,
> type_variables: [
> @780-781 AliasVar {
> name: 'k',
> var: 63,
> opt_bound_abilities: Some(
> AbilitySet(
> [
> `Hash.Hash`,
> `Bool.Eq`,
> ],
> ),
> ),
> },
> ],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (DelayedAlias `Dict.Dict` @795-796 OptAbleType { typ: <63>, opt_abilities: Some(AbilitySet([`Hash.Hash`, `Bool.Eq`])) } @797-799 OptAbleType { typ: {}, opt_abilities: None }),
> kind: Opaque,
> },
> Alias {
> region: @17219-17228,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @17034-17044,
> type_variables: [
> @17039-17044 AliasVar {
> name: 'range',
> var: 65,
> opt_bound_abilities: None,
> },
> ],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` <65>[ but actually <65> ])[ but actually (Alias `Num.FloatingPoint` <65>[ but actually <65> ]) ]),
> kind: Structural,
> },
> Alias {
> region: @17513-17516,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned32`[ but actually [] ])[ but actually (Alias `Num.Unsigned32`[ but actually [] ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @17090-17098,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @17135-17142,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @17291-17294,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed64`[ but actually [] ])[ but actually (Alias `Num.Signed64`[ but actually [] ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @17575-17577,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned8`[ but actually [] ])[ but actually (Alias `Num.Unsigned8`[ but actually [] ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @17349-17352,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed16`[ but actually [] ])[ but actually (Alias `Num.Signed16`[ but actually [] ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @241-254,
> type_variables: [
> @248-250 AliasVar {
> name: 'ok',
> var: 64,
> opt_bound_abilities: None,
> },
> @251-254 AliasVar {
> name: 'err',
> var: 65,
> opt_bound_abilities: None,
> },
> ],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [
> 63,
> ],
> recursion_variables: {},
> typ: ['Err' <65>, 'Ok' <64>]<63>,
> kind: Structural,
> },
> Alias {
> region: @40231-40237,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (DelayedAlias `Num.U64`),
> kind: Opaque,
> },
> Alias {
> region: @17150-17161,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @17431-17433,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Int` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed8`[ but actually [] ])[ but actually (Alias `Num.Signed8`[ but actually [] ]) ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @5228-5237,
> type_variables: [
> @5232-5237 AliasVar {
> name: 'range',
> var: 63,
> opt_bound_abilities: None,
> },
> ],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: <63>,
> kind: Opaque,
> },
> Alias {
> region: @707-744,
> type_variables: [
> @720-725 AliasVar {
> name: 'state',
> var: 64,
> opt_bound_abilities: None,
> },
> @726-736 AliasVar {
> name: 'collection',
> var: 63,
> opt_bound_abilities: None,
> },
> @737-740 AliasVar {
> name: 'key',
> var: 65,
> opt_bound_abilities: None,
> },
> @741-744 AliasVar {
> name: 'val',
> var: 66,
> opt_bound_abilities: None,
> },
> ],
> lambda_set_variables: [
> LambdaSet(
> <67>,
> ),
> LambdaSet(
> <68>,
> ),
> ],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: Fn(<63>, <64>, Fn(<64>, <65>, <66> |<67>| -> <64>) |<68>| -> <64>),
> kind: Structural,
> },
> Alias {
> region: @26896-26907,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [
> 64,
> ],
> recursion_variables: {},
> typ: { 'problem' : RigidRequired((Alias `Str.Utf8ByteProblem`[ but actually ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<64> ]))'byteIndex' : RigidRequired((DelayedAlias `Num.U64`)), },
> kind: Structural,
> },
> Alias {
> region: @17605-17612,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @17185-17195,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @17105-17113,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @3079-3087,
> type_variables: [
> @3084-3085 AliasVar {
> name: 'k',
> var: 63,
> opt_bound_abilities: Some(
> AbilitySet(
> [
> `Hash.Hash`,
> `Bool.Eq`,
> ],
> ),
> ),
> },
> @3086-3087 AliasVar {
> name: 'v',
> var: 64,
> opt_bound_abilities: None,
> },
> ],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: { 'buckets' : RigidRequired((`List.List` @3112-3118 (Alias `Dict.IdentId(31)`[ but actually { 'distAndFingerprint' : RigidRequired((DelayedAlias `Num.U32`))'dataIndex' : RigidRequired((DelayedAlias `Num.U32`)), } ])))'shifts' : RigidRequired((DelayedAlias `Num.U8`)), 'maxBucketCapacity' : RigidRequired((DelayedAlias `Num.U64`)), 'maxLoadFactor' : RigidRequired((DelayedAlias `Num.F32`)), 'data' : RigidRequired((`List.List` @3136-3142 ( <63><64>, ))), },
> kind: Opaque,
> },
> Alias {
> region: @17236-17249,
> type_variables: [
> @17244-17249 AliasVar {
> name: 'range',
> var: 66,
> opt_bound_abilities: None,
> },
> ],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: <66>,
> kind: Opaque,
> },
> Alias {
> region: @17260-17264,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed128`[ but actually [] ])[ but actually (Alias `Num.Signed128`[ but actually [] ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @17449-17453,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Unsigned128`[ but actually [] ])[ but actually (Alias `Num.Unsigned128`[ but actually [] ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @25758-25764,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: { 'distAndFingerprint' : RigidRequired((DelayedAlias `Num.U32`))'dataIndex' : RigidRequired((DelayedAlias `Num.U32`)), },
> kind: Structural,
> },
> Alias {
> region: @1556-1571,
> type_variables: [
> @1564-1567 AliasVar {
> name: 'val',
> var: 67,
> opt_bound_abilities: None,
> },
> @1568-1571 AliasVar {
> name: 'fmt',
> var: 66,
> opt_bound_abilities: Some(
> AbilitySet(
> [
> `Decode.DecoderFormatting`,
> ],
> ),
> ),
> },
> ],
> lambda_set_variables: [
> LambdaSet(
> <68>,
> ),
> ],
> infer_ext_in_output_variables: [
> 70,
> 71,
> ],
> recursion_variables: {},
> typ: Fn((`List.List` @1580-1582 (DelayedAlias `Num.U8`)), <66> |<68>| -> (Alias `Decode.DecodeResult` <67>[ but actually { 'result' : RigidRequired((DelayedAlias `Result.Result` @1357-1360 OptAbleType { typ: <67>, opt_abilities: None } @1361-1372 OptAbleType { typ: (Alias `Decode.DecodeError`[ but actually ['TooShort']<71> ]), opt_abilities: None } `0@<70>))'rest' : RigidRequired((`List.List` @1386-1388 (DelayedAlias `Num.U8`))), } ])),
> kind: Opaque,
> },
> Alias {
> region: @17320-17323,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ])[ but actually (Alias `Num.Integer` (Alias `Num.Signed32`[ but actually [] ])[ but actually (Alias `Num.Signed32`[ but actually [] ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @17120-17128,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @17168-17178,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: [],
> kind: Opaque,
> },
> Alias {
> region: @19085-19088,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Binary64`[ but actually [] ])[ but actually (Alias `Num.Binary64`[ but actually [] ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @734-745,
> type_variables: [
> @742-745 AliasVar {
> name: 'fmt',
> var: 63,
> opt_bound_abilities: Some(
> AbilitySet(
> [
> `Encode.EncoderFormatting`,
> ],
> ),
> ),
> },
> ],
> lambda_set_variables: [
> LambdaSet(
> <64>,
> ),
> ],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: Fn((`List.List` @754-756 (DelayedAlias `Num.U8`)), <63> |<64>| -> (`List.List` @770-772 (DelayedAlias `Num.U8`))),
> kind: Opaque,
> },
> Alias {
> region: @23363-23366,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: (Alias `Num.Num` (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ])[ but actually (Alias `Num.FloatingPoint` (Alias `Num.Decimal`[ but actually [] ])[ but actually (Alias `Num.Decimal`[ but actually [] ]) ]) ]),
> kind: Structural,
> },
> Alias {
> region: @35465-35479,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [
> 65,
> ],
> recursion_variables: {},
> typ: { 'dProblemCode' : RigidRequired((Alias `Str.Utf8ByteProblem`[ but actually ['CodepointTooLarge', 'EncodesSurrogateHalf', 'ExpectedContinuation', 'InvalidStartByte', 'OverlongEncoding', 'UnexpectedEndOfSequence']<65> ]))'cIsOk' : RigidRequired((DelayedAlias `Bool.Bool`)), 'aByteIndex' : RigidRequired((DelayedAlias `Num.U64`)), 'bString' : RigidRequired((`Str.Str`)), },
> kind: Structural,
> },
> Alias {
> region: @41841-41855,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: { 'state' : RigidRequired((DelayedAlias `Num.U64`))'initializedSeed' : RigidRequired((DelayedAlias `Num.U64`)), },
> kind: Opaque,
> },
> Alias {
> region: @112-116,
> type_variables: [],
> lambda_set_variables: [],
> infer_ext_in_output_variables: [],
> recursion_variables: {},
> typ: { 'name' : RigidRequired((`Str.Str`)) },
> kind: Structural,
> },
> ],
> },
> abilities_store: IAbilitiesStore {
> members_of_ability: {
> `Hash.Hash`: [
> `Hash.hash`,
> ],
> `Decode.DecoderFormatting`: [
> `Decode.u8`,
> `Decode.u16`,
> `Decode.u32`,
> `Decode.u64`,
> `Decode.u128`,
> `Decode.i8`,
> `Decode.i16`,
> `Decode.i32`,
> `Decode.i64`,
> `Decode.i128`,
> `Decode.f32`,
> `Decode.f64`,
> `Decode.dec`,
> `Decode.bool`,
> `Decode.string`,
> `Decode.list`,
> `Decode.record`,
> `Decode.tuple`,
> ],
> `Inspect.Inspect`: [
> `Inspect.toInspector`,
> ],
> `Encode.Encoding`: [
> `Encode.toEncoder`,
> ],
> `Hash.Hasher`: [
> `Hash.addBytes`,
> `Hash.addU8`,
> `Hash.addU16`,
> `Hash.addU32`,
> `Hash.addU64`,
> `Hash.addU128`,
> `Hash.complete`,
> ],
> `Encode.EncoderFormatting`: [
> `Encode.u8`,
> `Encode.u16`,
> `Encode.u32`,
> `Encode.u64`,
> `Encode.u128`,
> `Encode.i8`,
> `Encode.i16`,
> `Encode.i32`,
> `Encode.i64`,
> `Encode.i128`,
> `Encode.f32`,
> `Encode.f64`,
> `Encode.dec`,
> `Encode.bool`,
> `Encode.string`,
> `Encode.list`,
> `Encode.record`,
> `Encode.tuple`,
> `Encode.tag`,
> ],
> `Decode.Decoding`: [
> `Decode.decoder`,
> ],
> `Bool.Eq`: [
> `Bool.isEq`,
> ],
> `Inspect.InspectFormatter`: [
> `Inspect.init`,
> `Inspect.tag`,
> `Inspect.tuple`,
> `Inspect.record`,
> `Inspect.bool`,
> `Inspect.str`,
> `Inspect.list`,
> `Inspect.set`,
> `Inspect.dict`,
> `Inspect.opaque`,
> `Inspect.function`,
> `Inspect.u8`,
> `Inspect.i8`,
> `Inspect.u16`,
> `Inspect.i16`,
> `Inspect.u32`,
> `Inspect.i32`,
> `Inspect.u64`,
> `Inspect.i64`,
> `Inspect.u128`,
> `Inspect.i128`,
> `Inspect.f32`,
> `Inspect.f64`,
> `Inspect.dec`,
> ],
> },
> specialization_to_root: {
> `Inspect.IdentId(35)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.init`,
> },
> `Inspect.IdentId(55)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.i128`,
> },
> `Inspect.IdentId(45)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.function`,
> },
> `Inspect.IdentId(42)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.bool`,
> },
> `Inspect.IdentId(57)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.f64`,
> },
> `Inspect.IdentId(54)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.u128`,
> },
> `Inspect.IdentId(41)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.record`,
> },
> `Inspect.IdentId(44)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.opaque`,
> },
> `Inspect.IdentId(50)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.u32`,
> },
> `Inspect.IdentId(58)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.dec`,
> },
> `Inspect.IdentId(46)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.u8`,
> },
> `Inspect.IdentId(38)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.dict`,
> },
> `Inspect.IdentId(56)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.f32`,
> },
> `Inspect.IdentId(53)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.i64`,
> },
> `Bool.boolIsEq`: ImplKey {
> opaque: `Bool.Bool`,
> ability_member: `Bool.isEq`,
> },
> `Inspect.IdentId(37)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.set`,
> },
> `Inspect.IdentId(43)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.str`,
> },
> `Inspect.IdentId(47)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.i8`,
> },
> `Inspect.IdentId(48)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.u16`,
> },
> `Inspect.IdentId(52)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.u64`,
> },
> `Inspect.IdentId(51)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.i32`,
> },
> `Inspect.IdentId(39)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.tag`,
> },
> `Inspect.IdentId(40)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.tuple`,
> },
> `Inspect.IdentId(49)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.i16`,
> },
> `Inspect.IdentId(36)`: ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.list`,
> },
> },
> ability_members: {
> `Decode.i16`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2273-2276,
> typ: Imported,
> },
> `Inspect.i16`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2355-2358,
> typ: Imported,
> },
> `Decode.dec`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2665-2668,
> typ: Imported,
> },
> `Inspect.set`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @1499-1502,
> typ: Imported,
> },
> `Encode.u128`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1236-1240,
> typ: Imported,
> },
> `Decode.u32`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2013-2016,
> typ: Imported,
> },
> `Decode.i128`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2468-2472,
> typ: Imported,
> },
> `Encode.f64`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1714-1717,
> typ: Imported,
> },
> `Inspect.i32`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2485-2488,
> typ: Imported,
> },
> `Decode.string`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2797-2803,
> typ: Imported,
> },
> `Encode.record`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @2089-2095,
> typ: Imported,
> },
> `Decode.u64`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2078-2081,
> typ: Imported,
> },
> `Inspect.i128`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2747-2751,
> typ: Imported,
> },
> `Decode.bool`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2730-2734,
> typ: Imported,
> },
> `Encode.i128`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1576-1580,
> typ: Imported,
> },
> `Inspect.dec`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2944-2947,
> typ: Imported,
> },
> `Encode.toEncoder`: AbilityMemberData {
> parent_ability: `Encode.Encoding`,
> region: @837-846,
> typ: Imported,
> },
> `Hash.addU16`: AbilityMemberData {
> parent_ability: `Hash.Hasher`,
> region: @1337-1343,
> typ: Imported,
> },
> `Encode.f32`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1646-1649,
> typ: Imported,
> },
> `Encode.tuple`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @2196-2201,
> typ: Imported,
> },
> `Inspect.bool`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @1248-1252,
> typ: Imported,
> },
> `Encode.i8`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1306-1308,
> typ: Imported,
> },
> `Decode.record`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @3265-3271,
> typ: Imported,
> },
> `Encode.i16`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1372-1375,
> typ: Imported,
> },
> `Encode.u64`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1168-1171,
> typ: Imported,
> },
> `Encode.u8`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @966-968,
> typ: Imported,
> },
> `Decode.i64`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2403-2406,
> typ: Imported,
> },
> `Hash.addBytes`: AbilityMemberData {
> parent_ability: `Hash.Hasher`,
> region: @1150-1158,
> typ: Imported,
> },
> `Inspect.f32`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2814-2817,
> typ: Imported,
> },
> `Bool.isEq`: AbilityMemberData {
> parent_ability: `Bool.Eq`,
> region: @1635-1639,
> typ: Imported,
> },
> `Inspect.function`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2095-2103,
> typ: Imported,
> },
> `Encode.u32`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1100-1103,
> typ: Imported,
> },
> `Hash.addU128`: AbilityMemberData {
> parent_ability: `Hash.Hasher`,
> region: @1614-1621,
> typ: Imported,
> },
> `Decode.f64`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2600-2603,
> typ: Imported,
> },
> `Inspect.i8`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2227-2229,
> typ: Imported,
> },
> `Inspect.u64`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2550-2553,
> typ: Imported,
> },
> `Encode.string`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1920-1926,
> typ: Imported,
> },
> `Inspect.u128`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2680-2684,
> typ: Imported,
> },
> `Inspect.tag`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @977-980,
> typ: Imported,
> },
> `Decode.i8`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2210-2212,
> typ: Imported,
> },
> `Decode.decoder`: AbilityMemberData {
> parent_ability: `Decode.Decoding`,
> region: @1712-1719,
> typ: Imported,
> },
> `Decode.f32`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2535-2538,
> typ: Imported,
> },
> `Inspect.opaque`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @1880-1886,
> typ: Imported,
> },
> `Decode.i32`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2338-2341,
> typ: Imported,
> },
> `Inspect.u32`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2420-2423,
> typ: Imported,
> },
> `Decode.u8`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @1885-1887,
> typ: Imported,
> },
> `Inspect.u8`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2164-2166,
> typ: Imported,
> },
> `Decode.u16`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @1948-1951,
> typ: Imported,
> },
> `Encode.u16`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1032-1035,
> typ: Imported,
> },
> `Inspect.dict`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @1614-1618,
> typ: Imported,
> },
> `Inspect.list`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @1381-1385,
> typ: Imported,
> },
> `Inspect.init`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @921-925,
> typ: Imported,
> },
> `Encode.i32`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1440-1443,
> typ: Imported,
> },
> `Encode.bool`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1850-1854,
> typ: Imported,
> },
> `Encode.tag`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @2281-2284,
> typ: Imported,
> },
> `Hash.addU32`: AbilityMemberData {
> parent_ability: `Hash.Hasher`,
> region: @1429-1435,
> typ: Imported,
> },
> `Inspect.toInspector`: AbilityMemberData {
> parent_ability: `Inspect.Inspect`,
> region: @3291-3302,
> typ: Imported,
> },
> `Inspect.f64`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2879-2882,
> typ: Imported,
> },
> `Inspect.str`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @1315-1318,
> typ: Imported,
> },
> `Encode.list`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1991-1995,
> typ: Imported,
> },
> `Hash.addU8`: AbilityMemberData {
> parent_ability: `Hash.Hasher`,
> region: @1247-1252,
> typ: Imported,
> },
> `Decode.list`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2865-2869,
> typ: Imported,
> },
> `Decode.tuple`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @3794-3799,
> typ: Imported,
> },
> `Encode.dec`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1782-1785,
> typ: Imported,
> },
> `Decode.u128`: AbilityMemberData {
> parent_ability: `Decode.DecoderFormatting`,
> region: @2143-2147,
> typ: Imported,
> },
> `Encode.i64`: AbilityMemberData {
> parent_ability: `Encode.EncoderFormatting`,
> region: @1508-1511,
> typ: Imported,
> },
> `Hash.addU64`: AbilityMemberData {
> parent_ability: `Hash.Hasher`,
> region: @1521-1527,
> typ: Imported,
> },
> `Hash.hash`: AbilityMemberData {
> parent_ability: `Hash.Hash`,
> region: @742-746,
> typ: Imported,
> },
> `Inspect.u16`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2290-2293,
> typ: Imported,
> },
> `Inspect.record`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @1144-1150,
> typ: Imported,
> },
> `Inspect.i64`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @2615-2618,
> typ: Imported,
> },
> `Inspect.tuple`: AbilityMemberData {
> parent_ability: `Inspect.InspectFormatter`,
> region: @1062-1067,
> typ: Imported,
> },
> `Hash.complete`: AbilityMemberData {
> parent_ability: `Hash.Hasher`,
> region: @1761-1769,
> typ: Imported,
> },
> },
> declared_implementations: {
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.i16`,
> }: Impl(
> `Inspect.IdentId(49)`,
> ),
> ImplKey {
> opaque: `Bool.Bool`,
> ability_member: `Bool.isEq`,
> }: Impl(
> `Bool.boolIsEq`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.str`,
> }: Impl(
> `Inspect.IdentId(43)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.u32`,
> }: Impl(
> `Inspect.IdentId(50)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.u128`,
> }: Impl(
> `Inspect.IdentId(54)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.function`,
> }: Impl(
> `Inspect.IdentId(45)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.dec`,
> }: Impl(
> `Inspect.IdentId(58)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.init`,
> }: Impl(
> `Inspect.IdentId(35)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.bool`,
> }: Impl(
> `Inspect.IdentId(42)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.opaque`,
> }: Impl(
> `Inspect.IdentId(44)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.f64`,
> }: Impl(
> `Inspect.IdentId(57)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.u64`,
> }: Impl(
> `Inspect.IdentId(52)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.i32`,
> }: Impl(
> `Inspect.IdentId(51)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.i64`,
> }: Impl(
> `Inspect.IdentId(53)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.tag`,
> }: Impl(
> `Inspect.IdentId(39)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.dict`,
> }: Impl(
> `Inspect.IdentId(38)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.u8`,
> }: Impl(
> `Inspect.IdentId(46)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.tuple`,
> }: Impl(
> `Inspect.IdentId(40)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.f32`,
> }: Impl(
> `Inspect.IdentId(56)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.list`,
> }: Impl(
> `Inspect.IdentId(36)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.i128`,
> }: Impl(
> `Inspect.IdentId(55)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.set`,
> }: Impl(
> `Inspect.IdentId(37)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.i8`,
> }: Impl(
> `Inspect.IdentId(47)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.u16`,
> }: Impl(
> `Inspect.IdentId(48)`,
> ),
> ImplKey {
> opaque: `Inspect.IdentId(34)`,
> ability_member: `Inspect.record`,
> }: Impl(
> `Inspect.IdentId(41)`,
> ),
> },
> specializations: {},
> next_specialization_id: 1,
> resolved_specializations: {},
> },
> home: find module name somehow?,
> exposed_ident_count: 2,
> imports: [
> (
> Ident(
> IdentStr {
> string: "Str",
> },
> ),
> `Str.Str`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "List",
> },
> ),
> `List.List`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Box",
> },
> ),
> `Box.Box`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Ok",
> },
> ),
> `Result.Ok`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Err",
> },
> ),
> `Result.Err`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "U8",
> },
> ),
> `Num.U8`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "F64",
> },
> ),
> `Num.F64`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Integer",
> },
> ),
> `Num.Integer`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Binary32",
> },
> ),
> `Num.Binary32`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "DecoderFormatting",
> },
> ),
> `Decode.DecoderFormatting`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "I128",
> },
> ),
> `Num.I128`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Signed8",
> },
> ),
> `Num.Signed8`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Frac",
> },
> ),
> `Num.Frac`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Decimal",
> },
> ),
> `Num.Decimal`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Binary64",
> },
> ),
> `Num.Binary64`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Dec",
> },
> ),
> `Num.Dec`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Result",
> },
> ),
> `Result.Result`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Dict",
> },
> ),
> `Dict.Dict`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "DecodeError",
> },
> ),
> `Decode.DecodeError`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "I64",
> },
> ),
> `Num.I64`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "U64",
> },
> ),
> `Num.U64`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "F32",
> },
> ),
> `Num.F32`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "FloatingPoint",
> },
> ),
> `Num.FloatingPoint`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Eq",
> },
> ),
> `Bool.Eq`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "DecodeResult",
> },
> ),
> `Decode.DecodeResult`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Decoding",
> },
> ),
> `Decode.Decoding`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "ElemWalker",
> },
> ),
> `Inspect.ElemWalker`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "KeyValWalker",
> },
> ),
> `Inspect.KeyValWalker`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Unsigned8",
> },
> ),
> `Num.Unsigned8`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Decoder",
> },
> ),
> `Decode.Decoder`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Signed16",
> },
> ),
> `Num.Signed16`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Encoding",
> },
> ),
> `Encode.Encoding`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Signed64",
> },
> ),
> `Num.Signed64`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Int",
> },
> ),
> `Num.Int`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Num",
> },
> ),
> `Num.Num`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Inspect",
> },
> ),
> `Inspect.Inspect`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "U16",
> },
> ),
> `Num.U16`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "InspectFormatter",
> },
> ),
> `Inspect.InspectFormatter`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Set",
> },
> ),
> `Set.Set`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "EncoderFormatting",
> },
> ),
> `Encode.EncoderFormatting`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "I32",
> },
> ),
> `Num.I32`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Hash",
> },
> ),
> `Hash.Hash`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Hasher",
> },
> ),
> `Hash.Hasher`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Unsigned32",
> },
> ),
> `Num.Unsigned32`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Signed128",
> },
> ),
> `Num.Signed128`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Inspector",
> },
> ),
> `Inspect.Inspector`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Unsigned16",
> },
> ),
> `Num.Unsigned16`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Signed32",
> },
> ),
> `Num.Signed32`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "U32",
> },
> ),
> `Num.U32`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Unsigned128",
> },
> ),
> `Num.Unsigned128`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Unsigned64",
> },
> ),
> `Num.Unsigned64`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Bool",
> },
> ),
> `Bool.Bool`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Encoder",
> },
> ),
> `Encode.Encoder`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "I16",
> },
> ),
> `Num.I16`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "I8",
> },
> ),
> `Num.I8`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "U128",
> },
> ),
> `Num.U128`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Dict",
> },
> ),
> `Dict.Dict`,
> …,
> ),
> (
> Ident(
> IdentStr {
> string: "Set",
> },
> ),
> `Set.Set`,
> …,
> ),
> ],
> shadows: VecMap {
> keys: [],
> values: [],
> },
> locals: ScopedIdentIds {
> ident_ids: IdentIds {
> interner: SmallStringInterner {
> buffer: [
> 109,
> 97,
> 107,
> 101,
> 85,
> 115,
> 101,
> 114,
> 103,
> 101,
> 116,
> 78,
> 97,
> 109,
> 101,
> 85,
> 115,
> 101,
> 114,
> 83,
> 116,
> 114,
> 110,
> 97,
> 109,
> 101,
> ],
> lengths: [
> Interned(8),
> Interned(7),
> Interned(4),
> Interned(3),
> Interned(4),
> ],
> offsets: [
> 0,
> 8,
> 15,
> 19,
> 22,
> ],
> strings: [
> "makeUser",
> "getName",
> "User",
> "Str",
> "name",
> ],
> },
> },
> in_scope: BitVec<usize, bitvec::order::Lsb0> {
> addr: 0x00007fffed7a26c0,
> head: 000000,
> bits: 5,
> capacity: 64,
> } [
> 1,
> 1,
> 1,
> 0,
> 0,
> ],
> regions: [
> @174-182,
> @231-238,
> @112-133,
> …,
> @186-190,
> ],
> home: find module name somehow?,
> },
> ignored_locals: VecMap {
> keys: [],
> values: [],
> },
> },
> exposed_symbols: VecSet {
> elements: [
> `find module name somehow?.identity`,
> `find module name somehow?.intVal`,
> ],
> },
>}
', crates/compiler/load_internal/tests/test_load.rs:441:5
failures:
load_docs
test result: FAILED. 33 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 2.15s
error: test failed, to rerun pass `--test test_load`
Reference in a new issue View git blame Copy permalink