roc-lang/roc
1
1
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2024-09-21 07:49:17 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #5134 from lukewilliamboswell/docs

Browse Source 
Add documentation for `Set` and minor fixes
This commit is contained in:
Anton-4 2023-03-15 11:40:06 +01:00 committed by GitHub
commit 2023770ce7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 677 additions and 489 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
crates/compiler/builtins/roc/Bool.roc
View File

@ -32,6 +32,8 @@ Eq has
## cannot derive `isEq` for types that contain functions. ## cannot derive `isEq` for types that contain functions.
isEq : a, a -> Bool | a has Eq isEq : a, a -> Bool | a has Eq
## Represents the boolean true and false using an opaque type.
## `Bool` implements the `Eq` ability.
Bool := [True, False] has [Eq { isEq: boolIsEq }] Bool := [True, False] has [Eq { isEq: boolIsEq }]
boolIsEq = \@Bool b1, @Bool b2 -> structuralEq b1 b2 boolIsEq = \@Bool b1, @Bool b2 -> structuralEq b1 b2
@ -57,7 +59,9 @@ false = @Bool False
## expect (Bool.false && Bool.false) == Bool.false ## expect (Bool.false && Bool.false) == Bool.false
## ``` ## ```
## ##
## **Performance Note** that in Roc the `&&` and `||` work the same way as any ## ## Performance Details
##
## In Roc the `&&` and `||` work the same way as any
## other function. However, in some languages `&&` and `||` are special-cased. ## other function. However, in some languages `&&` and `||` are special-cased.
## In these languages the compiler will skip evaluating the expression after the ## In these languages the compiler will skip evaluating the expression after the
## first operator under certain circumstances. For example an expression like ## first operator under certain circumstances. For example an expression like
@ -83,7 +87,10 @@ and : Bool, Bool -> Bool
## expect (Bool.true || Bool.false) == Bool.true ## expect (Bool.true || Bool.false) == Bool.true
## expect (Bool.false || Bool.false) == Bool.false ## expect (Bool.false || Bool.false) == Bool.false
## ``` ## ```
## **Performance Note** that in Roc the `&&` and `||` work the same way as any ##
## ## Performance Details
##
## In Roc the `&&` and `||` work the same way as any
## other functions. However, in some languages `&&` and `||` are special-cased. ## other functions. However, in some languages `&&` and `||` are special-cased.
## Refer to the note in `Bool.and` for more detail. ## Refer to the note in `Bool.and` for more detail.
or : Bool, Bool -> Bool or : Bool, Bool -> Bool

6
crates/compiler/builtins/roc/Dict.roc
View File

@ -34,7 +34,7 @@ interface Dict
## A [dictionary](https://en.wikipedia.org/wiki/Associative_array) that lets you ## A [dictionary](https://en.wikipedia.org/wiki/Associative_array) that lets you
## associate keys with values. ## associate keys with values.
## ##
## ### Inserting ## ## Inserting
## ##
## The most basic way to use a dictionary is to start with an empty one and ## The most basic way to use a dictionary is to start with an empty one and
## then: ## then:
@ -54,7 +54,7 @@ interface Dict
## |> Dict.insert "Delhi" 16_787_941 ## |> Dict.insert "Delhi" 16_787_941
## |> Dict.insert "Amsterdam" 872_680 ## |> Dict.insert "Amsterdam" 872_680
## ``` ## ```
## ### Accessing keys or values ## ## Accessing keys or values
## ##
## We can use [Dict.keys] and [Dict.values] functions to get only the keys or ## We can use [Dict.keys] and [Dict.values] functions to get only the keys or
## only the values. ## only the values.
@ -63,7 +63,7 @@ interface Dict
## order. This will be true if all you ever do is [Dict.insert] and [Dict.get] operations ## order. This will be true if all you ever do is [Dict.insert] and [Dict.get] operations
## on the dictionary, but [Dict.remove] operations can change this order. ## on the dictionary, but [Dict.remove] operations can change this order.
## ##
## ### Removing ## ## Removing
## ##
## We can remove an element from the dictionary, like so: ## We can remove an element from the dictionary, like so:
## ``` ## ```

104
crates/compiler/builtins/roc/Json.roc
View File

@ -1,3 +1,40 @@
## JSON is a data format that is easy for humans to read and write. It is
## commonly used to exhange data between two systems such as a server and a
## client (e.g. web browser).
##
## This module implements functionality to serialise and de-serialise Roc types
## to and from JSON data. Using the `Encode` and `Decode` builtins this process
## can be achieved without the need to write custom encoder and decoder functions
## to parse UTF-8 strings.
##
## Here is a basic example which shows how to parse a JSON record into a Roc
## type named `Language` which includes a `name` field. The JSON string is
## decoded and then the field is encoded back into a UTF-8 string.
##
## ```
## Language : {
## name : Str,
## }
##
## jsonStr = Str.toUtf8 "{\"name\":\"Röc Lang\"}"
##
## result : Result Language _
## result =
## jsonStr
## |> Decode.fromBytes fromUtf8 # returns `Ok {name : "Röc Lang"}`
##
## name =
## decodedValue <- Result.map result
##
## Encode.toBytes decodedValue.name toUtf8
##
## expect name == Ok (Str.toUtf8 "\"Röc Lang\"")
## ```
##
## **Note:** This module is likely to be moved out of the builtins in future.
## It is currently located here to facilitate development of the Abilities
## language feature and testing. You are welcome to use this module, just note
## that it will be moved into a package in a future update.
interface Json interface Json
exposes [ exposes [
Json, Json,
@ -7,6 +44,7 @@ interface Json
imports [ imports [
List, List,
Str, Str,
Result.{ Result },
Encode, Encode,
Encode.{ Encode.{
Encoder, Encoder,
@ -37,6 +75,8 @@ interface Json
Result, Result,
] ]
## An opaque type with the `EncoderFormatting` and
## `DecoderFormatting` abilities.
Json := {} has [ Json := {} has [
EncoderFormatting { EncoderFormatting {
u8: encodeU8, u8: encodeU8,
@ -79,8 +119,10 @@ Json := {} has [
}, },
] ]
## Returns a JSON `Decoder`
toUtf8 = @Json {} toUtf8 = @Json {}
## Returns a JSON `Encoder`
fromUtf8 = @Json {} fromUtf8 = @Json {}
numToBytes = \n -> numToBytes = \n ->
@ -398,12 +440,20 @@ decodeList = \decodeElem -> Decode.custom \bytes, @Json {} ->
when bytes is when bytes is
['[', ']'] -> { result: Ok [], rest: List.drop bytes 2 } ['[', ']'] -> { result: Ok [], rest: List.drop bytes 2 }
['[', ..] -> ['[', ..] ->
when decodeElems (eatWhitespace (List.dropFirst bytes)) [] is bytesWithoutWhitespace = eatWhitespace (List.dropFirst bytes)
Errored e rest -> { result: Err e, rest } when bytesWithoutWhitespace is
Done vals rest -> [']', ..] ->
when rest is { result: Ok [], rest: List.dropFirst bytesWithoutWhitespace }
[']', ..] -> { result: Ok vals, rest: List.dropFirst rest }
_ -> { result: Err TooShort, rest } _ ->
when decodeElems bytesWithoutWhitespace [] is
Errored e rest ->
{ result: Err e, rest }
Done vals rest ->
when rest is
[']', ..] -> { result: Ok vals, rest: List.dropFirst rest }
_ -> { result: Err TooShort, rest }
_ -> _ ->
{ result: Err TooShort, rest: bytes } { result: Err TooShort, rest: bytes }
@ -491,6 +541,7 @@ expect
input = Str.toUtf8 " \n\r\tabc" input = Str.toUtf8 " \n\r\tabc"
actual = eatWhitespace input actual = eatWhitespace input
expected = Str.toUtf8 "abc" expected = Str.toUtf8 "abc"
actual == expected actual == expected
# Test json string decoding with escapes # Test json string decoding with escapes
@ -498,6 +549,7 @@ expect
input = Str.toUtf8 "\"a\r\nbc\\\"xz\"" input = Str.toUtf8 "\"a\r\nbc\\\"xz\""
expected = Ok "a\r\nbc\\\"xz" expected = Ok "a\r\nbc\\\"xz"
actual = Decode.fromBytes input fromUtf8 actual = Decode.fromBytes input fromUtf8
actual == expected actual == expected
# Test json string encoding with escapes # Test json string encoding with escapes
@ -505,53 +557,31 @@ expect
input = "a\r\nbc\\\"xz" input = "a\r\nbc\\\"xz"
expected = Str.toUtf8 "\"a\r\nbc\\\"xz\"" expected = Str.toUtf8 "\"a\r\nbc\\\"xz\""
actual = Encode.toBytes input toUtf8 actual = Encode.toBytes input toUtf8
actual == expected actual == expected
# Test json array decode empty list # Test json array decode empty list
expect expect
input = Str.toUtf8 "[ ]" input = Str.toUtf8 "[ ]"
expected = [] actual : Result (List U8) _
actual = Decode.fromBytes input fromUtf8
actual : List U8 expected = Ok []
actual = Decode.fromBytes input fromUtf8 |> Result.withDefault []
actual == expected actual == expected
# Test json array decoding into integers # Test json array decoding into integers
expect expect
input = Str.toUtf8 "[ 1,\n2,\t3]" input = Str.toUtf8 "[ 1,\n2,\t3]"
expected = [1, 2, 3] actual : Result (List U8) _
actual = Decode.fromBytes input fromUtf8
actual : List U8 expected = Ok [1, 2, 3]
actual = Decode.fromBytes input fromUtf8 |> Result.withDefault []
actual == expected actual == expected
# Test json array decoding into strings ignoring whitespace around values # Test json array decoding into strings ignoring whitespace around values
expect expect
input = Str.toUtf8 "[\r\"one\" ,\t\"two\"\n,\n\"3\"\t]" input = Str.toUtf8 "[\r\"one\" ,\t\"two\"\n,\n\"3\"\t]"
expected = ["one", "two", "3"] actual = Decode.fromBytes input fromUtf8
expected = Ok ["one", "two", "3"]
actual : List Str
actual =
Decode.fromBytes input fromUtf8
|> Result.onErr handleJsonDecodeError
|> Result.withDefault []
actual == expected actual == expected
# Helper for tests to handle Json decoding errors
handleJsonDecodeError = \err ->
when err is
Leftover bytes ->
when Str.fromUtf8 bytes is
Ok bs -> crash "ERROR: bytes left \(bs)"
Err _ ->
ls =
bytes
|> List.map Num.toStr
|> Str.joinWith ","
crash "ERROR: bytes left \(ls)"
TooShort -> crash "ERROR: input too short"

2
crates/compiler/builtins/roc/List.roc
View File

@ -187,7 +187,7 @@ interface List
## ##
## first ## first
## ``` ## ```
## TODO explain how in the former example, when we go to free `nums` at the end, ## **TODO** explain how in the former example, when we go to free `nums` at the end,
## we can free it immediately because there are no other refcounts. However, ## we can free it immediately because there are no other refcounts. However,
## in the case of `lists`, we have to iterate through the list and decrement ## in the case of `lists`, we have to iterate through the list and decrement
## the refcounts of each of its contained lists - because they, too, have ## the refcounts of each of its contained lists - because they, too, have

8
crates/compiler/builtins/roc/Num.roc
View File

@ -239,7 +239,7 @@ Num range := range
## ##
## This pattern continues up to [U128] and [I128]. ## This pattern continues up to [U128] and [I128].
## ##
## ## Performance notes ## ## Performance Details
## ##
## In general, using smaller numeric sizes means your program will use less memory. ## In general, using smaller numeric sizes means your program will use less memory.
## However, if a mathematical operation results in an answer that is too big ## However, if a mathematical operation results in an answer that is too big
@ -381,7 +381,7 @@ Int range : Num (Integer range)
## Whenever a function in this module could return one of these values, that ## Whenever a function in this module could return one of these values, that
## possibility is noted in the function's documentation. ## possibility is noted in the function's documentation.
## ##
## ## Performance Notes ## ## Performance Details
## ##
## On typical modern CPUs, performance is similar between [Dec], [F64], and [F32] ## On typical modern CPUs, performance is similar between [Dec], [F64], and [F32]
## for addition and subtraction. For example, [F32] and [F64] do addition using ## for addition and subtraction. For example, [F32] and [F64] do addition using
@ -481,7 +481,7 @@ F32 : Num (FloatingPoint Binary32)
## details, below), and decimal precision loss isn't as big a concern when ## details, below), and decimal precision loss isn't as big a concern when
## dealing with screen coordinates as it is when dealing with currency. ## dealing with screen coordinates as it is when dealing with currency.
## ##
## ## Performance ## ## Performance Details
## ##
## [Dec] typically takes slightly less time than [F64] to perform addition and ## [Dec] typically takes slightly less time than [F64] to perform addition and
## subtraction, but 10-20 times longer to perform multiplication and division. ## subtraction, but 10-20 times longer to perform multiplication and division.
@ -951,7 +951,7 @@ pow : Frac a, Frac a -> Frac a
## ##
## Num.exp 5 6 ## Num.exp 5 6
## ``` ## ```
## ## Performance Notes ## ## Performance Details
## ##
## Be careful! It is very easy for this function to produce an answer ## Be careful! It is very easy for this function to produce an answer
## so large it causes an overflow. ## so large it causes an overflow.

24
crates/compiler/builtins/roc/Result.roc
View File

@ -39,16 +39,15 @@ withDefault = \result, default ->
Err _ -> default Err _ -> default
## If the result is `Ok`, transform the value it holds by running a conversion ## If the result is `Ok`, transform the value it holds by running a conversion
## function on it. Then return a new `Ok` holding the transformed value. ## function on it. Then return a new `Ok` holding the transformed value. If the
## ## result is `Err`, this has no effect. Use [mapErr] to transform an `Err`.
## (If the result is `Err`, this has no effect. Use [mapErr] to transform an `Err`.)
## ``` ## ```
## Result.map (Ok 12) Num.negate ## Result.map (Ok 12) Num.negate
## Result.map (Err "yipes!") Num.negate ## Result.map (Err "yipes!") Num.negate
## ``` ## ```
## ##
## `map` functions like this are common in Roc, and they all work similarly. ## Functions like `map` are common in Roc; see for example [List.map],
## See for example [List.map], `Set.map`, and `Dict.map`. ## `Set.map`, and `Dict.map`.
map : Result a err, (a -> b) -> Result b err map : Result a err, (a -> b) -> Result b err
map = \result, transform -> map = \result, transform ->
when result is when result is
@ -56,9 +55,8 @@ map = \result, transform ->
Err e -> Err e Err e -> Err e
## If the result is `Err`, transform the value it holds by running a conversion ## If the result is `Err`, transform the value it holds by running a conversion
## function on it. Then return a new `Err` holding the transformed value. ## function on it. Then return a new `Err` holding the transformed value. If
## ## the result is `Ok`, this has no effect. Use [map] to transform an `Ok`.
## (If the result is `Ok`, this has no effect. Use [map] to transform an `Ok`.)
## ``` ## ```
## Result.mapErr (Err "yipes!") Str.isEmpty ## Result.mapErr (Err "yipes!") Str.isEmpty
## Result.mapErr (Ok 12) Str.isEmpty ## Result.mapErr (Ok 12) Str.isEmpty
@ -70,9 +68,8 @@ mapErr = \result, transform ->
Err e -> Err (transform e) Err e -> Err (transform e)
## If the result is `Ok`, transform the entire result by running a conversion ## If the result is `Ok`, transform the entire result by running a conversion
## function on the value the `Ok` holds. Then return that new result. ## function on the value the `Ok` holds. Then return that new result. If the
## ## result is `Err`, this has no effect. Use `onErr` to transform an `Err`.
## (If the result is `Err`, this has no effect. Use `onErr` to transform an `Err`.)
## ``` ## ```
## Result.try (Ok -1) \num -> if num < 0 then Err "negative!" else Ok -num ## Result.try (Ok -1) \num -> if num < 0 then Err "negative!" else Ok -num
## Result.try (Err "yipes!") \num -> if num < 0 then Err "negative!" else Ok -num ## Result.try (Err "yipes!") \num -> if num < 0 then Err "negative!" else Ok -num
@ -84,9 +81,8 @@ try = \result, transform ->
Err e -> Err e Err e -> Err e
## If the result is `Err`, transform the entire result by running a conversion ## If the result is `Err`, transform the entire result by running a conversion
## function on the value the `Err` holds. Then return that new result. ## function on the value the `Err` holds. Then return that new result. If the
## ## result is `Ok`, this has no effect. Use `try` to transform an `Ok`.
## (If the result is `Ok`, this has no effect. Use `try` to transform an `Ok`.)
## ``` ## ```
## Result.onErr (Ok 10) \errorNum -> Str.toNat errorNum ## Result.onErr (Ok 10) \errorNum -> Str.toNat errorNum
## Result.onErr (Err "42") \errorNum -> Str.toNat errorNum ## Result.onErr (Err "42") \errorNum -> Str.toNat errorNum

154
crates/compiler/builtins/roc/Set.roc
View File

@ -4,6 +4,7 @@ interface Set
empty, empty,
single, single,
walk, walk,
walkUntil,
insert, insert,
len, len,
remove, remove,
@ -25,6 +26,8 @@ interface Set
# We should have this line above the next has. # We should have this line above the next has.
# It causes the formatter to fail currently. # It causes the formatter to fail currently.
# | k has Hash & Eq # | k has Hash & Eq
## Provides a [set](https://en.wikipedia.org/wiki/Set_(abstract_data_type))
## type which stores a collection of unique values, without any ordering
Set k := Dict.Dict k {} Set k := Dict.Dict k {}
has [ has [
Eq { Eq {
@ -43,14 +46,39 @@ isEq = \xs, ys ->
else else
Break Bool.false Break Bool.false
## Creates a new empty set. ## Creates a new empty `Set`.
## ```
## emptySet = Set.empty {}
## countValues = Set.len emptySet
##
## expect countValues == 0
## ```
empty : {} -> Set k | k has Hash & Eq empty : {} -> Set k | k has Hash & Eq
empty = \{} -> @Set (Dict.empty {}) empty = \{} -> @Set (Dict.empty {})
## Creates a new `Set` with a single value.
## ```
## singleItemSet = Set.single "Apple"
## countValues = Set.len singleItemSet
##
## expect countValues == 1
## ```
single : k -> Set k | k has Hash & Eq single : k -> Set k | k has Hash & Eq
single = \key -> single = \key ->
Dict.single key {} |> @Set Dict.single key {} |> @Set
## Insert a value into a `Set`.
## ```
## fewItemSet =
## Set.empty {}
## |> Set.insert "Apple"
## |> Set.insert "Pear"
## |> Set.insert "Banana"
##
## countValues = Set.len fewItemSet
##
## expect countValues == 3
## ```
insert : Set k, k -> Set k | k has Hash & Eq insert : Set k, k -> Set k | k has Hash & Eq
insert = \@Set dict, key -> insert = \@Set dict, key ->
Dict.insert dict key {} |> @Set Dict.insert dict key {} |> @Set
@ -72,6 +100,18 @@ expect
expected == actual expected == actual
## Counts the number of values in a given `Set`.
## ```
## fewItemSet =
## Set.empty {}
## |> Set.insert "Apple"
## |> Set.insert "Pear"
## |> Set.insert "Banana"
##
## countValues = Set.len fewItemSet
##
## expect countValues == 3
## ```
len : Set k -> Nat | k has Hash & Eq len : Set k -> Nat | k has Hash & Eq
len = \@Set dict -> len = \@Set dict ->
Dict.len dict Dict.len dict
@ -88,41 +128,151 @@ expect
actual == 3 actual == 3
## Drops the given element from the set. ## Removes the value from the given `Set`.
## ```
## numbers =
## Set.empty {}
## |> Set.insert 10
## |> Set.insert 20
## |> Set.remove 10
##
## has10 = Set.contains numbers 10
## has20 = Set.contains numbers 20
##
## expect has10 == Bool.false
## expect has20 == Bool.true
## ```
remove : Set k, k -> Set k | k has Hash & Eq remove : Set k, k -> Set k | k has Hash & Eq
remove = \@Set dict, key -> remove = \@Set dict, key ->
Dict.remove dict key |> @Set Dict.remove dict key |> @Set
## Test if a value is in the `Set`.
## ```
## Fruit : [Apple, Pear, Banana]
##
## fruit : Set Fruit
## fruit =
## Set.single Apple
## |> Set.insert Pear
##
## hasApple = Set.contains fruit Apple
## hasBanana = Set.contains fruit Banana
##
## expect hasApple == Bool.true
## expect hasBanana == Bool.false
## ```
contains : Set k, k -> Bool | k has Hash & Eq contains : Set k, k -> Bool | k has Hash & Eq
contains = \@Set dict, key -> contains = \@Set dict, key ->
Dict.contains dict key Dict.contains dict key
## Retrieve the values in a `Set` as a `List`.
## ```
## numbers : Set U64
## numbers = Set.fromList [1,2,3,4,5]
##
## values = [1,2,3,4,5]
##
## expect Set.toList numbers == values
## ```
toList : Set k -> List k | k has Hash & Eq toList : Set k -> List k | k has Hash & Eq
toList = \@Set dict -> toList = \@Set dict ->
Dict.keys dict Dict.keys dict
## Create a `Set` from a `List` of values.
## ```
## values =
## Set.empty {}
## |> Set.insert Banana
## |> Set.insert Apple
## |> Set.insert Pear
##
## expect Set.fromList [Pear, Apple, Banana] == values
## ```
fromList : List k -> Set k | k has Hash & Eq fromList : List k -> Set k | k has Hash & Eq
fromList = \list -> fromList = \list ->
initial = @Set (Dict.withCapacity (List.len list)) initial = @Set (Dict.withCapacity (List.len list))
List.walk list initial insert List.walk list initial insert
## Combine two `Set` collection by keeping the
## [union](https://en.wikipedia.org/wiki/Union_(set_theory))
## of all the values pairs. This means that all of the values in both `Set`s
## will be combined.
## ```
## set1 = Set.single Left
## set2 = Set.single Right
##
## expect Set.union set1 set2 == Set.fromList [Left, Right]
## ```
union : Set k, Set k -> Set k | k has Hash & Eq union : Set k, Set k -> Set k | k has Hash & Eq
union = \@Set dict1, @Set dict2 -> union = \@Set dict1, @Set dict2 ->
Dict.insertAll dict1 dict2 |> @Set Dict.insertAll dict1 dict2 |> @Set
## Combine two `Set`s by keeping the [intersection](https://en.wikipedia.org/wiki/Intersection_(set_theory))
## of all the values pairs. This means that we keep only those values that are
## in both `Set`s.
## ```
## set1 = Set.fromList [Left, Other]
## set2 = Set.fromList [Left, Right]
##
## expect Set.intersection set1 set2 == Set.single Left
## ```
intersection : Set k, Set k -> Set k | k has Hash & Eq intersection : Set k, Set k -> Set k | k has Hash & Eq
intersection = \@Set dict1, @Set dict2 -> intersection = \@Set dict1, @Set dict2 ->
Dict.keepShared dict1 dict2 |> @Set Dict.keepShared dict1 dict2 |> @Set
## Remove the values in the first `Set` that are also in the second `Set`
## using the [set difference](https://en.wikipedia.org/wiki/Complement_(set_theory)#Relative_complement)
## of the values. This means that we will be left with only those values that
## are in the first and not in the second.
## ```
## first = Set.fromList [Left, Right, Up, Down]
## second = Set.fromList [Left, Right]
##
## expect Set.difference first second == Set.fromList [Up, Down]
## ```
difference : Set k, Set k -> Set k | k has Hash & Eq difference : Set k, Set k -> Set k | k has Hash & Eq
difference = \@Set dict1, @Set dict2 -> difference = \@Set dict1, @Set dict2 ->
Dict.removeAll dict1 dict2 |> @Set Dict.removeAll dict1 dict2 |> @Set
## Iterate through the values of a given `Set` and build a value.
## ```
## values = Set.fromList ["March", "April", "May"]
##
## startsWithLetterM = \month ->
## when Str.toUtf8 month is
## ['M', ..] -> Bool.true
## _ -> Bool.false
##
## reduce = \state, k ->
## if startsWithLetterM k then
## state + 1
## else
## state
##
## result = Set.walk values 0 reduce
##
## expect result == 2
## ```
walk : Set k, state, (state, k -> state) -> state | k has Hash & Eq walk : Set k, state, (state, k -> state) -> state | k has Hash & Eq
walk = \@Set dict, state, step -> walk = \@Set dict, state, step ->
Dict.walk dict state (\s, k, _ -> step s k) Dict.walk dict state (\s, k, _ -> step s k)
## Iterate through the values of a given `Set` and build a value, can stop
## iterating part way through the collection.
## ```
## numbers = Set.fromList [1,2,3,4,5,6,42,7,8,9,10]
##
## find42 = \state, k ->
## if k == 42 then
## Break FoundTheAnswer
## else
## Continue state
##
## result = Set.walkUntil numbers NotFound find42
##
## expect result == FoundTheAnswer
## ```
walkUntil : Set k, state, (state, k -> [Continue state, Break state]) -> state | k has Hash & Eq walkUntil : Set k, state, (state, k -> [Continue state, Break state]) -> state | k has Hash & Eq
walkUntil = \@Set dict, state, step -> walkUntil = \@Set dict, state, step ->
Dict.walkUntil dict state (\s, k, _ -> step s k) Dict.walkUntil dict state (\s, k, _ -> step s k)

9
crates/compiler/builtins/roc/Str.roc
View File

@ -1,6 +1,5 @@
## Working with Unicode strings in Roc.
## ##
## ### Unicode ## ## Working with Unicode strings in Roc
## ##
## Unicode can represent text values which span multiple languages, symbols, and emoji. ## Unicode can represent text values which span multiple languages, symbols, and emoji.
## Here are some valid Roc strings: ## Here are some valid Roc strings:
@ -124,7 +123,6 @@ interface Str
Num.{ Nat, Num, U8, U16, U32, U64, U128, I8, I16, I32, I64, I128, F32, F64, Dec }, Num.{ Nat, Num, U8, U16, U32, U64, U128, I8, I16, I32, I64, I128, F32, F64, Dec },
] ]
## Test
Utf8ByteProblem : [ Utf8ByteProblem : [
InvalidStartByte, InvalidStartByte,
UnexpectedEndOfSequence, UnexpectedEndOfSequence,
@ -214,7 +212,10 @@ graphemes : Str -> List Str
## expect !Str.startsWithScalar "9" 9 # the Unicode scalar for "9" is 57, not 9 ## expect !Str.startsWithScalar "9" 9 # the Unicode scalar for "9" is 57, not 9
## expect !Str.startsWithScalar "" 40527 ## expect !Str.startsWithScalar "" 40527
## ``` ## ```
## **Performance Note:** This runs slightly faster than [Str.startsWith], so ##
## ## Performance Details
##
## This runs slightly faster than [Str.startsWith], so
## if you want to check whether a string begins with something that's representable ## if you want to check whether a string begins with something that's representable
## in a single code point, you can use (for example) `Str.startsWithScalar '鹏'` ## in a single code point, you can use (for example) `Str.startsWithScalar '鹏'`
## instead of `Str.startsWith "鹏"`. ('鹏' evaluates to the [U32] value `40527`.) ## instead of `Str.startsWith "鹏"`. ('鹏' evaluates to the [U32] value `40527`.)

128
crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt
View File

@ -44,7 +44,7 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106; ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.115 Encode.94 Encode.96 Encode.102; let Encode.113 : List U8 = CallByName Json.114 Encode.94 Encode.96 Encode.102;
ret Encode.113; ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
@ -52,11 +52,11 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.115; ret Encode.115;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.125 : List U8 = CallByName Json.115 Encode.94 Encode.96 Encode.102; let Encode.125 : List U8 = CallByName Json.114 Encode.94 Encode.96 Encode.102;
ret Encode.125; ret Encode.125;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.128 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102; let Encode.128 : List U8 = CallByName Json.98 Encode.94 Encode.96 Encode.102;
ret Encode.128; ret Encode.128;
procedure Encode.25 (Encode.100, Encode.101): procedure Encode.25 (Encode.100, Encode.101):
@ -69,54 +69,54 @@ procedure Json.1 ():
let Json.425 : {} = Struct {}; let Json.425 : {} = Struct {};
ret Json.425; ret Json.425;
procedure Json.115 (Json.116, Json.428, Json.114): procedure Json.114 (Json.115, Json.428, Json.113):
let Json.461 : I64 = 123i64; let Json.461 : I64 = 123i64;
let Json.460 : U8 = CallByName Num.127 Json.461; let Json.460 : U8 = CallByName Num.127 Json.461;
let Json.118 : List U8 = CallByName List.4 Json.116 Json.460; let Json.117 : List U8 = CallByName List.4 Json.115 Json.460;
let Json.459 : U64 = CallByName List.6 Json.114; let Json.459 : U64 = CallByName List.6 Json.113;
let Json.436 : {List U8, U64} = Struct {Json.118, Json.459}; let Json.436 : {List U8, U64} = Struct {Json.117, Json.459};
let Json.437 : {} = Struct {}; let Json.437 : {} = Struct {};
let Json.435 : {List U8, U64} = CallByName List.18 Json.114 Json.436 Json.437; let Json.435 : {List U8, U64} = CallByName List.18 Json.113 Json.436 Json.437;
dec Json.114; dec Json.113;
let Json.120 : List U8 = StructAtIndex 0 Json.435; let Json.119 : List U8 = StructAtIndex 0 Json.435;
inc Json.120; inc Json.119;
dec Json.435; dec Json.435;
let Json.434 : I64 = 125i64; let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434; let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.432 : List U8 = CallByName List.4 Json.120 Json.433; let Json.432 : List U8 = CallByName List.4 Json.119 Json.433;
ret Json.432; ret Json.432;
procedure Json.115 (Json.116, Json.428, Json.114): procedure Json.114 (Json.115, Json.428, Json.113):
let Json.501 : I64 = 123i64; let Json.501 : I64 = 123i64;
let Json.500 : U8 = CallByName Num.127 Json.501; let Json.500 : U8 = CallByName Num.127 Json.501;
let Json.118 : List U8 = CallByName List.4 Json.116 Json.500; let Json.117 : List U8 = CallByName List.4 Json.115 Json.500;
let Json.499 : U64 = CallByName List.6 Json.114; let Json.499 : U64 = CallByName List.6 Json.113;
let Json.476 : {List U8, U64} = Struct {Json.118, Json.499}; let Json.476 : {List U8, U64} = Struct {Json.117, Json.499};
let Json.477 : {} = Struct {}; let Json.477 : {} = Struct {};
let Json.475 : {List U8, U64} = CallByName List.18 Json.114 Json.476 Json.477; let Json.475 : {List U8, U64} = CallByName List.18 Json.113 Json.476 Json.477;
dec Json.114; dec Json.113;
let Json.120 : List U8 = StructAtIndex 0 Json.475; let Json.119 : List U8 = StructAtIndex 0 Json.475;
inc Json.120; inc Json.119;
dec Json.475; dec Json.475;
let Json.474 : I64 = 125i64; let Json.474 : I64 = 125i64;
let Json.473 : U8 = CallByName Num.127 Json.474; let Json.473 : U8 = CallByName Num.127 Json.474;
let Json.472 : List U8 = CallByName List.4 Json.120 Json.473; let Json.472 : List U8 = CallByName List.4 Json.119 Json.473;
ret Json.472; ret Json.472;
procedure Json.117 (Json.430, Json.431): procedure Json.116 (Json.430, Json.431):
let Json.123 : Str = StructAtIndex 0 Json.431; let Json.122 : Str = StructAtIndex 0 Json.431;
inc Json.122;
let Json.123 : Str = StructAtIndex 1 Json.431;
inc Json.123; inc Json.123;
let Json.124 : Str = StructAtIndex 1 Json.431;
inc Json.124;
dec Json.431; dec Json.431;
let Json.121 : List U8 = StructAtIndex 0 Json.430; let Json.120 : List U8 = StructAtIndex 0 Json.430;
inc Json.121; inc Json.120;
let Json.122 : U64 = StructAtIndex 1 Json.430; let Json.121 : U64 = StructAtIndex 1 Json.430;
dec Json.430; dec Json.430;
let Json.458 : I64 = 34i64; let Json.458 : I64 = 34i64;
let Json.457 : U8 = CallByName Num.127 Json.458; let Json.457 : U8 = CallByName Num.127 Json.458;
let Json.455 : List U8 = CallByName List.4 Json.121 Json.457; let Json.455 : List U8 = CallByName List.4 Json.120 Json.457;
let Json.456 : List U8 = CallByName Str.12 Json.123; let Json.456 : List U8 = CallByName Str.12 Json.122;
let Json.452 : List U8 = CallByName List.8 Json.455 Json.456; let Json.452 : List U8 = CallByName List.8 Json.455 Json.456;
let Json.454 : I64 = 34i64; let Json.454 : I64 = 34i64;
let Json.453 : U8 = CallByName Num.127 Json.454; let Json.453 : U8 = CallByName Num.127 Json.454;
@ -125,37 +125,37 @@ procedure Json.117 (Json.430, Json.431):
let Json.450 : U8 = CallByName Num.127 Json.451; let Json.450 : U8 = CallByName Num.127 Json.451;
let Json.447 : List U8 = CallByName List.4 Json.449 Json.450; let Json.447 : List U8 = CallByName List.4 Json.449 Json.450;
let Json.448 : {} = Struct {}; let Json.448 : {} = Struct {};
let Json.125 : List U8 = CallByName Encode.23 Json.447 Json.124 Json.448; let Json.124 : List U8 = CallByName Encode.23 Json.447 Json.123 Json.448;
joinpoint Json.442 Json.126: joinpoint Json.442 Json.125:
let Json.440 : U64 = 1i64; let Json.440 : U64 = 1i64;
let Json.439 : U64 = CallByName Num.20 Json.122 Json.440; let Json.439 : U64 = CallByName Num.20 Json.121 Json.440;
let Json.438 : {List U8, U64} = Struct {Json.126, Json.439}; let Json.438 : {List U8, U64} = Struct {Json.125, Json.439};
ret Json.438; ret Json.438;
in in
let Json.446 : U64 = 1i64; let Json.446 : U64 = 1i64;
let Json.443 : Int1 = CallByName Num.24 Json.122 Json.446; let Json.443 : Int1 = CallByName Num.24 Json.121 Json.446;
if Json.443 then if Json.443 then
let Json.445 : I64 = 44i64; let Json.445 : I64 = 44i64;
let Json.444 : U8 = CallByName Num.127 Json.445; let Json.444 : U8 = CallByName Num.127 Json.445;
let Json.441 : List U8 = CallByName List.4 Json.125 Json.444; let Json.441 : List U8 = CallByName List.4 Json.124 Json.444;
jump Json.442 Json.441; jump Json.442 Json.441;
else else
jump Json.442 Json.125; jump Json.442 Json.124;
procedure Json.117 (Json.430, Json.431): procedure Json.116 (Json.430, Json.431):
let Json.123 : Str = StructAtIndex 0 Json.431; let Json.122 : Str = StructAtIndex 0 Json.431;
inc Json.122;
let Json.123 : Str = StructAtIndex 1 Json.431;
inc Json.123; inc Json.123;
let Json.124 : Str = StructAtIndex 1 Json.431;
inc Json.124;
dec Json.431; dec Json.431;
let Json.121 : List U8 = StructAtIndex 0 Json.430; let Json.120 : List U8 = StructAtIndex 0 Json.430;
inc Json.121; inc Json.120;
let Json.122 : U64 = StructAtIndex 1 Json.430; let Json.121 : U64 = StructAtIndex 1 Json.430;
dec Json.430; dec Json.430;
let Json.498 : I64 = 34i64; let Json.498 : I64 = 34i64;
let Json.497 : U8 = CallByName Num.127 Json.498; let Json.497 : U8 = CallByName Num.127 Json.498;
let Json.495 : List U8 = CallByName List.4 Json.121 Json.497; let Json.495 : List U8 = CallByName List.4 Json.120 Json.497;
let Json.496 : List U8 = CallByName Str.12 Json.123; let Json.496 : List U8 = CallByName Str.12 Json.122;
let Json.492 : List U8 = CallByName List.8 Json.495 Json.496; let Json.492 : List U8 = CallByName List.8 Json.495 Json.496;
let Json.494 : I64 = 34i64; let Json.494 : I64 = 34i64;
let Json.493 : U8 = CallByName Num.127 Json.494; let Json.493 : U8 = CallByName Num.127 Json.494;
@ -164,40 +164,40 @@ procedure Json.117 (Json.430, Json.431):
let Json.490 : U8 = CallByName Num.127 Json.491; let Json.490 : U8 = CallByName Num.127 Json.491;
let Json.487 : List U8 = CallByName List.4 Json.489 Json.490; let Json.487 : List U8 = CallByName List.4 Json.489 Json.490;
let Json.488 : {} = Struct {}; let Json.488 : {} = Struct {};
let Json.125 : List U8 = CallByName Encode.23 Json.487 Json.124 Json.488; let Json.124 : List U8 = CallByName Encode.23 Json.487 Json.123 Json.488;
joinpoint Json.482 Json.126: joinpoint Json.482 Json.125:
let Json.480 : U64 = 1i64; let Json.480 : U64 = 1i64;
let Json.479 : U64 = CallByName Num.20 Json.122 Json.480; let Json.479 : U64 = CallByName Num.20 Json.121 Json.480;
let Json.478 : {List U8, U64} = Struct {Json.126, Json.479}; let Json.478 : {List U8, U64} = Struct {Json.125, Json.479};
ret Json.478; ret Json.478;
in in
let Json.486 : U64 = 1i64; let Json.486 : U64 = 1i64;
let Json.483 : Int1 = CallByName Num.24 Json.122 Json.486; let Json.483 : Int1 = CallByName Num.24 Json.121 Json.486;
if Json.483 then if Json.483 then
let Json.485 : I64 = 44i64; let Json.485 : I64 = 44i64;
let Json.484 : U8 = CallByName Num.127 Json.485; let Json.484 : U8 = CallByName Num.127 Json.485;
let Json.481 : List U8 = CallByName List.4 Json.125 Json.484; let Json.481 : List U8 = CallByName List.4 Json.124 Json.484;
jump Json.482 Json.481; jump Json.482 Json.481;
else else
jump Json.482 Json.125; jump Json.482 Json.124;
procedure Json.18 (Json.98): procedure Json.18 (Json.97):
let Json.502 : Str = CallByName Encode.22 Json.98; let Json.502 : Str = CallByName Encode.22 Json.97;
ret Json.502; ret Json.502;
procedure Json.20 (Json.114): procedure Json.20 (Json.113):
let Json.426 : List {Str, Str} = CallByName Encode.22 Json.114; let Json.426 : List {Str, Str} = CallByName Encode.22 Json.113;
ret Json.426; ret Json.426;
procedure Json.20 (Json.114): procedure Json.20 (Json.113):
let Json.468 : List {Str, Str} = CallByName Encode.22 Json.114; let Json.468 : List {Str, Str} = CallByName Encode.22 Json.113;
ret Json.468; ret Json.468;
procedure Json.99 (Json.100, Json.504, Json.98): procedure Json.98 (Json.99, Json.504, Json.97):
let Json.513 : I64 = 34i64; let Json.513 : I64 = 34i64;
let Json.512 : U8 = CallByName Num.127 Json.513; let Json.512 : U8 = CallByName Num.127 Json.513;
let Json.510 : List U8 = CallByName List.4 Json.100 Json.512; let Json.510 : List U8 = CallByName List.4 Json.99 Json.512;
let Json.511 : List U8 = CallByName Str.12 Json.98; let Json.511 : List U8 = CallByName Str.12 Json.97;
let Json.507 : List U8 = CallByName List.8 Json.510 Json.511; let Json.507 : List U8 = CallByName List.8 Json.510 Json.511;
let Json.509 : I64 = 34i64; let Json.509 : I64 = 34i64;
let Json.508 : U8 = CallByName Num.127 Json.509; let Json.508 : U8 = CallByName Num.127 Json.509;
@ -205,11 +205,11 @@ procedure Json.99 (Json.100, Json.504, Json.98):
ret Json.506; ret Json.506;
procedure List.139 (List.140, List.141, List.138): procedure List.139 (List.140, List.141, List.138):
let List.535 : {List U8, U64} = CallByName Json.117 List.140 List.141; let List.535 : {List U8, U64} = CallByName Json.116 List.140 List.141;
ret List.535; ret List.535;
procedure List.139 (List.140, List.141, List.138): procedure List.139 (List.140, List.141, List.138):
let List.608 : {List U8, U64} = CallByName Json.117 List.140 List.141; let List.608 : {List U8, U64} = CallByName Json.116 List.140 List.141;
ret List.608; ret List.608;
procedure List.18 (List.136, List.137, List.138): procedure List.18 (List.136, List.137, List.138):

70
crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt
View File

@ -25,11 +25,11 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106; ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.115 Encode.94 Encode.96 Encode.102; let Encode.113 : List U8 = CallByName Json.114 Encode.94 Encode.96 Encode.102;
ret Encode.113; ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.116 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102; let Encode.116 : List U8 = CallByName Json.98 Encode.94 Encode.96 Encode.102;
ret Encode.116; ret Encode.116;
procedure Encode.25 (Encode.100, Encode.101): procedure Encode.25 (Encode.100, Encode.101):
@ -42,37 +42,37 @@ procedure Json.1 ():
let Json.425 : {} = Struct {}; let Json.425 : {} = Struct {};
ret Json.425; ret Json.425;
procedure Json.115 (Json.116, Json.428, Json.114): procedure Json.114 (Json.115, Json.428, Json.113):
let Json.461 : I64 = 123i64; let Json.461 : I64 = 123i64;
let Json.460 : U8 = CallByName Num.127 Json.461; let Json.460 : U8 = CallByName Num.127 Json.461;
let Json.118 : List U8 = CallByName List.4 Json.116 Json.460; let Json.117 : List U8 = CallByName List.4 Json.115 Json.460;
let Json.459 : U64 = CallByName List.6 Json.114; let Json.459 : U64 = CallByName List.6 Json.113;
let Json.436 : {List U8, U64} = Struct {Json.118, Json.459}; let Json.436 : {List U8, U64} = Struct {Json.117, Json.459};
let Json.437 : {} = Struct {}; let Json.437 : {} = Struct {};
let Json.435 : {List U8, U64} = CallByName List.18 Json.114 Json.436 Json.437; let Json.435 : {List U8, U64} = CallByName List.18 Json.113 Json.436 Json.437;
dec Json.114; dec Json.113;
let Json.120 : List U8 = StructAtIndex 0 Json.435; let Json.119 : List U8 = StructAtIndex 0 Json.435;
inc Json.120; inc Json.119;
dec Json.435; dec Json.435;
let Json.434 : I64 = 125i64; let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434; let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.432 : List U8 = CallByName List.4 Json.120 Json.433; let Json.432 : List U8 = CallByName List.4 Json.119 Json.433;
ret Json.432; ret Json.432;
procedure Json.117 (Json.430, Json.431): procedure Json.116 (Json.430, Json.431):
let Json.123 : Str = StructAtIndex 0 Json.431; let Json.122 : Str = StructAtIndex 0 Json.431;
inc Json.122;
let Json.123 : Str = StructAtIndex 1 Json.431;
inc Json.123; inc Json.123;
let Json.124 : Str = StructAtIndex 1 Json.431;
inc Json.124;
dec Json.431; dec Json.431;
let Json.121 : List U8 = StructAtIndex 0 Json.430; let Json.120 : List U8 = StructAtIndex 0 Json.430;
inc Json.121; inc Json.120;
let Json.122 : U64 = StructAtIndex 1 Json.430; let Json.121 : U64 = StructAtIndex 1 Json.430;
dec Json.430; dec Json.430;
let Json.458 : I64 = 34i64; let Json.458 : I64 = 34i64;
let Json.457 : U8 = CallByName Num.127 Json.458; let Json.457 : U8 = CallByName Num.127 Json.458;
let Json.455 : List U8 = CallByName List.4 Json.121 Json.457; let Json.455 : List U8 = CallByName List.4 Json.120 Json.457;
let Json.456 : List U8 = CallByName Str.12 Json.123; let Json.456 : List U8 = CallByName Str.12 Json.122;
let Json.452 : List U8 = CallByName List.8 Json.455 Json.456; let Json.452 : List U8 = CallByName List.8 Json.455 Json.456;
let Json.454 : I64 = 34i64; let Json.454 : I64 = 34i64;
let Json.453 : U8 = CallByName Num.127 Json.454; let Json.453 : U8 = CallByName Num.127 Json.454;
@ -81,36 +81,36 @@ procedure Json.117 (Json.430, Json.431):
let Json.450 : U8 = CallByName Num.127 Json.451; let Json.450 : U8 = CallByName Num.127 Json.451;
let Json.447 : List U8 = CallByName List.4 Json.449 Json.450; let Json.447 : List U8 = CallByName List.4 Json.449 Json.450;
let Json.448 : {} = Struct {}; let Json.448 : {} = Struct {};
let Json.125 : List U8 = CallByName Encode.23 Json.447 Json.124 Json.448; let Json.124 : List U8 = CallByName Encode.23 Json.447 Json.123 Json.448;
joinpoint Json.442 Json.126: joinpoint Json.442 Json.125:
let Json.440 : U64 = 1i64; let Json.440 : U64 = 1i64;
let Json.439 : U64 = CallByName Num.20 Json.122 Json.440; let Json.439 : U64 = CallByName Num.20 Json.121 Json.440;
let Json.438 : {List U8, U64} = Struct {Json.126, Json.439}; let Json.438 : {List U8, U64} = Struct {Json.125, Json.439};
ret Json.438; ret Json.438;
in in
let Json.446 : U64 = 1i64; let Json.446 : U64 = 1i64;
let Json.443 : Int1 = CallByName Num.24 Json.122 Json.446; let Json.443 : Int1 = CallByName Num.24 Json.121 Json.446;
if Json.443 then if Json.443 then
let Json.445 : I64 = 44i64; let Json.445 : I64 = 44i64;
let Json.444 : U8 = CallByName Num.127 Json.445; let Json.444 : U8 = CallByName Num.127 Json.445;
let Json.441 : List U8 = CallByName List.4 Json.125 Json.444; let Json.441 : List U8 = CallByName List.4 Json.124 Json.444;
jump Json.442 Json.441; jump Json.442 Json.441;
else else
jump Json.442 Json.125; jump Json.442 Json.124;
procedure Json.18 (Json.98): procedure Json.18 (Json.97):
let Json.462 : Str = CallByName Encode.22 Json.98; let Json.462 : Str = CallByName Encode.22 Json.97;
ret Json.462; ret Json.462;
procedure Json.20 (Json.114): procedure Json.20 (Json.113):
let Json.426 : List {Str, Str} = CallByName Encode.22 Json.114; let Json.426 : List {Str, Str} = CallByName Encode.22 Json.113;
ret Json.426; ret Json.426;
procedure Json.99 (Json.100, Json.464, Json.98): procedure Json.98 (Json.99, Json.464, Json.97):
let Json.473 : I64 = 34i64; let Json.473 : I64 = 34i64;
let Json.472 : U8 = CallByName Num.127 Json.473; let Json.472 : U8 = CallByName Num.127 Json.473;
let Json.470 : List U8 = CallByName List.4 Json.100 Json.472; let Json.470 : List U8 = CallByName List.4 Json.99 Json.472;
let Json.471 : List U8 = CallByName Str.12 Json.98; let Json.471 : List U8 = CallByName Str.12 Json.97;
let Json.467 : List U8 = CallByName List.8 Json.470 Json.471; let Json.467 : List U8 = CallByName List.8 Json.470 Json.471;
let Json.469 : I64 = 34i64; let Json.469 : I64 = 34i64;
let Json.468 : U8 = CallByName Num.127 Json.469; let Json.468 : U8 = CallByName Num.127 Json.469;
@ -118,7 +118,7 @@ procedure Json.99 (Json.100, Json.464, Json.98):
ret Json.466; ret Json.466;
procedure List.139 (List.140, List.141, List.138): procedure List.139 (List.140, List.141, List.138):
let List.541 : {List U8, U64} = CallByName Json.117 List.140 List.141; let List.541 : {List U8, U64} = CallByName Json.116 List.140 List.141;
ret List.541; ret List.541;
procedure List.18 (List.136, List.137, List.138): procedure List.18 (List.136, List.137, List.138):

70
crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt
View File

@ -33,11 +33,11 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106; ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.115 Encode.94 Encode.96 Encode.102; let Encode.113 : List U8 = CallByName Json.114 Encode.94 Encode.96 Encode.102;
ret Encode.113; ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.117 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102; let Encode.117 : List U8 = CallByName Json.98 Encode.94 Encode.96 Encode.102;
ret Encode.117; ret Encode.117;
procedure Encode.25 (Encode.100, Encode.101): procedure Encode.25 (Encode.100, Encode.101):
@ -50,37 +50,37 @@ procedure Json.1 ():
let Json.425 : {} = Struct {}; let Json.425 : {} = Struct {};
ret Json.425; ret Json.425;
procedure Json.115 (Json.116, Json.428, Json.114): procedure Json.114 (Json.115, Json.428, Json.113):
let Json.461 : I64 = 123i64; let Json.461 : I64 = 123i64;
let Json.460 : U8 = CallByName Num.127 Json.461; let Json.460 : U8 = CallByName Num.127 Json.461;
let Json.118 : List U8 = CallByName List.4 Json.116 Json.460; let Json.117 : List U8 = CallByName List.4 Json.115 Json.460;
let Json.459 : U64 = CallByName List.6 Json.114; let Json.459 : U64 = CallByName List.6 Json.113;
let Json.436 : {List U8, U64} = Struct {Json.118, Json.459}; let Json.436 : {List U8, U64} = Struct {Json.117, Json.459};
let Json.437 : {} = Struct {}; let Json.437 : {} = Struct {};
let Json.435 : {List U8, U64} = CallByName List.18 Json.114 Json.436 Json.437; let Json.435 : {List U8, U64} = CallByName List.18 Json.113 Json.436 Json.437;
dec Json.114; dec Json.113;
let Json.120 : List U8 = StructAtIndex 0 Json.435; let Json.119 : List U8 = StructAtIndex 0 Json.435;
inc Json.120; inc Json.119;
dec Json.435; dec Json.435;
let Json.434 : I64 = 125i64; let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434; let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.432 : List U8 = CallByName List.4 Json.120 Json.433; let Json.432 : List U8 = CallByName List.4 Json.119 Json.433;
ret Json.432; ret Json.432;
procedure Json.117 (Json.430, Json.431): procedure Json.116 (Json.430, Json.431):
let Json.123 : Str = StructAtIndex 0 Json.431; let Json.122 : Str = StructAtIndex 0 Json.431;
inc Json.122;
let Json.123 : Str = StructAtIndex 1 Json.431;
inc Json.123; inc Json.123;
let Json.124 : Str = StructAtIndex 1 Json.431;
inc Json.124;
dec Json.431; dec Json.431;
let Json.121 : List U8 = StructAtIndex 0 Json.430; let Json.120 : List U8 = StructAtIndex 0 Json.430;
inc Json.121; inc Json.120;
let Json.122 : U64 = StructAtIndex 1 Json.430; let Json.121 : U64 = StructAtIndex 1 Json.430;
dec Json.430; dec Json.430;
let Json.458 : I64 = 34i64; let Json.458 : I64 = 34i64;
let Json.457 : U8 = CallByName Num.127 Json.458; let Json.457 : U8 = CallByName Num.127 Json.458;
let Json.455 : List U8 = CallByName List.4 Json.121 Json.457; let Json.455 : List U8 = CallByName List.4 Json.120 Json.457;
let Json.456 : List U8 = CallByName Str.12 Json.123; let Json.456 : List U8 = CallByName Str.12 Json.122;
let Json.452 : List U8 = CallByName List.8 Json.455 Json.456; let Json.452 : List U8 = CallByName List.8 Json.455 Json.456;
let Json.454 : I64 = 34i64; let Json.454 : I64 = 34i64;
let Json.453 : U8 = CallByName Num.127 Json.454; let Json.453 : U8 = CallByName Num.127 Json.454;
@ -89,36 +89,36 @@ procedure Json.117 (Json.430, Json.431):
let Json.450 : U8 = CallByName Num.127 Json.451; let Json.450 : U8 = CallByName Num.127 Json.451;
let Json.447 : List U8 = CallByName List.4 Json.449 Json.450; let Json.447 : List U8 = CallByName List.4 Json.449 Json.450;
let Json.448 : {} = Struct {}; let Json.448 : {} = Struct {};
let Json.125 : List U8 = CallByName Encode.23 Json.447 Json.124 Json.448; let Json.124 : List U8 = CallByName Encode.23 Json.447 Json.123 Json.448;
joinpoint Json.442 Json.126: joinpoint Json.442 Json.125:
let Json.440 : U64 = 1i64; let Json.440 : U64 = 1i64;
let Json.439 : U64 = CallByName Num.20 Json.122 Json.440; let Json.439 : U64 = CallByName Num.20 Json.121 Json.440;
let Json.438 : {List U8, U64} = Struct {Json.126, Json.439}; let Json.438 : {List U8, U64} = Struct {Json.125, Json.439};
ret Json.438; ret Json.438;
in in
let Json.446 : U64 = 1i64; let Json.446 : U64 = 1i64;
let Json.443 : Int1 = CallByName Num.24 Json.122 Json.446; let Json.443 : Int1 = CallByName Num.24 Json.121 Json.446;
if Json.443 then if Json.443 then
let Json.445 : I64 = 44i64; let Json.445 : I64 = 44i64;
let Json.444 : U8 = CallByName Num.127 Json.445; let Json.444 : U8 = CallByName Num.127 Json.445;
let Json.441 : List U8 = CallByName List.4 Json.125 Json.444; let Json.441 : List U8 = CallByName List.4 Json.124 Json.444;
jump Json.442 Json.441; jump Json.442 Json.441;
else else
jump Json.442 Json.125; jump Json.442 Json.124;
procedure Json.18 (Json.98): procedure Json.18 (Json.97):
let Json.474 : Str = CallByName Encode.22 Json.98; let Json.474 : Str = CallByName Encode.22 Json.97;
ret Json.474; ret Json.474;
procedure Json.20 (Json.114): procedure Json.20 (Json.113):
let Json.426 : List {Str, Str} = CallByName Encode.22 Json.114; let Json.426 : List {Str, Str} = CallByName Encode.22 Json.113;
ret Json.426; ret Json.426;
procedure Json.99 (Json.100, Json.464, Json.98): procedure Json.98 (Json.99, Json.464, Json.97):
let Json.473 : I64 = 34i64; let Json.473 : I64 = 34i64;
let Json.472 : U8 = CallByName Num.127 Json.473; let Json.472 : U8 = CallByName Num.127 Json.473;
let Json.470 : List U8 = CallByName List.4 Json.100 Json.472; let Json.470 : List U8 = CallByName List.4 Json.99 Json.472;
let Json.471 : List U8 = CallByName Str.12 Json.98; let Json.471 : List U8 = CallByName Str.12 Json.97;
let Json.467 : List U8 = CallByName List.8 Json.470 Json.471; let Json.467 : List U8 = CallByName List.8 Json.470 Json.471;
let Json.469 : I64 = 34i64; let Json.469 : I64 = 34i64;
let Json.468 : U8 = CallByName Num.127 Json.469; let Json.468 : U8 = CallByName Num.127 Json.469;
@ -126,7 +126,7 @@ procedure Json.99 (Json.100, Json.464, Json.98):
ret Json.466; ret Json.466;
procedure List.139 (List.140, List.141, List.138): procedure List.139 (List.140, List.141, List.138):
let List.541 : {List U8, U64} = CallByName Json.117 List.140 List.141; let List.541 : {List U8, U64} = CallByName Json.116 List.140 List.141;
ret List.541; ret List.541;
procedure List.18 (List.136, List.137, List.138): procedure List.18 (List.136, List.137, List.138):

12
crates/compiler/test_mono/generated/encode_derived_string.txt
View File

@ -2,7 +2,7 @@ procedure Encode.22 (Encode.93):
ret Encode.93; ret Encode.93;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.106 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102; let Encode.106 : List U8 = CallByName Json.98 Encode.94 Encode.96 Encode.102;
ret Encode.106; ret Encode.106;
procedure Encode.25 (Encode.100, Encode.101): procedure Encode.25 (Encode.100, Encode.101):
@ -15,15 +15,15 @@ procedure Json.1 ():
let Json.425 : {} = Struct {}; let Json.425 : {} = Struct {};
ret Json.425; ret Json.425;
procedure Json.18 (Json.98): procedure Json.18 (Json.97):
let Json.426 : Str = CallByName Encode.22 Json.98; let Json.426 : Str = CallByName Encode.22 Json.97;
ret Json.426; ret Json.426;
procedure Json.99 (Json.100, Json.428, Json.98): procedure Json.98 (Json.99, Json.428, Json.97):
let Json.437 : I64 = 34i64; let Json.437 : I64 = 34i64;
let Json.436 : U8 = CallByName Num.127 Json.437; let Json.436 : U8 = CallByName Num.127 Json.437;
let Json.434 : List U8 = CallByName List.4 Json.100 Json.436; let Json.434 : List U8 = CallByName List.4 Json.99 Json.436;
let Json.435 : List U8 = CallByName Str.12 Json.98; let Json.435 : List U8 = CallByName Str.12 Json.97;
let Json.431 : List U8 = CallByName List.8 Json.434 Json.435; let Json.431 : List U8 = CallByName List.8 Json.434 Json.435;
let Json.433 : I64 = 34i64; let Json.433 : I64 = 34i64;
let Json.432 : U8 = CallByName Num.127 Json.433; let Json.432 : U8 = CallByName Num.127 Json.433;

70
crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt
View File

@ -27,11 +27,11 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106; ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.129 Encode.94 Encode.96 Encode.102; let Encode.113 : List U8 = CallByName Json.128 Encode.94 Encode.96 Encode.102;
ret Encode.113; ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.116 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102; let Encode.116 : List U8 = CallByName Json.98 Encode.94 Encode.96 Encode.102;
ret Encode.116; ret Encode.116;
procedure Encode.25 (Encode.100, Encode.101): procedure Encode.25 (Encode.100, Encode.101):
@ -44,19 +44,19 @@ procedure Json.1 ():
let Json.425 : {} = Struct {}; let Json.425 : {} = Struct {};
ret Json.425; ret Json.425;
procedure Json.129 (Json.130, Json.428, #Attr.12): procedure Json.128 (Json.129, Json.428, #Attr.12):
let Json.128 : List Str = StructAtIndex 1 #Attr.12; let Json.127 : List Str = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
inc Json.127; inc Json.127;
let Json.126 : Str = StructAtIndex 0 #Attr.12;
inc Json.126;
dec #Attr.12; dec #Attr.12;
let Json.466 : I64 = 123i64; let Json.466 : I64 = 123i64;
let Json.465 : U8 = CallByName Num.127 Json.466; let Json.465 : U8 = CallByName Num.127 Json.466;
let Json.462 : List U8 = CallByName List.4 Json.130 Json.465; let Json.462 : List U8 = CallByName List.4 Json.129 Json.465;
let Json.464 : I64 = 34i64; let Json.464 : I64 = 34i64;
let Json.463 : U8 = CallByName Num.127 Json.464; let Json.463 : U8 = CallByName Num.127 Json.464;
let Json.460 : List U8 = CallByName List.4 Json.462 Json.463; let Json.460 : List U8 = CallByName List.4 Json.462 Json.463;
let Json.461 : List U8 = CallByName Str.12 Json.127; let Json.461 : List U8 = CallByName Str.12 Json.126;
let Json.457 : List U8 = CallByName List.8 Json.460 Json.461; let Json.457 : List U8 = CallByName List.8 Json.460 Json.461;
let Json.459 : I64 = 34i64; let Json.459 : I64 = 34i64;
let Json.458 : U8 = CallByName Num.127 Json.459; let Json.458 : U8 = CallByName Num.127 Json.459;
@ -66,60 +66,60 @@ procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.451 : List U8 = CallByName List.4 Json.454 Json.455; let Json.451 : List U8 = CallByName List.4 Json.454 Json.455;
let Json.453 : I64 = 91i64; let Json.453 : I64 = 91i64;
let Json.452 : U8 = CallByName Num.127 Json.453; let Json.452 : U8 = CallByName Num.127 Json.453;
let Json.132 : List U8 = CallByName List.4 Json.451 Json.452; let Json.131 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.128; let Json.450 : U64 = CallByName List.6 Json.127;
let Json.438 : {List U8, U64} = Struct {Json.132, Json.450}; let Json.438 : {List U8, U64} = Struct {Json.131, Json.450};
let Json.439 : {} = Struct {}; let Json.439 : {} = Struct {};
let Json.437 : {List U8, U64} = CallByName List.18 Json.128 Json.438 Json.439; let Json.437 : {List U8, U64} = CallByName List.18 Json.127 Json.438 Json.439;
dec Json.128; dec Json.127;
let Json.134 : List U8 = StructAtIndex 0 Json.437; let Json.133 : List U8 = StructAtIndex 0 Json.437;
inc Json.134; inc Json.133;
dec Json.437; dec Json.437;
let Json.436 : I64 = 93i64; let Json.436 : I64 = 93i64;
let Json.435 : U8 = CallByName Num.127 Json.436; let Json.435 : U8 = CallByName Num.127 Json.436;
let Json.432 : List U8 = CallByName List.4 Json.134 Json.435; let Json.432 : List U8 = CallByName List.4 Json.133 Json.435;
let Json.434 : I64 = 125i64; let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434; let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.431 : List U8 = CallByName List.4 Json.432 Json.433; let Json.431 : List U8 = CallByName List.4 Json.432 Json.433;
ret Json.431; ret Json.431;
procedure Json.131 (Json.430, Json.137): procedure Json.130 (Json.430, Json.136):
let Json.135 : List U8 = StructAtIndex 0 Json.430; let Json.134 : List U8 = StructAtIndex 0 Json.430;
inc Json.135; inc Json.134;
let Json.136 : U64 = StructAtIndex 1 Json.430; let Json.135 : U64 = StructAtIndex 1 Json.430;
dec Json.430; dec Json.430;
let Json.449 : {} = Struct {}; let Json.449 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.449; let Json.137 : List U8 = CallByName Encode.23 Json.134 Json.136 Json.449;
joinpoint Json.444 Json.139: joinpoint Json.444 Json.138:
let Json.442 : U64 = 1i64; let Json.442 : U64 = 1i64;
let Json.441 : U64 = CallByName Num.20 Json.136 Json.442; let Json.441 : U64 = CallByName Num.20 Json.135 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.139, Json.441}; let Json.440 : {List U8, U64} = Struct {Json.138, Json.441};
ret Json.440; ret Json.440;
in in
let Json.448 : U64 = 1i64; let Json.448 : U64 = 1i64;
let Json.445 : Int1 = CallByName Num.24 Json.136 Json.448; let Json.445 : Int1 = CallByName Num.24 Json.135 Json.448;
if Json.445 then if Json.445 then
let Json.447 : I64 = 44i64; let Json.447 : I64 = 44i64;
let Json.446 : U8 = CallByName Num.127 Json.447; let Json.446 : U8 = CallByName Num.127 Json.447;
let Json.443 : List U8 = CallByName List.4 Json.138 Json.446; let Json.443 : List U8 = CallByName List.4 Json.137 Json.446;
jump Json.444 Json.443; jump Json.444 Json.443;
else else
jump Json.444 Json.138; jump Json.444 Json.137;
procedure Json.18 (Json.98): procedure Json.18 (Json.97):
let Json.467 : Str = CallByName Encode.22 Json.98; let Json.467 : Str = CallByName Encode.22 Json.97;
ret Json.467; ret Json.467;
procedure Json.21 (Json.127, Json.128): procedure Json.21 (Json.126, Json.127):
let Json.427 : {Str, List Str} = Struct {Json.127, Json.128}; let Json.427 : {Str, List Str} = Struct {Json.126, Json.127};
let Json.426 : {Str, List Str} = CallByName Encode.22 Json.427; let Json.426 : {Str, List Str} = CallByName Encode.22 Json.427;
ret Json.426; ret Json.426;
procedure Json.99 (Json.100, Json.469, Json.98): procedure Json.98 (Json.99, Json.469, Json.97):
let Json.478 : I64 = 34i64; let Json.478 : I64 = 34i64;
let Json.477 : U8 = CallByName Num.127 Json.478; let Json.477 : U8 = CallByName Num.127 Json.478;
let Json.475 : List U8 = CallByName List.4 Json.100 Json.477; let Json.475 : List U8 = CallByName List.4 Json.99 Json.477;
let Json.476 : List U8 = CallByName Str.12 Json.98; let Json.476 : List U8 = CallByName Str.12 Json.97;
let Json.472 : List U8 = CallByName List.8 Json.475 Json.476; let Json.472 : List U8 = CallByName List.8 Json.475 Json.476;
let Json.474 : I64 = 34i64; let Json.474 : I64 = 34i64;
let Json.473 : U8 = CallByName Num.127 Json.474; let Json.473 : U8 = CallByName Num.127 Json.474;
@ -127,7 +127,7 @@ procedure Json.99 (Json.100, Json.469, Json.98):
ret Json.471; ret Json.471;
procedure List.139 (List.140, List.141, List.138): procedure List.139 (List.140, List.141, List.138):
let List.547 : {List U8, U64} = CallByName Json.131 List.140 List.141; let List.547 : {List U8, U64} = CallByName Json.130 List.140 List.141;
ret List.547; ret List.547;
procedure List.18 (List.136, List.137, List.138): procedure List.18 (List.136, List.137, List.138):

70
crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt
View File

@ -33,11 +33,11 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106; ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.129 Encode.94 Encode.96 Encode.102; let Encode.113 : List U8 = CallByName Json.128 Encode.94 Encode.96 Encode.102;
ret Encode.113; ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.117 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102; let Encode.117 : List U8 = CallByName Json.98 Encode.94 Encode.96 Encode.102;
ret Encode.117; ret Encode.117;
procedure Encode.25 (Encode.100, Encode.101): procedure Encode.25 (Encode.100, Encode.101):
@ -50,19 +50,19 @@ procedure Json.1 ():
let Json.425 : {} = Struct {}; let Json.425 : {} = Struct {};
ret Json.425; ret Json.425;
procedure Json.129 (Json.130, Json.428, #Attr.12): procedure Json.128 (Json.129, Json.428, #Attr.12):
let Json.128 : List Str = StructAtIndex 1 #Attr.12; let Json.127 : List Str = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
inc Json.127; inc Json.127;
let Json.126 : Str = StructAtIndex 0 #Attr.12;
inc Json.126;
dec #Attr.12; dec #Attr.12;
let Json.466 : I64 = 123i64; let Json.466 : I64 = 123i64;
let Json.465 : U8 = CallByName Num.127 Json.466; let Json.465 : U8 = CallByName Num.127 Json.466;
let Json.462 : List U8 = CallByName List.4 Json.130 Json.465; let Json.462 : List U8 = CallByName List.4 Json.129 Json.465;
let Json.464 : I64 = 34i64; let Json.464 : I64 = 34i64;
let Json.463 : U8 = CallByName Num.127 Json.464; let Json.463 : U8 = CallByName Num.127 Json.464;
let Json.460 : List U8 = CallByName List.4 Json.462 Json.463; let Json.460 : List U8 = CallByName List.4 Json.462 Json.463;
let Json.461 : List U8 = CallByName Str.12 Json.127; let Json.461 : List U8 = CallByName Str.12 Json.126;
let Json.457 : List U8 = CallByName List.8 Json.460 Json.461; let Json.457 : List U8 = CallByName List.8 Json.460 Json.461;
let Json.459 : I64 = 34i64; let Json.459 : I64 = 34i64;
let Json.458 : U8 = CallByName Num.127 Json.459; let Json.458 : U8 = CallByName Num.127 Json.459;
@ -72,60 +72,60 @@ procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.451 : List U8 = CallByName List.4 Json.454 Json.455; let Json.451 : List U8 = CallByName List.4 Json.454 Json.455;
let Json.453 : I64 = 91i64; let Json.453 : I64 = 91i64;
let Json.452 : U8 = CallByName Num.127 Json.453; let Json.452 : U8 = CallByName Num.127 Json.453;
let Json.132 : List U8 = CallByName List.4 Json.451 Json.452; let Json.131 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.128; let Json.450 : U64 = CallByName List.6 Json.127;
let Json.438 : {List U8, U64} = Struct {Json.132, Json.450}; let Json.438 : {List U8, U64} = Struct {Json.131, Json.450};
let Json.439 : {} = Struct {}; let Json.439 : {} = Struct {};
let Json.437 : {List U8, U64} = CallByName List.18 Json.128 Json.438 Json.439; let Json.437 : {List U8, U64} = CallByName List.18 Json.127 Json.438 Json.439;
dec Json.128; dec Json.127;
let Json.134 : List U8 = StructAtIndex 0 Json.437; let Json.133 : List U8 = StructAtIndex 0 Json.437;
inc Json.134; inc Json.133;
dec Json.437; dec Json.437;
let Json.436 : I64 = 93i64; let Json.436 : I64 = 93i64;
let Json.435 : U8 = CallByName Num.127 Json.436; let Json.435 : U8 = CallByName Num.127 Json.436;
let Json.432 : List U8 = CallByName List.4 Json.134 Json.435; let Json.432 : List U8 = CallByName List.4 Json.133 Json.435;
let Json.434 : I64 = 125i64; let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434; let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.431 : List U8 = CallByName List.4 Json.432 Json.433; let Json.431 : List U8 = CallByName List.4 Json.432 Json.433;
ret Json.431; ret Json.431;
procedure Json.131 (Json.430, Json.137): procedure Json.130 (Json.430, Json.136):
let Json.135 : List U8 = StructAtIndex 0 Json.430; let Json.134 : List U8 = StructAtIndex 0 Json.430;
inc Json.135; inc Json.134;
let Json.136 : U64 = StructAtIndex 1 Json.430; let Json.135 : U64 = StructAtIndex 1 Json.430;
dec Json.430; dec Json.430;
let Json.449 : {} = Struct {}; let Json.449 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.449; let Json.137 : List U8 = CallByName Encode.23 Json.134 Json.136 Json.449;
joinpoint Json.444 Json.139: joinpoint Json.444 Json.138:
let Json.442 : U64 = 1i64; let Json.442 : U64 = 1i64;
let Json.441 : U64 = CallByName Num.20 Json.136 Json.442; let Json.441 : U64 = CallByName Num.20 Json.135 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.139, Json.441}; let Json.440 : {List U8, U64} = Struct {Json.138, Json.441};
ret Json.440; ret Json.440;
in in
let Json.448 : U64 = 1i64; let Json.448 : U64 = 1i64;
let Json.445 : Int1 = CallByName Num.24 Json.136 Json.448; let Json.445 : Int1 = CallByName Num.24 Json.135 Json.448;
if Json.445 then if Json.445 then
let Json.447 : I64 = 44i64; let Json.447 : I64 = 44i64;
let Json.446 : U8 = CallByName Num.127 Json.447; let Json.446 : U8 = CallByName Num.127 Json.447;
let Json.443 : List U8 = CallByName List.4 Json.138 Json.446; let Json.443 : List U8 = CallByName List.4 Json.137 Json.446;
jump Json.444 Json.443; jump Json.444 Json.443;
else else
jump Json.444 Json.138; jump Json.444 Json.137;
procedure Json.18 (Json.98): procedure Json.18 (Json.97):
let Json.479 : Str = CallByName Encode.22 Json.98; let Json.479 : Str = CallByName Encode.22 Json.97;
ret Json.479; ret Json.479;
procedure Json.21 (Json.127, Json.128): procedure Json.21 (Json.126, Json.127):
let Json.427 : {Str, List Str} = Struct {Json.127, Json.128}; let Json.427 : {Str, List Str} = Struct {Json.126, Json.127};
let Json.426 : {Str, List Str} = CallByName Encode.22 Json.427; let Json.426 : {Str, List Str} = CallByName Encode.22 Json.427;
ret Json.426; ret Json.426;
procedure Json.99 (Json.100, Json.469, Json.98): procedure Json.98 (Json.99, Json.469, Json.97):
let Json.478 : I64 = 34i64; let Json.478 : I64 = 34i64;
let Json.477 : U8 = CallByName Num.127 Json.478; let Json.477 : U8 = CallByName Num.127 Json.478;
let Json.475 : List U8 = CallByName List.4 Json.100 Json.477; let Json.475 : List U8 = CallByName List.4 Json.99 Json.477;
let Json.476 : List U8 = CallByName Str.12 Json.98; let Json.476 : List U8 = CallByName Str.12 Json.97;
let Json.472 : List U8 = CallByName List.8 Json.475 Json.476; let Json.472 : List U8 = CallByName List.8 Json.475 Json.476;
let Json.474 : I64 = 34i64; let Json.474 : I64 = 34i64;
let Json.473 : U8 = CallByName Num.127 Json.474; let Json.473 : U8 = CallByName Num.127 Json.474;
@ -133,7 +133,7 @@ procedure Json.99 (Json.100, Json.469, Json.98):
ret Json.471; ret Json.471;
procedure List.139 (List.140, List.141, List.138): procedure List.139 (List.140, List.141, List.138):
let List.547 : {List U8, U64} = CallByName Json.131 List.140 List.141; let List.547 : {List U8, U64} = CallByName Json.130 List.140 List.141;
ret List.547; ret List.547;
procedure List.18 (List.136, List.137, List.138): procedure List.18 (List.136, List.137, List.138):

118
crates/compiler/test_mono/generated/issue_4749.txt
View File

@ -32,7 +32,7 @@ procedure Decode.23 (Decode.94):
ret Decode.94; ret Decode.94;
procedure Decode.24 (Decode.95, Decode.114, Decode.97): procedure Decode.24 (Decode.95, Decode.114, Decode.97):
let Decode.127 : {List U8, [C {}, C Str]} = CallByName Json.300 Decode.95 Decode.97; let Decode.127 : {List U8, [C {}, C Str]} = CallByName Json.299 Decode.95 Decode.97;
ret Decode.127; ret Decode.127;
procedure Decode.25 (Decode.98, Decode.99): procedure Decode.25 (Decode.98, Decode.99):
@ -70,60 +70,60 @@ procedure Decode.26 (Decode.100, Decode.101):
let Decode.116 : [C [C List U8, C ], C Str] = TagId(0) Decode.117; let Decode.116 : [C [C List U8, C ], C Str] = TagId(0) Decode.117;
ret Decode.116; ret Decode.116;
procedure Json.145 (Json.512, Json.513): procedure Json.144 (Json.512, Json.513):
joinpoint Json.450 Json.447 Json.144: joinpoint Json.450 Json.447 Json.143:
let Json.147 : List U8 = StructAtIndex 0 Json.447; let Json.146 : List U8 = StructAtIndex 0 Json.447;
inc Json.147;
let Json.146 : List U8 = StructAtIndex 1 Json.447;
inc Json.146; inc Json.146;
let Json.145 : List U8 = StructAtIndex 1 Json.447;
inc Json.145;
dec Json.447; dec Json.447;
joinpoint Json.490: joinpoint Json.490:
let Json.487 : {List U8, List U8} = Struct {Json.147, Json.146}; let Json.487 : {List U8, List U8} = Struct {Json.146, Json.145};
ret Json.487; ret Json.487;
in in
let Json.496 : U64 = lowlevel ListLen Json.147; let Json.496 : U64 = lowlevel ListLen Json.146;
let Json.497 : U64 = 2i64; let Json.497 : U64 = 2i64;
let Json.498 : Int1 = lowlevel NumGte Json.496 Json.497; let Json.498 : Int1 = lowlevel NumGte Json.496 Json.497;
if Json.498 then if Json.498 then
let Json.489 : U64 = 0i64; let Json.489 : U64 = 0i64;
let Json.148 : U8 = lowlevel ListGetUnsafe Json.147 Json.489; let Json.147 : U8 = lowlevel ListGetUnsafe Json.146 Json.489;
let Json.488 : U64 = 1i64; let Json.488 : U64 = 1i64;
let Json.149 : U8 = lowlevel ListGetUnsafe Json.147 Json.488; let Json.148 : U8 = lowlevel ListGetUnsafe Json.146 Json.488;
let Json.458 : Int1 = CallByName Json.22 Json.148 Json.149; let Json.458 : Int1 = CallByName Json.22 Json.147 Json.148;
if Json.458 then if Json.458 then
let Json.465 : U64 = 2i64; let Json.465 : U64 = 2i64;
let Json.462 : List U8 = CallByName List.29 Json.147 Json.465; let Json.462 : List U8 = CallByName List.29 Json.146 Json.465;
let Json.464 : List U8 = CallByName List.4 Json.146 Json.148; let Json.464 : List U8 = CallByName List.4 Json.145 Json.147;
let Json.463 : List U8 = CallByName List.4 Json.464 Json.149; let Json.463 : List U8 = CallByName List.4 Json.464 Json.148;
let Json.460 : {List U8, List U8} = Struct {Json.462, Json.463}; let Json.460 : {List U8, List U8} = Struct {Json.462, Json.463};
jump Json.450 Json.460 Json.144; jump Json.450 Json.460 Json.143;
else else
let Json.452 : Int1 = CallByName Json.290 Json.148; let Json.452 : Int1 = CallByName Json.289 Json.147;
if Json.452 then if Json.452 then
let Json.456 : List U8 = CallByName List.38 Json.147; let Json.456 : List U8 = CallByName List.38 Json.146;
let Json.457 : List U8 = CallByName List.4 Json.146 Json.148; let Json.457 : List U8 = CallByName List.4 Json.145 Json.147;
let Json.454 : {List U8, List U8} = Struct {Json.456, Json.457}; let Json.454 : {List U8, List U8} = Struct {Json.456, Json.457};
jump Json.450 Json.454 Json.144; jump Json.450 Json.454 Json.143;
else else
let Json.451 : {List U8, List U8} = Struct {Json.147, Json.146}; let Json.451 : {List U8, List U8} = Struct {Json.146, Json.145};
ret Json.451; ret Json.451;
else else
let Json.493 : U64 = lowlevel ListLen Json.147; let Json.493 : U64 = lowlevel ListLen Json.146;
let Json.494 : U64 = 1i64; let Json.494 : U64 = 1i64;
let Json.495 : Int1 = lowlevel NumGte Json.493 Json.494; let Json.495 : Int1 = lowlevel NumGte Json.493 Json.494;
if Json.495 then if Json.495 then
let Json.492 : U64 = 0i64; let Json.492 : U64 = 0i64;
let Json.150 : U8 = lowlevel ListGetUnsafe Json.147 Json.492; let Json.149 : U8 = lowlevel ListGetUnsafe Json.146 Json.492;
joinpoint Json.485 Json.491: joinpoint Json.485 Json.491:
if Json.491 then if Json.491 then
let Json.483 : List U8 = CallByName List.38 Json.147; let Json.483 : List U8 = CallByName List.38 Json.146;
let Json.484 : List U8 = CallByName List.4 Json.146 Json.150; let Json.484 : List U8 = CallByName List.4 Json.145 Json.149;
let Json.481 : {List U8, List U8} = Struct {Json.483, Json.484}; let Json.481 : {List U8, List U8} = Struct {Json.483, Json.484};
jump Json.450 Json.481 Json.144; jump Json.450 Json.481 Json.143;
else else
jump Json.490; jump Json.490;
in in
let Json.486 : Int1 = CallByName Json.290 Json.150; let Json.486 : Int1 = CallByName Json.289 Json.149;
jump Json.485 Json.486; jump Json.485 Json.486;
else else
jump Json.490; jump Json.490;
@ -134,8 +134,8 @@ procedure Json.2 ():
let Json.425 : {} = Struct {}; let Json.425 : {} = Struct {};
ret Json.425; ret Json.425;
procedure Json.22 (Json.140, Json.141): procedure Json.22 (Json.139, Json.140):
let Json.466 : {U8, U8} = Struct {Json.140, Json.141}; let Json.466 : {U8, U8} = Struct {Json.139, Json.140};
joinpoint Json.475: joinpoint Json.475:
let Json.474 : Int1 = CallByName Bool.1; let Json.474 : Int1 = CallByName Bool.1;
ret Json.474; ret Json.474;
@ -180,71 +180,71 @@ procedure Json.22 (Json.140, Json.141):
else else
jump Json.475; jump Json.475;
procedure Json.23 (Json.143, Json.144): procedure Json.23 (Json.142, Json.143):
let Json.500 : List U8 = Array []; let Json.500 : List U8 = Array [];
let Json.449 : {List U8, List U8} = Struct {Json.143, Json.500}; let Json.449 : {List U8, List U8} = Struct {Json.142, Json.500};
let Json.448 : {List U8, List U8} = CallByName Json.145 Json.449 Json.144; let Json.448 : {List U8, List U8} = CallByName Json.144 Json.449 Json.143;
ret Json.448; ret Json.448;
procedure Json.290 (Json.291): procedure Json.289 (Json.290):
let Json.502 : U8 = 34i64; let Json.502 : U8 = 34i64;
let Json.501 : Int1 = CallByName Bool.7 Json.291 Json.502; let Json.501 : Int1 = CallByName Bool.7 Json.290 Json.502;
ret Json.501; ret Json.501;
procedure Json.300 (Json.301, Json.428): procedure Json.299 (Json.300, Json.428):
let Json.429 : {List U8, [C {}, C Str]} = CallByName Json.41 Json.301; let Json.429 : {List U8, [C {}, C Str]} = CallByName Json.41 Json.300;
ret Json.429; ret Json.429;
procedure Json.41 (Json.283): procedure Json.41 (Json.282):
let Json.506 : U64 = 1i64; let Json.506 : U64 = 1i64;
inc Json.282;
let Json.505 : {List U8, List U8} = CallByName List.52 Json.282 Json.506;
let Json.283 : List U8 = StructAtIndex 0 Json.505;
inc Json.283; inc Json.283;
let Json.505 : {List U8, List U8} = CallByName List.52 Json.283 Json.506; let Json.285 : List U8 = StructAtIndex 1 Json.505;
let Json.284 : List U8 = StructAtIndex 0 Json.505; inc Json.285;
inc Json.284;
let Json.286 : List U8 = StructAtIndex 1 Json.505;
inc Json.286;
dec Json.505; dec Json.505;
let Json.504 : U8 = 34i64; let Json.504 : U8 = 34i64;
let Json.503 : List U8 = Array [Json.504]; let Json.503 : List U8 = Array [Json.504];
let Json.433 : Int1 = CallByName Bool.11 Json.284 Json.503; let Json.433 : Int1 = CallByName Bool.11 Json.283 Json.503;
dec Json.503; dec Json.503;
dec Json.284; dec Json.283;
if Json.433 then if Json.433 then
dec Json.283; dec Json.282;
let Json.446 : {} = Struct {}; let Json.446 : {} = Struct {};
let Json.445 : {List U8, List U8} = CallByName Json.23 Json.286 Json.446; let Json.445 : {List U8, List U8} = CallByName Json.23 Json.285 Json.446;
let Json.289 : List U8 = StructAtIndex 0 Json.445; let Json.288 : List U8 = StructAtIndex 0 Json.445;
inc Json.289;
let Json.288 : List U8 = StructAtIndex 1 Json.445;
inc Json.288; inc Json.288;
let Json.287 : List U8 = StructAtIndex 1 Json.445;
inc Json.287;
dec Json.445; dec Json.445;
let Json.434 : [C {U64, U8}, C Str] = CallByName Str.9 Json.288; let Json.434 : [C {U64, U8}, C Str] = CallByName Str.9 Json.287;
let Json.442 : U8 = 1i64; let Json.442 : U8 = 1i64;
let Json.443 : U8 = GetTagId Json.434; let Json.443 : U8 = GetTagId Json.434;
let Json.444 : Int1 = lowlevel Eq Json.442 Json.443; let Json.444 : Int1 = lowlevel Eq Json.442 Json.443;
if Json.444 then if Json.444 then
let Json.292 : Str = UnionAtIndex (Id 1) (Index 0) Json.434; let Json.291 : Str = UnionAtIndex (Id 1) (Index 0) Json.434;
inc Json.292; inc Json.291;
dec Json.434; dec Json.434;
let Json.438 : U64 = 1i64; let Json.438 : U64 = 1i64;
let Json.437 : {List U8, List U8} = CallByName List.52 Json.289 Json.438; let Json.437 : {List U8, List U8} = CallByName List.52 Json.288 Json.438;
let Json.294 : List U8 = StructAtIndex 1 Json.437; let Json.293 : List U8 = StructAtIndex 1 Json.437;
inc Json.294; inc Json.293;
dec Json.437; dec Json.437;
let Json.436 : [C {}, C Str] = TagId(1) Json.292; let Json.436 : [C {}, C Str] = TagId(1) Json.291;
let Json.435 : {List U8, [C {}, C Str]} = Struct {Json.294, Json.436}; let Json.435 : {List U8, [C {}, C Str]} = Struct {Json.293, Json.436};
ret Json.435; ret Json.435;
else else
dec Json.434; dec Json.434;
let Json.441 : {} = Struct {}; let Json.441 : {} = Struct {};
let Json.440 : [C {}, C Str] = TagId(0) Json.441; let Json.440 : [C {}, C Str] = TagId(0) Json.441;
let Json.439 : {List U8, [C {}, C Str]} = Struct {Json.289, Json.440}; let Json.439 : {List U8, [C {}, C Str]} = Struct {Json.288, Json.440};
ret Json.439; ret Json.439;
else else
dec Json.286; dec Json.285;
let Json.432 : {} = Struct {}; let Json.432 : {} = Struct {};
let Json.431 : [C {}, C Str] = TagId(0) Json.432; let Json.431 : [C {}, C Str] = TagId(0) Json.432;
let Json.430 : {List U8, [C {}, C Str]} = Struct {Json.283, Json.431}; let Json.430 : {List U8, [C {}, C Str]} = Struct {Json.282, Json.431};
ret Json.430; ret Json.430;
procedure Json.42 (): procedure Json.42 ():

118
crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt
View File

@ -36,7 +36,7 @@ procedure Decode.23 (Decode.94):
ret Decode.94; ret Decode.94;
procedure Decode.24 (Decode.95, Decode.114, Decode.97): procedure Decode.24 (Decode.95, Decode.114, Decode.97):
let Decode.117 : {List U8, [C {}, C Str]} = CallByName Json.300 Decode.95 Decode.97; let Decode.117 : {List U8, [C {}, C Str]} = CallByName Json.299 Decode.95 Decode.97;
ret Decode.117; ret Decode.117;
procedure Decode.25 (Decode.98, Decode.99): procedure Decode.25 (Decode.98, Decode.99):
@ -44,60 +44,60 @@ procedure Decode.25 (Decode.98, Decode.99):
let Decode.115 : {List U8, [C {}, C Str]} = CallByName Decode.24 Decode.98 Decode.116 Decode.99; let Decode.115 : {List U8, [C {}, C Str]} = CallByName Decode.24 Decode.98 Decode.116 Decode.99;
ret Decode.115; ret Decode.115;
procedure Json.145 (Json.512, Json.513): procedure Json.144 (Json.512, Json.513):
joinpoint Json.450 Json.447 Json.144: joinpoint Json.450 Json.447 Json.143:
let Json.147 : List U8 = StructAtIndex 0 Json.447; let Json.146 : List U8 = StructAtIndex 0 Json.447;
inc Json.147;
let Json.146 : List U8 = StructAtIndex 1 Json.447;
inc Json.146; inc Json.146;
let Json.145 : List U8 = StructAtIndex 1 Json.447;
inc Json.145;
dec Json.447; dec Json.447;
joinpoint Json.490: joinpoint Json.490:
let Json.487 : {List U8, List U8} = Struct {Json.147, Json.146}; let Json.487 : {List U8, List U8} = Struct {Json.146, Json.145};
ret Json.487; ret Json.487;
in in
let Json.496 : U64 = lowlevel ListLen Json.147; let Json.496 : U64 = lowlevel ListLen Json.146;
let Json.497 : U64 = 2i64; let Json.497 : U64 = 2i64;
let Json.498 : Int1 = lowlevel NumGte Json.496 Json.497; let Json.498 : Int1 = lowlevel NumGte Json.496 Json.497;
if Json.498 then if Json.498 then
let Json.489 : U64 = 0i64; let Json.489 : U64 = 0i64;
let Json.148 : U8 = lowlevel ListGetUnsafe Json.147 Json.489; let Json.147 : U8 = lowlevel ListGetUnsafe Json.146 Json.489;
let Json.488 : U64 = 1i64; let Json.488 : U64 = 1i64;
let Json.149 : U8 = lowlevel ListGetUnsafe Json.147 Json.488; let Json.148 : U8 = lowlevel ListGetUnsafe Json.146 Json.488;
let Json.458 : Int1 = CallByName Json.22 Json.148 Json.149; let Json.458 : Int1 = CallByName Json.22 Json.147 Json.148;
if Json.458 then if Json.458 then
let Json.465 : U64 = 2i64; let Json.465 : U64 = 2i64;
let Json.462 : List U8 = CallByName List.29 Json.147 Json.465; let Json.462 : List U8 = CallByName List.29 Json.146 Json.465;
let Json.464 : List U8 = CallByName List.4 Json.146 Json.148; let Json.464 : List U8 = CallByName List.4 Json.145 Json.147;
let Json.463 : List U8 = CallByName List.4 Json.464 Json.149; let Json.463 : List U8 = CallByName List.4 Json.464 Json.148;
let Json.460 : {List U8, List U8} = Struct {Json.462, Json.463}; let Json.460 : {List U8, List U8} = Struct {Json.462, Json.463};
jump Json.450 Json.460 Json.144; jump Json.450 Json.460 Json.143;
else else
let Json.452 : Int1 = CallByName Json.290 Json.148; let Json.452 : Int1 = CallByName Json.289 Json.147;
if Json.452 then if Json.452 then
let Json.456 : List U8 = CallByName List.38 Json.147; let Json.456 : List U8 = CallByName List.38 Json.146;
let Json.457 : List U8 = CallByName List.4 Json.146 Json.148; let Json.457 : List U8 = CallByName List.4 Json.145 Json.147;
let Json.454 : {List U8, List U8} = Struct {Json.456, Json.457}; let Json.454 : {List U8, List U8} = Struct {Json.456, Json.457};
jump Json.450 Json.454 Json.144; jump Json.450 Json.454 Json.143;
else else
let Json.451 : {List U8, List U8} = Struct {Json.147, Json.146}; let Json.451 : {List U8, List U8} = Struct {Json.146, Json.145};
ret Json.451; ret Json.451;
else else
let Json.493 : U64 = lowlevel ListLen Json.147; let Json.493 : U64 = lowlevel ListLen Json.146;
let Json.494 : U64 = 1i64; let Json.494 : U64 = 1i64;
let Json.495 : Int1 = lowlevel NumGte Json.493 Json.494; let Json.495 : Int1 = lowlevel NumGte Json.493 Json.494;
if Json.495 then if Json.495 then
let Json.492 : U64 = 0i64; let Json.492 : U64 = 0i64;
let Json.150 : U8 = lowlevel ListGetUnsafe Json.147 Json.492; let Json.149 : U8 = lowlevel ListGetUnsafe Json.146 Json.492;
joinpoint Json.485 Json.491: joinpoint Json.485 Json.491:
if Json.491 then if Json.491 then
let Json.483 : List U8 = CallByName List.38 Json.147; let Json.483 : List U8 = CallByName List.38 Json.146;
let Json.484 : List U8 = CallByName List.4 Json.146 Json.150; let Json.484 : List U8 = CallByName List.4 Json.145 Json.149;
let Json.481 : {List U8, List U8} = Struct {Json.483, Json.484}; let Json.481 : {List U8, List U8} = Struct {Json.483, Json.484};
jump Json.450 Json.481 Json.144; jump Json.450 Json.481 Json.143;
else else
jump Json.490; jump Json.490;
in in
let Json.486 : Int1 = CallByName Json.290 Json.150; let Json.486 : Int1 = CallByName Json.289 Json.149;
jump Json.485 Json.486; jump Json.485 Json.486;
else else
jump Json.490; jump Json.490;
@ -108,8 +108,8 @@ procedure Json.2 ():
let Json.425 : {} = Struct {}; let Json.425 : {} = Struct {};
ret Json.425; ret Json.425;
procedure Json.22 (Json.140, Json.141): procedure Json.22 (Json.139, Json.140):
let Json.466 : {U8, U8} = Struct {Json.140, Json.141}; let Json.466 : {U8, U8} = Struct {Json.139, Json.140};
joinpoint Json.475: joinpoint Json.475:
let Json.474 : Int1 = CallByName Bool.1; let Json.474 : Int1 = CallByName Bool.1;
ret Json.474; ret Json.474;
@ -154,71 +154,71 @@ procedure Json.22 (Json.140, Json.141):
else else
jump Json.475; jump Json.475;
procedure Json.23 (Json.143, Json.144): procedure Json.23 (Json.142, Json.143):
let Json.500 : List U8 = Array []; let Json.500 : List U8 = Array [];
let Json.449 : {List U8, List U8} = Struct {Json.143, Json.500}; let Json.449 : {List U8, List U8} = Struct {Json.142, Json.500};
let Json.448 : {List U8, List U8} = CallByName Json.145 Json.449 Json.144; let Json.448 : {List U8, List U8} = CallByName Json.144 Json.449 Json.143;
ret Json.448; ret Json.448;
procedure Json.290 (Json.291): procedure Json.289 (Json.290):
let Json.502 : U8 = 34i64; let Json.502 : U8 = 34i64;
let Json.501 : Int1 = CallByName Bool.7 Json.291 Json.502; let Json.501 : Int1 = CallByName Bool.7 Json.290 Json.502;
ret Json.501; ret Json.501;
procedure Json.300 (Json.301, Json.428): procedure Json.299 (Json.300, Json.428):
let Json.429 : {List U8, [C {}, C Str]} = CallByName Json.41 Json.301; let Json.429 : {List U8, [C {}, C Str]} = CallByName Json.41 Json.300;
ret Json.429; ret Json.429;
procedure Json.41 (Json.283): procedure Json.41 (Json.282):
let Json.506 : U64 = 1i64; let Json.506 : U64 = 1i64;
inc Json.282;
let Json.505 : {List U8, List U8} = CallByName List.52 Json.282 Json.506;
let Json.283 : List U8 = StructAtIndex 0 Json.505;
inc Json.283; inc Json.283;
let Json.505 : {List U8, List U8} = CallByName List.52 Json.283 Json.506; let Json.285 : List U8 = StructAtIndex 1 Json.505;
let Json.284 : List U8 = StructAtIndex 0 Json.505; inc Json.285;
inc Json.284;
let Json.286 : List U8 = StructAtIndex 1 Json.505;
inc Json.286;
dec Json.505; dec Json.505;
let Json.504 : U8 = 34i64; let Json.504 : U8 = 34i64;
let Json.503 : List U8 = Array [Json.504]; let Json.503 : List U8 = Array [Json.504];
let Json.433 : Int1 = CallByName Bool.11 Json.284 Json.503; let Json.433 : Int1 = CallByName Bool.11 Json.283 Json.503;
dec Json.503; dec Json.503;
dec Json.284; dec Json.283;
if Json.433 then if Json.433 then
dec Json.283; dec Json.282;
let Json.446 : {} = Struct {}; let Json.446 : {} = Struct {};
let Json.445 : {List U8, List U8} = CallByName Json.23 Json.286 Json.446; let Json.445 : {List U8, List U8} = CallByName Json.23 Json.285 Json.446;
let Json.289 : List U8 = StructAtIndex 0 Json.445; let Json.288 : List U8 = StructAtIndex 0 Json.445;
inc Json.289;
let Json.288 : List U8 = StructAtIndex 1 Json.445;
inc Json.288; inc Json.288;
let Json.287 : List U8 = StructAtIndex 1 Json.445;
inc Json.287;
dec Json.445; dec Json.445;
let Json.434 : [C {U64, U8}, C Str] = CallByName Str.9 Json.288; let Json.434 : [C {U64, U8}, C Str] = CallByName Str.9 Json.287;
let Json.442 : U8 = 1i64; let Json.442 : U8 = 1i64;
let Json.443 : U8 = GetTagId Json.434; let Json.443 : U8 = GetTagId Json.434;
let Json.444 : Int1 = lowlevel Eq Json.442 Json.443; let Json.444 : Int1 = lowlevel Eq Json.442 Json.443;
if Json.444 then if Json.444 then
let Json.292 : Str = UnionAtIndex (Id 1) (Index 0) Json.434; let Json.291 : Str = UnionAtIndex (Id 1) (Index 0) Json.434;
inc Json.292; inc Json.291;
dec Json.434; dec Json.434;
let Json.438 : U64 = 1i64; let Json.438 : U64 = 1i64;
let Json.437 : {List U8, List U8} = CallByName List.52 Json.289 Json.438; let Json.437 : {List U8, List U8} = CallByName List.52 Json.288 Json.438;
let Json.294 : List U8 = StructAtIndex 1 Json.437; let Json.293 : List U8 = StructAtIndex 1 Json.437;
inc Json.294; inc Json.293;
dec Json.437; dec Json.437;
let Json.436 : [C {}, C Str] = TagId(1) Json.292; let Json.436 : [C {}, C Str] = TagId(1) Json.291;
let Json.435 : {List U8, [C {}, C Str]} = Struct {Json.294, Json.436}; let Json.435 : {List U8, [C {}, C Str]} = Struct {Json.293, Json.436};
ret Json.435; ret Json.435;
else else
dec Json.434; dec Json.434;
let Json.441 : {} = Struct {}; let Json.441 : {} = Struct {};
let Json.440 : [C {}, C Str] = TagId(0) Json.441; let Json.440 : [C {}, C Str] = TagId(0) Json.441;
let Json.439 : {List U8, [C {}, C Str]} = Struct {Json.289, Json.440}; let Json.439 : {List U8, [C {}, C Str]} = Struct {Json.288, Json.440};
ret Json.439; ret Json.439;
else else
dec Json.286; dec Json.285;
let Json.432 : {} = Struct {}; let Json.432 : {} = Struct {};
let Json.431 : [C {}, C Str] = TagId(0) Json.432; let Json.431 : [C {}, C Str] = TagId(0) Json.432;
let Json.430 : {List U8, [C {}, C Str]} = Struct {Json.283, Json.431}; let Json.430 : {List U8, [C {}, C Str]} = Struct {Json.282, Json.431};
ret Json.430; ret Json.430;
procedure Json.42 (): procedure Json.42 ():

70
crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt
View File

@ -16,11 +16,11 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106; ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.129 Encode.94 Encode.96 Encode.102; let Encode.113 : List U8 = CallByName Json.128 Encode.94 Encode.96 Encode.102;
ret Encode.113; ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.118 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102; let Encode.118 : List U8 = CallByName Json.98 Encode.94 Encode.96 Encode.102;
ret Encode.118; ret Encode.118;
procedure Encode.25 (Encode.100, Encode.101): procedure Encode.25 (Encode.100, Encode.101):
@ -33,19 +33,19 @@ procedure Json.1 ():
let Json.425 : {} = Struct {}; let Json.425 : {} = Struct {};
ret Json.425; ret Json.425;
procedure Json.129 (Json.130, Json.428, #Attr.12): procedure Json.128 (Json.129, Json.428, #Attr.12):
let Json.128 : List Str = StructAtIndex 1 #Attr.12; let Json.127 : List Str = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
inc Json.127; inc Json.127;
let Json.126 : Str = StructAtIndex 0 #Attr.12;
inc Json.126;
dec #Attr.12; dec #Attr.12;
let Json.466 : I64 = 123i64; let Json.466 : I64 = 123i64;
let Json.465 : U8 = CallByName Num.127 Json.466; let Json.465 : U8 = CallByName Num.127 Json.466;
let Json.462 : List U8 = CallByName List.4 Json.130 Json.465; let Json.462 : List U8 = CallByName List.4 Json.129 Json.465;
let Json.464 : I64 = 34i64; let Json.464 : I64 = 34i64;
let Json.463 : U8 = CallByName Num.127 Json.464; let Json.463 : U8 = CallByName Num.127 Json.464;
let Json.460 : List U8 = CallByName List.4 Json.462 Json.463; let Json.460 : List U8 = CallByName List.4 Json.462 Json.463;
let Json.461 : List U8 = CallByName Str.12 Json.127; let Json.461 : List U8 = CallByName Str.12 Json.126;
let Json.457 : List U8 = CallByName List.8 Json.460 Json.461; let Json.457 : List U8 = CallByName List.8 Json.460 Json.461;
let Json.459 : I64 = 34i64; let Json.459 : I64 = 34i64;
let Json.458 : U8 = CallByName Num.127 Json.459; let Json.458 : U8 = CallByName Num.127 Json.459;
@ -55,60 +55,60 @@ procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.451 : List U8 = CallByName List.4 Json.454 Json.455; let Json.451 : List U8 = CallByName List.4 Json.454 Json.455;
let Json.453 : I64 = 91i64; let Json.453 : I64 = 91i64;
let Json.452 : U8 = CallByName Num.127 Json.453; let Json.452 : U8 = CallByName Num.127 Json.453;
let Json.132 : List U8 = CallByName List.4 Json.451 Json.452; let Json.131 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.128; let Json.450 : U64 = CallByName List.6 Json.127;
let Json.438 : {List U8, U64} = Struct {Json.132, Json.450}; let Json.438 : {List U8, U64} = Struct {Json.131, Json.450};
let Json.439 : {} = Struct {}; let Json.439 : {} = Struct {};
let Json.437 : {List U8, U64} = CallByName List.18 Json.128 Json.438 Json.439; let Json.437 : {List U8, U64} = CallByName List.18 Json.127 Json.438 Json.439;
dec Json.128; dec Json.127;
let Json.134 : List U8 = StructAtIndex 0 Json.437; let Json.133 : List U8 = StructAtIndex 0 Json.437;
inc Json.134; inc Json.133;
dec Json.437; dec Json.437;
let Json.436 : I64 = 93i64; let Json.436 : I64 = 93i64;
let Json.435 : U8 = CallByName Num.127 Json.436; let Json.435 : U8 = CallByName Num.127 Json.436;
let Json.432 : List U8 = CallByName List.4 Json.134 Json.435; let Json.432 : List U8 = CallByName List.4 Json.133 Json.435;
let Json.434 : I64 = 125i64; let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434; let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.431 : List U8 = CallByName List.4 Json.432 Json.433; let Json.431 : List U8 = CallByName List.4 Json.432 Json.433;
ret Json.431; ret Json.431;
procedure Json.131 (Json.430, Json.137): procedure Json.130 (Json.430, Json.136):
let Json.135 : List U8 = StructAtIndex 0 Json.430; let Json.134 : List U8 = StructAtIndex 0 Json.430;
inc Json.135; inc Json.134;
let Json.136 : U64 = StructAtIndex 1 Json.430; let Json.135 : U64 = StructAtIndex 1 Json.430;
dec Json.430; dec Json.430;
let Json.449 : {} = Struct {}; let Json.449 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.449; let Json.137 : List U8 = CallByName Encode.23 Json.134 Json.136 Json.449;
joinpoint Json.444 Json.139: joinpoint Json.444 Json.138:
let Json.442 : U64 = 1i64; let Json.442 : U64 = 1i64;
let Json.441 : U64 = CallByName Num.20 Json.136 Json.442; let Json.441 : U64 = CallByName Num.20 Json.135 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.139, Json.441}; let Json.440 : {List U8, U64} = Struct {Json.138, Json.441};
ret Json.440; ret Json.440;
in in
let Json.448 : U64 = 1i64; let Json.448 : U64 = 1i64;
let Json.445 : Int1 = CallByName Num.24 Json.136 Json.448; let Json.445 : Int1 = CallByName Num.24 Json.135 Json.448;
if Json.445 then if Json.445 then
let Json.447 : I64 = 44i64; let Json.447 : I64 = 44i64;
let Json.446 : U8 = CallByName Num.127 Json.447; let Json.446 : U8 = CallByName Num.127 Json.447;
let Json.443 : List U8 = CallByName List.4 Json.138 Json.446; let Json.443 : List U8 = CallByName List.4 Json.137 Json.446;
jump Json.444 Json.443; jump Json.444 Json.443;
else else
jump Json.444 Json.138; jump Json.444 Json.137;
procedure Json.18 (Json.98): procedure Json.18 (Json.97):
let Json.482 : Str = CallByName Encode.22 Json.98; let Json.482 : Str = CallByName Encode.22 Json.97;
ret Json.482; ret Json.482;
procedure Json.21 (Json.127, Json.128): procedure Json.21 (Json.126, Json.127):
let Json.468 : {Str, List Str} = Struct {Json.127, Json.128}; let Json.468 : {Str, List Str} = Struct {Json.126, Json.127};
let Json.467 : {Str, List Str} = CallByName Encode.22 Json.468; let Json.467 : {Str, List Str} = CallByName Encode.22 Json.468;
ret Json.467; ret Json.467;
procedure Json.99 (Json.100, Json.472, Json.98): procedure Json.98 (Json.99, Json.472, Json.97):
let Json.481 : I64 = 34i64; let Json.481 : I64 = 34i64;
let Json.480 : U8 = CallByName Num.127 Json.481; let Json.480 : U8 = CallByName Num.127 Json.481;
let Json.478 : List U8 = CallByName List.4 Json.100 Json.480; let Json.478 : List U8 = CallByName List.4 Json.99 Json.480;
let Json.479 : List U8 = CallByName Str.12 Json.98; let Json.479 : List U8 = CallByName Str.12 Json.97;
let Json.475 : List U8 = CallByName List.8 Json.478 Json.479; let Json.475 : List U8 = CallByName List.8 Json.478 Json.479;
let Json.477 : I64 = 34i64; let Json.477 : I64 = 34i64;
let Json.476 : U8 = CallByName Num.127 Json.477; let Json.476 : U8 = CallByName Num.127 Json.477;
@ -116,7 +116,7 @@ procedure Json.99 (Json.100, Json.472, Json.98):
ret Json.474; ret Json.474;
procedure List.139 (List.140, List.141, List.138): procedure List.139 (List.140, List.141, List.138):
let List.545 : {List U8, U64} = CallByName Json.131 List.140 List.141; let List.545 : {List U8, U64} = CallByName Json.130 List.140 List.141;
ret List.545; ret List.545;
procedure List.18 (List.136, List.137, List.138): procedure List.18 (List.136, List.137, List.138):

118
crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt
View File

@ -51,7 +51,7 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106; ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.129 Encode.94 Encode.96 Encode.102; let Encode.113 : List U8 = CallByName Json.128 Encode.94 Encode.96 Encode.102;
ret Encode.113; ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
@ -67,7 +67,7 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.129 : List U8 = CallByName Json.129 Encode.94 Encode.96 Encode.102; let Encode.129 : List U8 = CallByName Json.128 Encode.94 Encode.96 Encode.102;
ret Encode.129; ret Encode.129;
procedure Encode.23 (Encode.94, Encode.102, Encode.96): procedure Encode.23 (Encode.94, Encode.102, Encode.96):
@ -84,19 +84,19 @@ procedure Json.1 ():
let Json.425 : {} = Struct {}; let Json.425 : {} = Struct {};
ret Json.425; ret Json.425;
procedure Json.129 (Json.130, Json.428, #Attr.12): procedure Json.128 (Json.129, Json.428, #Attr.12):
let Json.128 : List [C {}, C {}] = StructAtIndex 1 #Attr.12; let Json.127 : List [C {}, C {}] = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
inc Json.127; inc Json.127;
let Json.126 : Str = StructAtIndex 0 #Attr.12;
inc Json.126;
dec #Attr.12; dec #Attr.12;
let Json.466 : I64 = 123i64; let Json.466 : I64 = 123i64;
let Json.465 : U8 = CallByName Num.127 Json.466; let Json.465 : U8 = CallByName Num.127 Json.466;
let Json.462 : List U8 = CallByName List.4 Json.130 Json.465; let Json.462 : List U8 = CallByName List.4 Json.129 Json.465;
let Json.464 : I64 = 34i64; let Json.464 : I64 = 34i64;
let Json.463 : U8 = CallByName Num.127 Json.464; let Json.463 : U8 = CallByName Num.127 Json.464;
let Json.460 : List U8 = CallByName List.4 Json.462 Json.463; let Json.460 : List U8 = CallByName List.4 Json.462 Json.463;
let Json.461 : List U8 = CallByName Str.12 Json.127; let Json.461 : List U8 = CallByName Str.12 Json.126;
let Json.457 : List U8 = CallByName List.8 Json.460 Json.461; let Json.457 : List U8 = CallByName List.8 Json.460 Json.461;
let Json.459 : I64 = 34i64; let Json.459 : I64 = 34i64;
let Json.458 : U8 = CallByName Num.127 Json.459; let Json.458 : U8 = CallByName Num.127 Json.459;
@ -106,36 +106,36 @@ procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.451 : List U8 = CallByName List.4 Json.454 Json.455; let Json.451 : List U8 = CallByName List.4 Json.454 Json.455;
let Json.453 : I64 = 91i64; let Json.453 : I64 = 91i64;
let Json.452 : U8 = CallByName Num.127 Json.453; let Json.452 : U8 = CallByName Num.127 Json.453;
let Json.132 : List U8 = CallByName List.4 Json.451 Json.452; let Json.131 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.128; let Json.450 : U64 = CallByName List.6 Json.127;
let Json.438 : {List U8, U64} = Struct {Json.132, Json.450}; let Json.438 : {List U8, U64} = Struct {Json.131, Json.450};
let Json.439 : {} = Struct {}; let Json.439 : {} = Struct {};
let Json.437 : {List U8, U64} = CallByName List.18 Json.128 Json.438 Json.439; let Json.437 : {List U8, U64} = CallByName List.18 Json.127 Json.438 Json.439;
dec Json.128; dec Json.127;
let Json.134 : List U8 = StructAtIndex 0 Json.437; let Json.133 : List U8 = StructAtIndex 0 Json.437;
inc Json.134; inc Json.133;
dec Json.437; dec Json.437;
let Json.436 : I64 = 93i64; let Json.436 : I64 = 93i64;
let Json.435 : U8 = CallByName Num.127 Json.436; let Json.435 : U8 = CallByName Num.127 Json.436;
let Json.432 : List U8 = CallByName List.4 Json.134 Json.435; let Json.432 : List U8 = CallByName List.4 Json.133 Json.435;
let Json.434 : I64 = 125i64; let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434; let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.431 : List U8 = CallByName List.4 Json.432 Json.433; let Json.431 : List U8 = CallByName List.4 Json.432 Json.433;
ret Json.431; ret Json.431;
procedure Json.129 (Json.130, Json.428, #Attr.12): procedure Json.128 (Json.129, Json.428, #Attr.12):
let Json.128 : List [] = StructAtIndex 1 #Attr.12; let Json.127 : List [] = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
inc Json.127; inc Json.127;
let Json.126 : Str = StructAtIndex 0 #Attr.12;
inc Json.126;
dec #Attr.12; dec #Attr.12;
let Json.516 : I64 = 123i64; let Json.516 : I64 = 123i64;
let Json.515 : U8 = CallByName Num.127 Json.516; let Json.515 : U8 = CallByName Num.127 Json.516;
let Json.512 : List U8 = CallByName List.4 Json.130 Json.515; let Json.512 : List U8 = CallByName List.4 Json.129 Json.515;
let Json.514 : I64 = 34i64; let Json.514 : I64 = 34i64;
let Json.513 : U8 = CallByName Num.127 Json.514; let Json.513 : U8 = CallByName Num.127 Json.514;
let Json.510 : List U8 = CallByName List.4 Json.512 Json.513; let Json.510 : List U8 = CallByName List.4 Json.512 Json.513;
let Json.511 : List U8 = CallByName Str.12 Json.127; let Json.511 : List U8 = CallByName Str.12 Json.126;
let Json.507 : List U8 = CallByName List.8 Json.510 Json.511; let Json.507 : List U8 = CallByName List.8 Json.510 Json.511;
let Json.509 : I64 = 34i64; let Json.509 : I64 = 34i64;
let Json.508 : U8 = CallByName Num.127 Json.509; let Json.508 : U8 = CallByName Num.127 Json.509;
@ -145,86 +145,86 @@ procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.501 : List U8 = CallByName List.4 Json.504 Json.505; let Json.501 : List U8 = CallByName List.4 Json.504 Json.505;
let Json.503 : I64 = 91i64; let Json.503 : I64 = 91i64;
let Json.502 : U8 = CallByName Num.127 Json.503; let Json.502 : U8 = CallByName Num.127 Json.503;
let Json.132 : List U8 = CallByName List.4 Json.501 Json.502; let Json.131 : List U8 = CallByName List.4 Json.501 Json.502;
let Json.500 : U64 = CallByName List.6 Json.128; let Json.500 : U64 = CallByName List.6 Json.127;
let Json.488 : {List U8, U64} = Struct {Json.132, Json.500}; let Json.488 : {List U8, U64} = Struct {Json.131, Json.500};
let Json.489 : {} = Struct {}; let Json.489 : {} = Struct {};
let Json.487 : {List U8, U64} = CallByName List.18 Json.128 Json.488 Json.489; let Json.487 : {List U8, U64} = CallByName List.18 Json.127 Json.488 Json.489;
dec Json.128; dec Json.127;
let Json.134 : List U8 = StructAtIndex 0 Json.487; let Json.133 : List U8 = StructAtIndex 0 Json.487;
inc Json.134; inc Json.133;
dec Json.487; dec Json.487;
let Json.486 : I64 = 93i64; let Json.486 : I64 = 93i64;
let Json.485 : U8 = CallByName Num.127 Json.486; let Json.485 : U8 = CallByName Num.127 Json.486;
let Json.482 : List U8 = CallByName List.4 Json.134 Json.485; let Json.482 : List U8 = CallByName List.4 Json.133 Json.485;
let Json.484 : I64 = 125i64; let Json.484 : I64 = 125i64;
let Json.483 : U8 = CallByName Num.127 Json.484; let Json.483 : U8 = CallByName Num.127 Json.484;
let Json.481 : List U8 = CallByName List.4 Json.482 Json.483; let Json.481 : List U8 = CallByName List.4 Json.482 Json.483;
ret Json.481; ret Json.481;
procedure Json.131 (Json.430, Json.137): procedure Json.130 (Json.430, Json.136):
let Json.135 : List U8 = StructAtIndex 0 Json.430; let Json.134 : List U8 = StructAtIndex 0 Json.430;
inc Json.135; inc Json.134;
let Json.136 : U64 = StructAtIndex 1 Json.430; let Json.135 : U64 = StructAtIndex 1 Json.430;
dec Json.430; dec Json.430;
let Json.449 : {} = Struct {}; let Json.449 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.449; let Json.137 : List U8 = CallByName Encode.23 Json.134 Json.136 Json.449;
joinpoint Json.444 Json.139: joinpoint Json.444 Json.138:
let Json.442 : U64 = 1i64; let Json.442 : U64 = 1i64;
let Json.441 : U64 = CallByName Num.20 Json.136 Json.442; let Json.441 : U64 = CallByName Num.20 Json.135 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.139, Json.441}; let Json.440 : {List U8, U64} = Struct {Json.138, Json.441};
ret Json.440; ret Json.440;
in in
let Json.448 : U64 = 1i64; let Json.448 : U64 = 1i64;
let Json.445 : Int1 = CallByName Num.24 Json.136 Json.448; let Json.445 : Int1 = CallByName Num.24 Json.135 Json.448;
if Json.445 then if Json.445 then
let Json.447 : I64 = 44i64; let Json.447 : I64 = 44i64;
let Json.446 : U8 = CallByName Num.127 Json.447; let Json.446 : U8 = CallByName Num.127 Json.447;
let Json.443 : List U8 = CallByName List.4 Json.138 Json.446; let Json.443 : List U8 = CallByName List.4 Json.137 Json.446;
jump Json.444 Json.443; jump Json.444 Json.443;
else else
jump Json.444 Json.138; jump Json.444 Json.137;
procedure Json.131 (Json.430, Json.137): procedure Json.130 (Json.430, Json.136):
let Json.135 : List U8 = StructAtIndex 0 Json.430; let Json.134 : List U8 = StructAtIndex 0 Json.430;
inc Json.135; inc Json.134;
let Json.136 : U64 = StructAtIndex 1 Json.430; let Json.135 : U64 = StructAtIndex 1 Json.430;
dec Json.430; dec Json.430;
let Json.499 : {} = Struct {}; let Json.499 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.499; let Json.137 : List U8 = CallByName Encode.23 Json.134 Json.136 Json.499;
dec Json.135; dec Json.134;
joinpoint Json.494 Json.139: joinpoint Json.494 Json.138:
let Json.492 : U64 = 1i64; let Json.492 : U64 = 1i64;
let Json.491 : U64 = CallByName Num.20 Json.136 Json.492; let Json.491 : U64 = CallByName Num.20 Json.135 Json.492;
let Json.490 : {List U8, U64} = Struct {Json.139, Json.491}; let Json.490 : {List U8, U64} = Struct {Json.138, Json.491};
ret Json.490; ret Json.490;
in in
let Json.498 : U64 = 1i64; let Json.498 : U64 = 1i64;
let Json.495 : Int1 = CallByName Num.24 Json.136 Json.498; let Json.495 : Int1 = CallByName Num.24 Json.135 Json.498;
if Json.495 then if Json.495 then
let Json.497 : I64 = 44i64; let Json.497 : I64 = 44i64;
let Json.496 : U8 = CallByName Num.127 Json.497; let Json.496 : U8 = CallByName Num.127 Json.497;
let Json.493 : List U8 = CallByName List.4 Json.138 Json.496; let Json.493 : List U8 = CallByName List.4 Json.137 Json.496;
jump Json.494 Json.493; jump Json.494 Json.493;
else else
jump Json.494 Json.138; jump Json.494 Json.137;
procedure Json.21 (Json.127, Json.128): procedure Json.21 (Json.126, Json.127):
let Json.468 : {Str, List [C {}, C {}]} = Struct {Json.127, Json.128}; let Json.468 : {Str, List [C {}, C {}]} = Struct {Json.126, Json.127};
let Json.467 : {Str, List [C {}, C {}]} = CallByName Encode.22 Json.468; let Json.467 : {Str, List [C {}, C {}]} = CallByName Encode.22 Json.468;
ret Json.467; ret Json.467;
procedure Json.21 (Json.127, Json.128): procedure Json.21 (Json.126, Json.127):
let Json.518 : {Str, List []} = Struct {Json.127, Json.128}; let Json.518 : {Str, List []} = Struct {Json.126, Json.127};
let Json.517 : {Str, List []} = CallByName Encode.22 Json.518; let Json.517 : {Str, List []} = CallByName Encode.22 Json.518;
ret Json.517; ret Json.517;
procedure List.139 (List.140, List.141, List.138): procedure List.139 (List.140, List.141, List.138):
let List.539 : {List U8, U64} = CallByName Json.131 List.140 List.141; let List.539 : {List U8, U64} = CallByName Json.130 List.140 List.141;
ret List.539; ret List.539;
procedure List.139 (List.140, List.141, List.138): procedure List.139 (List.140, List.141, List.138):
let List.612 : {List U8, U64} = CallByName Json.131 List.140 List.141; let List.612 : {List U8, U64} = CallByName Json.130 List.140 List.141;
ret List.612; ret List.612;
procedure List.18 (List.136, List.137, List.138): procedure List.18 (List.136, List.137, List.138):

4
crates/docs/src/static/styles.css
View File

@ -182,6 +182,10 @@ section > *:last-child {
margin-bottom: 0; margin-bottom: 0;
} }
section h1,
section h2,
section h3,
section h4,
section p { section p {
padding: 0px 16px; padding: 0px 16px;
} }