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.
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 }]
boolIsEq = \@Bool b1, @Bool b2 -> structuralEq b1 b2
@ -57,7 +59,9 @@ 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.
## In these languages the compiler will skip evaluating the expression after the
## 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.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.
## Refer to the note in `Bool.and` for more detail.
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
## associate keys with values.
##
## ### Inserting
## ## Inserting
##
## The most basic way to use a dictionary is to start with an empty one and
## then:
@ -54,7 +54,7 @@ interface Dict
## |> Dict.insert "Delhi" 16_787_941
## |> 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
## 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
## on the dictionary, but [Dict.remove] operations can change this order.
##
## ### Removing
## ## Removing
##
## 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
exposes [
Json,
@ -7,6 +44,7 @@ interface Json
imports [
List,
Str,
Result.{ Result },
Encode,
Encode.{
Encoder,
@ -37,6 +75,8 @@ interface Json
Result,
]
## An opaque type with the `EncoderFormatting` and
## `DecoderFormatting` abilities.
Json := {} has [
EncoderFormatting {
u8: encodeU8,
@ -79,8 +119,10 @@ Json := {} has [
},
]
## Returns a JSON `Decoder`
toUtf8 = @Json {}
## Returns a JSON `Encoder`
fromUtf8 = @Json {}
numToBytes = \n ->
@ -398,12 +440,20 @@ decodeList = \decodeElem -> Decode.custom \bytes, @Json {} ->
when bytes is
['[', ']'] -> { result: Ok [], rest: List.drop bytes 2 }
['[', ..] ->
when decodeElems (eatWhitespace (List.dropFirst bytes)) [] 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 }
bytesWithoutWhitespace = eatWhitespace (List.dropFirst bytes)
when bytesWithoutWhitespace is
[']', ..] ->
{ result: Ok [], rest: List.dropFirst bytesWithoutWhitespace }
_ ->
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 }
@ -491,6 +541,7 @@ expect
input = Str.toUtf8 " \n\r\tabc"
actual = eatWhitespace input
expected = Str.toUtf8 "abc"
actual == expected
# Test json string decoding with escapes
@ -498,6 +549,7 @@ expect
input = Str.toUtf8 "\"a\r\nbc\\\"xz\""
expected = Ok "a\r\nbc\\\"xz"
actual = Decode.fromBytes input fromUtf8
actual == expected
# Test json string encoding with escapes
@ -505,53 +557,31 @@ expect
input = "a\r\nbc\\\"xz"
expected = Str.toUtf8 "\"a\r\nbc\\\"xz\""
actual = Encode.toBytes input toUtf8
actual == expected
# Test json array decode empty list
expect
input = Str.toUtf8 "[ ]"
expected = []
actual : List U8
actual = Decode.fromBytes input fromUtf8 |> Result.withDefault []
actual : Result (List U8) _
actual = Decode.fromBytes input fromUtf8
expected = Ok []
actual == expected
# Test json array decoding into integers
expect
input = Str.toUtf8 "[ 1,\n2,\t3]"
expected = [1, 2, 3]
actual : List U8
actual = Decode.fromBytes input fromUtf8 |> Result.withDefault []
actual : Result (List U8) _
actual = Decode.fromBytes input fromUtf8
expected = Ok [1, 2, 3]
actual == expected
# Test json array decoding into strings ignoring whitespace around values
expect
input = Str.toUtf8 "[\r\"one\" ,\t\"two\"\n,\n\"3\"\t]"
expected = ["one", "two", "3"]
actual : List Str
actual =
Decode.fromBytes input fromUtf8
|> Result.onErr handleJsonDecodeError
|> Result.withDefault []
actual = Decode.fromBytes input fromUtf8
expected = Ok ["one", "two", "3"]
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
## ```
## 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,
## 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

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

@ -239,7 +239,7 @@ Num range := range
##
## 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.
## 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
## possibility is noted in the function's documentation.
##
## ## Performance Notes
## ## Performance Details
##
## On typical modern CPUs, performance is similar between [Dec], [F64], and [F32]
## 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
## 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
## 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
## ```
## ## Performance Notes
## ## Performance Details
##
## Be careful! It is very easy for this function to produce an answer
## so large it causes an overflow.

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

@ -39,16 +39,15 @@ withDefault = \result, default ->
Err _ -> default
## 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.
##
## (If the result is `Err`, this has no effect. Use [mapErr] to transform an `Err`.)
## 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`.
## ```
## Result.map (Ok 12) Num.negate
## Result.map (Err "yipes!") Num.negate
## ```
##
## `map` functions like this are common in Roc, and they all work similarly.
## See for example [List.map], `Set.map`, and `Dict.map`.
## Functions like `map` are common in Roc; see for example [List.map],
## `Set.map`, and `Dict.map`.
map : Result a err, (a -> b) -> Result b err
map = \result, transform ->
when result is
@ -56,9 +55,8 @@ map = \result, transform ->
Err e -> Err e
## 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.
##
## (If the result is `Ok`, this has no effect. Use [map] to transform an `Ok`.)
## 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`.
## ```
## Result.mapErr (Err "yipes!") Str.isEmpty
## Result.mapErr (Ok 12) Str.isEmpty
@ -70,9 +68,8 @@ mapErr = \result, transform ->
Err e -> Err (transform e)
## 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.
##
## (If the result is `Err`, this has no effect. Use `onErr` to transform an `Err`.)
## 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`.
## ```
## 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
@ -84,9 +81,8 @@ try = \result, transform ->
Err e -> Err e
## 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.
##
## (If the result is `Ok`, this has no effect. Use `try` to transform an `Ok`.)
## 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`.
## ```
## Result.onErr (Ok 10) \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,
single,
walk,
walkUntil,
insert,
len,
remove,
@ -25,6 +26,8 @@ interface Set
# We should have this line above the next has.
# It causes the formatter to fail currently.
# | 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 {}
has [
Eq {
@ -43,14 +46,39 @@ isEq = \xs, ys ->
else
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 (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 = \key ->
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 dict, key ->
Dict.insert dict key {} |> @Set
@ -72,6 +100,18 @@ expect
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 dict ->
Dict.len dict
@ -88,41 +128,151 @@ expect
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 dict, key ->
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 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 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 ->
initial = @Set (Dict.withCapacity (List.len list))
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 dict1, @Set dict2 ->
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 dict1, @Set dict2 ->
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 dict1, @Set dict2 ->
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 dict, state, step ->
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 dict, state, step ->
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.
## 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 },
]
## Test
Utf8ByteProblem : [
InvalidStartByte,
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 "" 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
## in a single code point, you can use (for example) `Str.startsWithScalar '鹏'`
## 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;
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;
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;
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;
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;
procedure Encode.25 (Encode.100, Encode.101):
@ -69,54 +69,54 @@ procedure Json.1 ():
let Json.425 : {} = Struct {};
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.460 : U8 = CallByName Num.127 Json.461;
let Json.118 : List U8 = CallByName List.4 Json.116 Json.460;
let Json.459 : U64 = CallByName List.6 Json.114;
let Json.436 : {List U8, U64} = Struct {Json.118, Json.459};
let Json.117 : List U8 = CallByName List.4 Json.115 Json.460;
let Json.459 : U64 = CallByName List.6 Json.113;
let Json.436 : {List U8, U64} = Struct {Json.117, Json.459};
let Json.437 : {} = Struct {};
let Json.435 : {List U8, U64} = CallByName List.18 Json.114 Json.436 Json.437;
dec Json.114;
let Json.120 : List U8 = StructAtIndex 0 Json.435;
inc Json.120;
let Json.435 : {List U8, U64} = CallByName List.18 Json.113 Json.436 Json.437;
dec Json.113;
let Json.119 : List U8 = StructAtIndex 0 Json.435;
inc Json.119;
dec Json.435;
let Json.434 : I64 = 125i64;
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;
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.500 : U8 = CallByName Num.127 Json.501;
let Json.118 : List U8 = CallByName List.4 Json.116 Json.500;
let Json.499 : U64 = CallByName List.6 Json.114;
let Json.476 : {List U8, U64} = Struct {Json.118, Json.499};
let Json.117 : List U8 = CallByName List.4 Json.115 Json.500;
let Json.499 : U64 = CallByName List.6 Json.113;
let Json.476 : {List U8, U64} = Struct {Json.117, Json.499};
let Json.477 : {} = Struct {};
let Json.475 : {List U8, U64} = CallByName List.18 Json.114 Json.476 Json.477;
dec Json.114;
let Json.120 : List U8 = StructAtIndex 0 Json.475;
inc Json.120;
let Json.475 : {List U8, U64} = CallByName List.18 Json.113 Json.476 Json.477;
dec Json.113;
let Json.119 : List U8 = StructAtIndex 0 Json.475;
inc Json.119;
dec Json.475;
let Json.474 : I64 = 125i64;
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;
procedure Json.117 (Json.430, Json.431):
let Json.123 : Str = StructAtIndex 0 Json.431;
procedure Json.116 (Json.430, Json.431):
let Json.122 : Str = StructAtIndex 0 Json.431;
inc Json.122;
let Json.123 : Str = StructAtIndex 1 Json.431;
inc Json.123;
let Json.124 : Str = StructAtIndex 1 Json.431;
inc Json.124;
dec Json.431;
let Json.121 : List U8 = StructAtIndex 0 Json.430;
inc Json.121;
let Json.122 : U64 = StructAtIndex 1 Json.430;
let Json.120 : List U8 = StructAtIndex 0 Json.430;
inc Json.120;
let Json.121 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.458 : I64 = 34i64;
let Json.457 : U8 = CallByName Num.127 Json.458;
let Json.455 : List U8 = CallByName List.4 Json.121 Json.457;
let Json.456 : List U8 = CallByName Str.12 Json.123;
let Json.455 : List U8 = CallByName List.4 Json.120 Json.457;
let Json.456 : List U8 = CallByName Str.12 Json.122;
let Json.452 : List U8 = CallByName List.8 Json.455 Json.456;
let Json.454 : I64 = 34i64;
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.447 : List U8 = CallByName List.4 Json.449 Json.450;
let Json.448 : {} = Struct {};
let Json.125 : List U8 = CallByName Encode.23 Json.447 Json.124 Json.448;
joinpoint Json.442 Json.126:
let Json.124 : List U8 = CallByName Encode.23 Json.447 Json.123 Json.448;
joinpoint Json.442 Json.125:
let Json.440 : U64 = 1i64;
let Json.439 : U64 = CallByName Num.20 Json.122 Json.440;
let Json.438 : {List U8, U64} = Struct {Json.126, Json.439};
let Json.439 : U64 = CallByName Num.20 Json.121 Json.440;
let Json.438 : {List U8, U64} = Struct {Json.125, Json.439};
ret Json.438;
in
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
let Json.445 : I64 = 44i64;
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;
else
jump Json.442 Json.125;
jump Json.442 Json.124;
procedure Json.117 (Json.430, Json.431):
let Json.123 : Str = StructAtIndex 0 Json.431;
procedure Json.116 (Json.430, Json.431):
let Json.122 : Str = StructAtIndex 0 Json.431;
inc Json.122;
let Json.123 : Str = StructAtIndex 1 Json.431;
inc Json.123;
let Json.124 : Str = StructAtIndex 1 Json.431;
inc Json.124;
dec Json.431;
let Json.121 : List U8 = StructAtIndex 0 Json.430;
inc Json.121;
let Json.122 : U64 = StructAtIndex 1 Json.430;
let Json.120 : List U8 = StructAtIndex 0 Json.430;
inc Json.120;
let Json.121 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.498 : I64 = 34i64;
let Json.497 : U8 = CallByName Num.127 Json.498;
let Json.495 : List U8 = CallByName List.4 Json.121 Json.497;
let Json.496 : List U8 = CallByName Str.12 Json.123;
let Json.495 : List U8 = CallByName List.4 Json.120 Json.497;
let Json.496 : List U8 = CallByName Str.12 Json.122;
let Json.492 : List U8 = CallByName List.8 Json.495 Json.496;
let Json.494 : I64 = 34i64;
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.487 : List U8 = CallByName List.4 Json.489 Json.490;
let Json.488 : {} = Struct {};
let Json.125 : List U8 = CallByName Encode.23 Json.487 Json.124 Json.488;
joinpoint Json.482 Json.126:
let Json.124 : List U8 = CallByName Encode.23 Json.487 Json.123 Json.488;
joinpoint Json.482 Json.125:
let Json.480 : U64 = 1i64;
let Json.479 : U64 = CallByName Num.20 Json.122 Json.480;
let Json.478 : {List U8, U64} = Struct {Json.126, Json.479};
let Json.479 : U64 = CallByName Num.20 Json.121 Json.480;
let Json.478 : {List U8, U64} = Struct {Json.125, Json.479};
ret Json.478;
in
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
let Json.485 : I64 = 44i64;
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;
else
jump Json.482 Json.125;
jump Json.482 Json.124;
procedure Json.18 (Json.98):
let Json.502 : Str = CallByName Encode.22 Json.98;
procedure Json.18 (Json.97):
let Json.502 : Str = CallByName Encode.22 Json.97;
ret Json.502;
procedure Json.20 (Json.114):
let Json.426 : List {Str, Str} = CallByName Encode.22 Json.114;
procedure Json.20 (Json.113):
let Json.426 : List {Str, Str} = CallByName Encode.22 Json.113;
ret Json.426;
procedure Json.20 (Json.114):
let Json.468 : List {Str, Str} = CallByName Encode.22 Json.114;
procedure Json.20 (Json.113):
let Json.468 : List {Str, Str} = CallByName Encode.22 Json.113;
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.512 : U8 = CallByName Num.127 Json.513;
let Json.510 : List U8 = CallByName List.4 Json.100 Json.512;
let Json.511 : List U8 = CallByName Str.12 Json.98;
let Json.510 : List U8 = CallByName List.4 Json.99 Json.512;
let Json.511 : List U8 = CallByName Str.12 Json.97;
let Json.507 : List U8 = CallByName List.8 Json.510 Json.511;
let Json.509 : I64 = 34i64;
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;
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;
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;
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;
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;
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;
procedure Encode.25 (Encode.100, Encode.101):
@ -42,37 +42,37 @@ procedure Json.1 ():
let Json.425 : {} = Struct {};
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.460 : U8 = CallByName Num.127 Json.461;
let Json.118 : List U8 = CallByName List.4 Json.116 Json.460;
let Json.459 : U64 = CallByName List.6 Json.114;
let Json.436 : {List U8, U64} = Struct {Json.118, Json.459};
let Json.117 : List U8 = CallByName List.4 Json.115 Json.460;
let Json.459 : U64 = CallByName List.6 Json.113;
let Json.436 : {List U8, U64} = Struct {Json.117, Json.459};
let Json.437 : {} = Struct {};
let Json.435 : {List U8, U64} = CallByName List.18 Json.114 Json.436 Json.437;
dec Json.114;
let Json.120 : List U8 = StructAtIndex 0 Json.435;
inc Json.120;
let Json.435 : {List U8, U64} = CallByName List.18 Json.113 Json.436 Json.437;
dec Json.113;
let Json.119 : List U8 = StructAtIndex 0 Json.435;
inc Json.119;
dec Json.435;
let Json.434 : I64 = 125i64;
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;
procedure Json.117 (Json.430, Json.431):
let Json.123 : Str = StructAtIndex 0 Json.431;
procedure Json.116 (Json.430, Json.431):
let Json.122 : Str = StructAtIndex 0 Json.431;
inc Json.122;
let Json.123 : Str = StructAtIndex 1 Json.431;
inc Json.123;
let Json.124 : Str = StructAtIndex 1 Json.431;
inc Json.124;
dec Json.431;
let Json.121 : List U8 = StructAtIndex 0 Json.430;
inc Json.121;
let Json.122 : U64 = StructAtIndex 1 Json.430;
let Json.120 : List U8 = StructAtIndex 0 Json.430;
inc Json.120;
let Json.121 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.458 : I64 = 34i64;
let Json.457 : U8 = CallByName Num.127 Json.458;
let Json.455 : List U8 = CallByName List.4 Json.121 Json.457;
let Json.456 : List U8 = CallByName Str.12 Json.123;
let Json.455 : List U8 = CallByName List.4 Json.120 Json.457;
let Json.456 : List U8 = CallByName Str.12 Json.122;
let Json.452 : List U8 = CallByName List.8 Json.455 Json.456;
let Json.454 : I64 = 34i64;
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.447 : List U8 = CallByName List.4 Json.449 Json.450;
let Json.448 : {} = Struct {};
let Json.125 : List U8 = CallByName Encode.23 Json.447 Json.124 Json.448;
joinpoint Json.442 Json.126:
let Json.124 : List U8 = CallByName Encode.23 Json.447 Json.123 Json.448;
joinpoint Json.442 Json.125:
let Json.440 : U64 = 1i64;
let Json.439 : U64 = CallByName Num.20 Json.122 Json.440;
let Json.438 : {List U8, U64} = Struct {Json.126, Json.439};
let Json.439 : U64 = CallByName Num.20 Json.121 Json.440;
let Json.438 : {List U8, U64} = Struct {Json.125, Json.439};
ret Json.438;
in
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
let Json.445 : I64 = 44i64;
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;
else
jump Json.442 Json.125;
jump Json.442 Json.124;
procedure Json.18 (Json.98):
let Json.462 : Str = CallByName Encode.22 Json.98;
procedure Json.18 (Json.97):
let Json.462 : Str = CallByName Encode.22 Json.97;
ret Json.462;
procedure Json.20 (Json.114):
let Json.426 : List {Str, Str} = CallByName Encode.22 Json.114;
procedure Json.20 (Json.113):
let Json.426 : List {Str, Str} = CallByName Encode.22 Json.113;
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.472 : U8 = CallByName Num.127 Json.473;
let Json.470 : List U8 = CallByName List.4 Json.100 Json.472;
let Json.471 : List U8 = CallByName Str.12 Json.98;
let Json.470 : List U8 = CallByName List.4 Json.99 Json.472;
let Json.471 : List U8 = CallByName Str.12 Json.97;
let Json.467 : List U8 = CallByName List.8 Json.470 Json.471;
let Json.469 : I64 = 34i64;
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;
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;
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;
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;
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;
procedure Encode.25 (Encode.100, Encode.101):
@ -50,37 +50,37 @@ procedure Json.1 ():
let Json.425 : {} = Struct {};
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.460 : U8 = CallByName Num.127 Json.461;
let Json.118 : List U8 = CallByName List.4 Json.116 Json.460;
let Json.459 : U64 = CallByName List.6 Json.114;
let Json.436 : {List U8, U64} = Struct {Json.118, Json.459};
let Json.117 : List U8 = CallByName List.4 Json.115 Json.460;
let Json.459 : U64 = CallByName List.6 Json.113;
let Json.436 : {List U8, U64} = Struct {Json.117, Json.459};
let Json.437 : {} = Struct {};
let Json.435 : {List U8, U64} = CallByName List.18 Json.114 Json.436 Json.437;
dec Json.114;
let Json.120 : List U8 = StructAtIndex 0 Json.435;
inc Json.120;
let Json.435 : {List U8, U64} = CallByName List.18 Json.113 Json.436 Json.437;
dec Json.113;
let Json.119 : List U8 = StructAtIndex 0 Json.435;
inc Json.119;
dec Json.435;
let Json.434 : I64 = 125i64;
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;
procedure Json.117 (Json.430, Json.431):
let Json.123 : Str = StructAtIndex 0 Json.431;
procedure Json.116 (Json.430, Json.431):
let Json.122 : Str = StructAtIndex 0 Json.431;
inc Json.122;
let Json.123 : Str = StructAtIndex 1 Json.431;
inc Json.123;
let Json.124 : Str = StructAtIndex 1 Json.431;
inc Json.124;
dec Json.431;
let Json.121 : List U8 = StructAtIndex 0 Json.430;
inc Json.121;
let Json.122 : U64 = StructAtIndex 1 Json.430;
let Json.120 : List U8 = StructAtIndex 0 Json.430;
inc Json.120;
let Json.121 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.458 : I64 = 34i64;
let Json.457 : U8 = CallByName Num.127 Json.458;
let Json.455 : List U8 = CallByName List.4 Json.121 Json.457;
let Json.456 : List U8 = CallByName Str.12 Json.123;
let Json.455 : List U8 = CallByName List.4 Json.120 Json.457;
let Json.456 : List U8 = CallByName Str.12 Json.122;
let Json.452 : List U8 = CallByName List.8 Json.455 Json.456;
let Json.454 : I64 = 34i64;
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.447 : List U8 = CallByName List.4 Json.449 Json.450;
let Json.448 : {} = Struct {};
let Json.125 : List U8 = CallByName Encode.23 Json.447 Json.124 Json.448;
joinpoint Json.442 Json.126:
let Json.124 : List U8 = CallByName Encode.23 Json.447 Json.123 Json.448;
joinpoint Json.442 Json.125:
let Json.440 : U64 = 1i64;
let Json.439 : U64 = CallByName Num.20 Json.122 Json.440;
let Json.438 : {List U8, U64} = Struct {Json.126, Json.439};
let Json.439 : U64 = CallByName Num.20 Json.121 Json.440;
let Json.438 : {List U8, U64} = Struct {Json.125, Json.439};
ret Json.438;
in
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
let Json.445 : I64 = 44i64;
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;
else
jump Json.442 Json.125;
jump Json.442 Json.124;
procedure Json.18 (Json.98):
let Json.474 : Str = CallByName Encode.22 Json.98;
procedure Json.18 (Json.97):
let Json.474 : Str = CallByName Encode.22 Json.97;
ret Json.474;
procedure Json.20 (Json.114):
let Json.426 : List {Str, Str} = CallByName Encode.22 Json.114;
procedure Json.20 (Json.113):
let Json.426 : List {Str, Str} = CallByName Encode.22 Json.113;
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.472 : U8 = CallByName Num.127 Json.473;
let Json.470 : List U8 = CallByName List.4 Json.100 Json.472;
let Json.471 : List U8 = CallByName Str.12 Json.98;
let Json.470 : List U8 = CallByName List.4 Json.99 Json.472;
let Json.471 : List U8 = CallByName Str.12 Json.97;
let Json.467 : List U8 = CallByName List.8 Json.470 Json.471;
let Json.469 : I64 = 34i64;
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;
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;
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;
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;
procedure Encode.25 (Encode.100, Encode.101):
@ -15,15 +15,15 @@ procedure Json.1 ():
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.18 (Json.98):
let Json.426 : Str = CallByName Encode.22 Json.98;
procedure Json.18 (Json.97):
let Json.426 : Str = CallByName Encode.22 Json.97;
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.436 : U8 = CallByName Num.127 Json.437;
let Json.434 : List U8 = CallByName List.4 Json.100 Json.436;
let Json.435 : List U8 = CallByName Str.12 Json.98;
let Json.434 : List U8 = CallByName List.4 Json.99 Json.436;
let Json.435 : List U8 = CallByName Str.12 Json.97;
let Json.431 : List U8 = CallByName List.8 Json.434 Json.435;
let Json.433 : I64 = 34i64;
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;
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;
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;
procedure Encode.25 (Encode.100, Encode.101):
@ -44,19 +44,19 @@ procedure Json.1 ():
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.128 : List Str = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
procedure Json.128 (Json.129, Json.428, #Attr.12):
let Json.127 : List Str = StructAtIndex 1 #Attr.12;
inc Json.127;
let Json.126 : Str = StructAtIndex 0 #Attr.12;
inc Json.126;
dec #Attr.12;
let Json.466 : I64 = 123i64;
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.463 : U8 = CallByName Num.127 Json.464;
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.459 : I64 = 34i64;
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.453 : I64 = 91i64;
let Json.452 : U8 = CallByName Num.127 Json.453;
let Json.132 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.128;
let Json.438 : {List U8, U64} = Struct {Json.132, Json.450};
let Json.131 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.127;
let Json.438 : {List U8, U64} = Struct {Json.131, Json.450};
let Json.439 : {} = Struct {};
let Json.437 : {List U8, U64} = CallByName List.18 Json.128 Json.438 Json.439;
dec Json.128;
let Json.134 : List U8 = StructAtIndex 0 Json.437;
inc Json.134;
let Json.437 : {List U8, U64} = CallByName List.18 Json.127 Json.438 Json.439;
dec Json.127;
let Json.133 : List U8 = StructAtIndex 0 Json.437;
inc Json.133;
dec Json.437;
let Json.436 : I64 = 93i64;
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.433 : U8 = CallByName Num.127 Json.434;
let Json.431 : List U8 = CallByName List.4 Json.432 Json.433;
ret Json.431;
procedure Json.131 (Json.430, Json.137):
let Json.135 : List U8 = StructAtIndex 0 Json.430;
inc Json.135;
let Json.136 : U64 = StructAtIndex 1 Json.430;
procedure Json.130 (Json.430, Json.136):
let Json.134 : List U8 = StructAtIndex 0 Json.430;
inc Json.134;
let Json.135 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.449 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.449;
joinpoint Json.444 Json.139:
let Json.137 : List U8 = CallByName Encode.23 Json.134 Json.136 Json.449;
joinpoint Json.444 Json.138:
let Json.442 : U64 = 1i64;
let Json.441 : U64 = CallByName Num.20 Json.136 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.139, Json.441};
let Json.441 : U64 = CallByName Num.20 Json.135 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.138, Json.441};
ret Json.440;
in
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
let Json.447 : I64 = 44i64;
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;
else
jump Json.444 Json.138;
jump Json.444 Json.137;
procedure Json.18 (Json.98):
let Json.467 : Str = CallByName Encode.22 Json.98;
procedure Json.18 (Json.97):
let Json.467 : Str = CallByName Encode.22 Json.97;
ret Json.467;
procedure Json.21 (Json.127, Json.128):
let Json.427 : {Str, List Str} = Struct {Json.127, Json.128};
procedure Json.21 (Json.126, Json.127):
let Json.427 : {Str, List Str} = Struct {Json.126, Json.127};
let Json.426 : {Str, List Str} = CallByName Encode.22 Json.427;
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.477 : U8 = CallByName Num.127 Json.478;
let Json.475 : List U8 = CallByName List.4 Json.100 Json.477;
let Json.476 : List U8 = CallByName Str.12 Json.98;
let Json.475 : List U8 = CallByName List.4 Json.99 Json.477;
let Json.476 : List U8 = CallByName Str.12 Json.97;
let Json.472 : List U8 = CallByName List.8 Json.475 Json.476;
let Json.474 : I64 = 34i64;
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;
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;
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;
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;
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;
procedure Encode.25 (Encode.100, Encode.101):
@ -50,19 +50,19 @@ procedure Json.1 ():
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.128 : List Str = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
procedure Json.128 (Json.129, Json.428, #Attr.12):
let Json.127 : List Str = StructAtIndex 1 #Attr.12;
inc Json.127;
let Json.126 : Str = StructAtIndex 0 #Attr.12;
inc Json.126;
dec #Attr.12;
let Json.466 : I64 = 123i64;
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.463 : U8 = CallByName Num.127 Json.464;
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.459 : I64 = 34i64;
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.453 : I64 = 91i64;
let Json.452 : U8 = CallByName Num.127 Json.453;
let Json.132 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.128;
let Json.438 : {List U8, U64} = Struct {Json.132, Json.450};
let Json.131 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.127;
let Json.438 : {List U8, U64} = Struct {Json.131, Json.450};
let Json.439 : {} = Struct {};
let Json.437 : {List U8, U64} = CallByName List.18 Json.128 Json.438 Json.439;
dec Json.128;
let Json.134 : List U8 = StructAtIndex 0 Json.437;
inc Json.134;
let Json.437 : {List U8, U64} = CallByName List.18 Json.127 Json.438 Json.439;
dec Json.127;
let Json.133 : List U8 = StructAtIndex 0 Json.437;
inc Json.133;
dec Json.437;
let Json.436 : I64 = 93i64;
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.433 : U8 = CallByName Num.127 Json.434;
let Json.431 : List U8 = CallByName List.4 Json.432 Json.433;
ret Json.431;
procedure Json.131 (Json.430, Json.137):
let Json.135 : List U8 = StructAtIndex 0 Json.430;
inc Json.135;
let Json.136 : U64 = StructAtIndex 1 Json.430;
procedure Json.130 (Json.430, Json.136):
let Json.134 : List U8 = StructAtIndex 0 Json.430;
inc Json.134;
let Json.135 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.449 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.449;
joinpoint Json.444 Json.139:
let Json.137 : List U8 = CallByName Encode.23 Json.134 Json.136 Json.449;
joinpoint Json.444 Json.138:
let Json.442 : U64 = 1i64;
let Json.441 : U64 = CallByName Num.20 Json.136 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.139, Json.441};
let Json.441 : U64 = CallByName Num.20 Json.135 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.138, Json.441};
ret Json.440;
in
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
let Json.447 : I64 = 44i64;
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;
else
jump Json.444 Json.138;
jump Json.444 Json.137;
procedure Json.18 (Json.98):
let Json.479 : Str = CallByName Encode.22 Json.98;
procedure Json.18 (Json.97):
let Json.479 : Str = CallByName Encode.22 Json.97;
ret Json.479;
procedure Json.21 (Json.127, Json.128):
let Json.427 : {Str, List Str} = Struct {Json.127, Json.128};
procedure Json.21 (Json.126, Json.127):
let Json.427 : {Str, List Str} = Struct {Json.126, Json.127};
let Json.426 : {Str, List Str} = CallByName Encode.22 Json.427;
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.477 : U8 = CallByName Num.127 Json.478;
let Json.475 : List U8 = CallByName List.4 Json.100 Json.477;
let Json.476 : List U8 = CallByName Str.12 Json.98;
let Json.475 : List U8 = CallByName List.4 Json.99 Json.477;
let Json.476 : List U8 = CallByName Str.12 Json.97;
let Json.472 : List U8 = CallByName List.8 Json.475 Json.476;
let Json.474 : I64 = 34i64;
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;
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;
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;
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;
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;
ret Decode.116;
procedure Json.145 (Json.512, Json.513):
joinpoint Json.450 Json.447 Json.144:
let Json.147 : List U8 = StructAtIndex 0 Json.447;
inc Json.147;
let Json.146 : List U8 = StructAtIndex 1 Json.447;
procedure Json.144 (Json.512, Json.513):
joinpoint Json.450 Json.447 Json.143:
let Json.146 : List U8 = StructAtIndex 0 Json.447;
inc Json.146;
let Json.145 : List U8 = StructAtIndex 1 Json.447;
inc Json.145;
dec Json.447;
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;
in
let Json.496 : U64 = lowlevel ListLen Json.147;
let Json.496 : U64 = lowlevel ListLen Json.146;
let Json.497 : U64 = 2i64;
let Json.498 : Int1 = lowlevel NumGte Json.496 Json.497;
if Json.498 then
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.149 : U8 = lowlevel ListGetUnsafe Json.147 Json.488;
let Json.458 : Int1 = CallByName Json.22 Json.148 Json.149;
let Json.148 : U8 = lowlevel ListGetUnsafe Json.146 Json.488;
let Json.458 : Int1 = CallByName Json.22 Json.147 Json.148;
if Json.458 then
let Json.465 : U64 = 2i64;
let Json.462 : List U8 = CallByName List.29 Json.147 Json.465;
let Json.464 : List U8 = CallByName List.4 Json.146 Json.148;
let Json.463 : List U8 = CallByName List.4 Json.464 Json.149;
let Json.462 : List U8 = CallByName List.29 Json.146 Json.465;
let Json.464 : List U8 = CallByName List.4 Json.145 Json.147;
let Json.463 : List U8 = CallByName List.4 Json.464 Json.148;
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
let Json.452 : Int1 = CallByName Json.290 Json.148;
let Json.452 : Int1 = CallByName Json.289 Json.147;
if Json.452 then
let Json.456 : List U8 = CallByName List.38 Json.147;
let Json.457 : List U8 = CallByName List.4 Json.146 Json.148;
let Json.456 : List U8 = CallByName List.38 Json.146;
let Json.457 : List U8 = CallByName List.4 Json.145 Json.147;
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
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;
else
let Json.493 : U64 = lowlevel ListLen Json.147;
let Json.493 : U64 = lowlevel ListLen Json.146;
let Json.494 : U64 = 1i64;
let Json.495 : Int1 = lowlevel NumGte Json.493 Json.494;
if Json.495 then
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:
if Json.491 then
let Json.483 : List U8 = CallByName List.38 Json.147;
let Json.484 : List U8 = CallByName List.4 Json.146 Json.150;
let Json.483 : List U8 = CallByName List.38 Json.146;
let Json.484 : List U8 = CallByName List.4 Json.145 Json.149;
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
jump Json.490;
in
let Json.486 : Int1 = CallByName Json.290 Json.150;
let Json.486 : Int1 = CallByName Json.289 Json.149;
jump Json.485 Json.486;
else
jump Json.490;
@ -134,8 +134,8 @@ procedure Json.2 ():
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.22 (Json.140, Json.141):
let Json.466 : {U8, U8} = Struct {Json.140, Json.141};
procedure Json.22 (Json.139, Json.140):
let Json.466 : {U8, U8} = Struct {Json.139, Json.140};
joinpoint Json.475:
let Json.474 : Int1 = CallByName Bool.1;
ret Json.474;
@ -180,71 +180,71 @@ procedure Json.22 (Json.140, Json.141):
else
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.449 : {List U8, List U8} = Struct {Json.143, Json.500};
let Json.448 : {List U8, List U8} = CallByName Json.145 Json.449 Json.144;
let Json.449 : {List U8, List U8} = Struct {Json.142, Json.500};
let Json.448 : {List U8, List U8} = CallByName Json.144 Json.449 Json.143;
ret Json.448;
procedure Json.290 (Json.291):
procedure Json.289 (Json.290):
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;
procedure Json.300 (Json.301, Json.428):
let Json.429 : {List U8, [C {}, C Str]} = CallByName Json.41 Json.301;
procedure Json.299 (Json.300, Json.428):
let Json.429 : {List U8, [C {}, C Str]} = CallByName Json.41 Json.300;
ret Json.429;
procedure Json.41 (Json.283):
procedure Json.41 (Json.282):
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;
let Json.505 : {List U8, List U8} = CallByName List.52 Json.283 Json.506;
let Json.284 : List U8 = StructAtIndex 0 Json.505;
inc Json.284;
let Json.286 : List U8 = StructAtIndex 1 Json.505;
inc Json.286;
let Json.285 : List U8 = StructAtIndex 1 Json.505;
inc Json.285;
dec Json.505;
let Json.504 : U8 = 34i64;
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.284;
dec Json.283;
if Json.433 then
dec Json.283;
dec Json.282;
let Json.446 : {} = Struct {};
let Json.445 : {List U8, List U8} = CallByName Json.23 Json.286 Json.446;
let Json.289 : List U8 = StructAtIndex 0 Json.445;
inc Json.289;
let Json.288 : List U8 = StructAtIndex 1 Json.445;
let Json.445 : {List U8, List U8} = CallByName Json.23 Json.285 Json.446;
let Json.288 : List U8 = StructAtIndex 0 Json.445;
inc Json.288;
let Json.287 : List U8 = StructAtIndex 1 Json.445;
inc Json.287;
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.443 : U8 = GetTagId Json.434;
let Json.444 : Int1 = lowlevel Eq Json.442 Json.443;
if Json.444 then
let Json.292 : Str = UnionAtIndex (Id 1) (Index 0) Json.434;
inc Json.292;
let Json.291 : Str = UnionAtIndex (Id 1) (Index 0) Json.434;
inc Json.291;
dec Json.434;
let Json.438 : U64 = 1i64;
let Json.437 : {List U8, List U8} = CallByName List.52 Json.289 Json.438;
let Json.294 : List U8 = StructAtIndex 1 Json.437;
inc Json.294;
let Json.437 : {List U8, List U8} = CallByName List.52 Json.288 Json.438;
let Json.293 : List U8 = StructAtIndex 1 Json.437;
inc Json.293;
dec Json.437;
let Json.436 : [C {}, C Str] = TagId(1) Json.292;
let Json.435 : {List U8, [C {}, C Str]} = Struct {Json.294, Json.436};
let Json.436 : [C {}, C Str] = TagId(1) Json.291;
let Json.435 : {List U8, [C {}, C Str]} = Struct {Json.293, Json.436};
ret Json.435;
else
dec Json.434;
let Json.441 : {} = Struct {};
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;
else
dec Json.286;
dec Json.285;
let Json.432 : {} = Struct {};
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;
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;
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;
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;
ret Decode.115;
procedure Json.145 (Json.512, Json.513):
joinpoint Json.450 Json.447 Json.144:
let Json.147 : List U8 = StructAtIndex 0 Json.447;
inc Json.147;
let Json.146 : List U8 = StructAtIndex 1 Json.447;
procedure Json.144 (Json.512, Json.513):
joinpoint Json.450 Json.447 Json.143:
let Json.146 : List U8 = StructAtIndex 0 Json.447;
inc Json.146;
let Json.145 : List U8 = StructAtIndex 1 Json.447;
inc Json.145;
dec Json.447;
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;
in
let Json.496 : U64 = lowlevel ListLen Json.147;
let Json.496 : U64 = lowlevel ListLen Json.146;
let Json.497 : U64 = 2i64;
let Json.498 : Int1 = lowlevel NumGte Json.496 Json.497;
if Json.498 then
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.149 : U8 = lowlevel ListGetUnsafe Json.147 Json.488;
let Json.458 : Int1 = CallByName Json.22 Json.148 Json.149;
let Json.148 : U8 = lowlevel ListGetUnsafe Json.146 Json.488;
let Json.458 : Int1 = CallByName Json.22 Json.147 Json.148;
if Json.458 then
let Json.465 : U64 = 2i64;
let Json.462 : List U8 = CallByName List.29 Json.147 Json.465;
let Json.464 : List U8 = CallByName List.4 Json.146 Json.148;
let Json.463 : List U8 = CallByName List.4 Json.464 Json.149;
let Json.462 : List U8 = CallByName List.29 Json.146 Json.465;
let Json.464 : List U8 = CallByName List.4 Json.145 Json.147;
let Json.463 : List U8 = CallByName List.4 Json.464 Json.148;
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
let Json.452 : Int1 = CallByName Json.290 Json.148;
let Json.452 : Int1 = CallByName Json.289 Json.147;
if Json.452 then
let Json.456 : List U8 = CallByName List.38 Json.147;
let Json.457 : List U8 = CallByName List.4 Json.146 Json.148;
let Json.456 : List U8 = CallByName List.38 Json.146;
let Json.457 : List U8 = CallByName List.4 Json.145 Json.147;
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
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;
else
let Json.493 : U64 = lowlevel ListLen Json.147;
let Json.493 : U64 = lowlevel ListLen Json.146;
let Json.494 : U64 = 1i64;
let Json.495 : Int1 = lowlevel NumGte Json.493 Json.494;
if Json.495 then
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:
if Json.491 then
let Json.483 : List U8 = CallByName List.38 Json.147;
let Json.484 : List U8 = CallByName List.4 Json.146 Json.150;
let Json.483 : List U8 = CallByName List.38 Json.146;
let Json.484 : List U8 = CallByName List.4 Json.145 Json.149;
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
jump Json.490;
in
let Json.486 : Int1 = CallByName Json.290 Json.150;
let Json.486 : Int1 = CallByName Json.289 Json.149;
jump Json.485 Json.486;
else
jump Json.490;
@ -108,8 +108,8 @@ procedure Json.2 ():
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.22 (Json.140, Json.141):
let Json.466 : {U8, U8} = Struct {Json.140, Json.141};
procedure Json.22 (Json.139, Json.140):
let Json.466 : {U8, U8} = Struct {Json.139, Json.140};
joinpoint Json.475:
let Json.474 : Int1 = CallByName Bool.1;
ret Json.474;
@ -154,71 +154,71 @@ procedure Json.22 (Json.140, Json.141):
else
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.449 : {List U8, List U8} = Struct {Json.143, Json.500};
let Json.448 : {List U8, List U8} = CallByName Json.145 Json.449 Json.144;
let Json.449 : {List U8, List U8} = Struct {Json.142, Json.500};
let Json.448 : {List U8, List U8} = CallByName Json.144 Json.449 Json.143;
ret Json.448;
procedure Json.290 (Json.291):
procedure Json.289 (Json.290):
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;
procedure Json.300 (Json.301, Json.428):
let Json.429 : {List U8, [C {}, C Str]} = CallByName Json.41 Json.301;
procedure Json.299 (Json.300, Json.428):
let Json.429 : {List U8, [C {}, C Str]} = CallByName Json.41 Json.300;
ret Json.429;
procedure Json.41 (Json.283):
procedure Json.41 (Json.282):
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;
let Json.505 : {List U8, List U8} = CallByName List.52 Json.283 Json.506;
let Json.284 : List U8 = StructAtIndex 0 Json.505;
inc Json.284;
let Json.286 : List U8 = StructAtIndex 1 Json.505;
inc Json.286;
let Json.285 : List U8 = StructAtIndex 1 Json.505;
inc Json.285;
dec Json.505;
let Json.504 : U8 = 34i64;
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.284;
dec Json.283;
if Json.433 then
dec Json.283;
dec Json.282;
let Json.446 : {} = Struct {};
let Json.445 : {List U8, List U8} = CallByName Json.23 Json.286 Json.446;
let Json.289 : List U8 = StructAtIndex 0 Json.445;
inc Json.289;
let Json.288 : List U8 = StructAtIndex 1 Json.445;
let Json.445 : {List U8, List U8} = CallByName Json.23 Json.285 Json.446;
let Json.288 : List U8 = StructAtIndex 0 Json.445;
inc Json.288;
let Json.287 : List U8 = StructAtIndex 1 Json.445;
inc Json.287;
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.443 : U8 = GetTagId Json.434;
let Json.444 : Int1 = lowlevel Eq Json.442 Json.443;
if Json.444 then
let Json.292 : Str = UnionAtIndex (Id 1) (Index 0) Json.434;
inc Json.292;
let Json.291 : Str = UnionAtIndex (Id 1) (Index 0) Json.434;
inc Json.291;
dec Json.434;
let Json.438 : U64 = 1i64;
let Json.437 : {List U8, List U8} = CallByName List.52 Json.289 Json.438;
let Json.294 : List U8 = StructAtIndex 1 Json.437;
inc Json.294;
let Json.437 : {List U8, List U8} = CallByName List.52 Json.288 Json.438;
let Json.293 : List U8 = StructAtIndex 1 Json.437;
inc Json.293;
dec Json.437;
let Json.436 : [C {}, C Str] = TagId(1) Json.292;
let Json.435 : {List U8, [C {}, C Str]} = Struct {Json.294, Json.436};
let Json.436 : [C {}, C Str] = TagId(1) Json.291;
let Json.435 : {List U8, [C {}, C Str]} = Struct {Json.293, Json.436};
ret Json.435;
else
dec Json.434;
let Json.441 : {} = Struct {};
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;
else
dec Json.286;
dec Json.285;
let Json.432 : {} = Struct {};
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;
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;
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;
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;
procedure Encode.25 (Encode.100, Encode.101):
@ -33,19 +33,19 @@ procedure Json.1 ():
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.128 : List Str = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
procedure Json.128 (Json.129, Json.428, #Attr.12):
let Json.127 : List Str = StructAtIndex 1 #Attr.12;
inc Json.127;
let Json.126 : Str = StructAtIndex 0 #Attr.12;
inc Json.126;
dec #Attr.12;
let Json.466 : I64 = 123i64;
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.463 : U8 = CallByName Num.127 Json.464;
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.459 : I64 = 34i64;
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.453 : I64 = 91i64;
let Json.452 : U8 = CallByName Num.127 Json.453;
let Json.132 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.128;
let Json.438 : {List U8, U64} = Struct {Json.132, Json.450};
let Json.131 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.127;
let Json.438 : {List U8, U64} = Struct {Json.131, Json.450};
let Json.439 : {} = Struct {};
let Json.437 : {List U8, U64} = CallByName List.18 Json.128 Json.438 Json.439;
dec Json.128;
let Json.134 : List U8 = StructAtIndex 0 Json.437;
inc Json.134;
let Json.437 : {List U8, U64} = CallByName List.18 Json.127 Json.438 Json.439;
dec Json.127;
let Json.133 : List U8 = StructAtIndex 0 Json.437;
inc Json.133;
dec Json.437;
let Json.436 : I64 = 93i64;
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.433 : U8 = CallByName Num.127 Json.434;
let Json.431 : List U8 = CallByName List.4 Json.432 Json.433;
ret Json.431;
procedure Json.131 (Json.430, Json.137):
let Json.135 : List U8 = StructAtIndex 0 Json.430;
inc Json.135;
let Json.136 : U64 = StructAtIndex 1 Json.430;
procedure Json.130 (Json.430, Json.136):
let Json.134 : List U8 = StructAtIndex 0 Json.430;
inc Json.134;
let Json.135 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.449 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.449;
joinpoint Json.444 Json.139:
let Json.137 : List U8 = CallByName Encode.23 Json.134 Json.136 Json.449;
joinpoint Json.444 Json.138:
let Json.442 : U64 = 1i64;
let Json.441 : U64 = CallByName Num.20 Json.136 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.139, Json.441};
let Json.441 : U64 = CallByName Num.20 Json.135 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.138, Json.441};
ret Json.440;
in
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
let Json.447 : I64 = 44i64;
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;
else
jump Json.444 Json.138;
jump Json.444 Json.137;
procedure Json.18 (Json.98):
let Json.482 : Str = CallByName Encode.22 Json.98;
procedure Json.18 (Json.97):
let Json.482 : Str = CallByName Encode.22 Json.97;
ret Json.482;
procedure Json.21 (Json.127, Json.128):
let Json.468 : {Str, List Str} = Struct {Json.127, Json.128};
procedure Json.21 (Json.126, Json.127):
let Json.468 : {Str, List Str} = Struct {Json.126, Json.127};
let Json.467 : {Str, List Str} = CallByName Encode.22 Json.468;
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.480 : U8 = CallByName Num.127 Json.481;
let Json.478 : List U8 = CallByName List.4 Json.100 Json.480;
let Json.479 : List U8 = CallByName Str.12 Json.98;
let Json.478 : List U8 = CallByName List.4 Json.99 Json.480;
let Json.479 : List U8 = CallByName Str.12 Json.97;
let Json.475 : List U8 = CallByName List.8 Json.478 Json.479;
let Json.477 : I64 = 34i64;
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;
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;
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;
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;
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):
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;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
@ -84,19 +84,19 @@ procedure Json.1 ():
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.128 : List [C {}, C {}] = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
procedure Json.128 (Json.129, Json.428, #Attr.12):
let Json.127 : List [C {}, C {}] = StructAtIndex 1 #Attr.12;
inc Json.127;
let Json.126 : Str = StructAtIndex 0 #Attr.12;
inc Json.126;
dec #Attr.12;
let Json.466 : I64 = 123i64;
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.463 : U8 = CallByName Num.127 Json.464;
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.459 : I64 = 34i64;
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.453 : I64 = 91i64;
let Json.452 : U8 = CallByName Num.127 Json.453;
let Json.132 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.128;
let Json.438 : {List U8, U64} = Struct {Json.132, Json.450};
let Json.131 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.127;
let Json.438 : {List U8, U64} = Struct {Json.131, Json.450};
let Json.439 : {} = Struct {};
let Json.437 : {List U8, U64} = CallByName List.18 Json.128 Json.438 Json.439;
dec Json.128;
let Json.134 : List U8 = StructAtIndex 0 Json.437;
inc Json.134;
let Json.437 : {List U8, U64} = CallByName List.18 Json.127 Json.438 Json.439;
dec Json.127;
let Json.133 : List U8 = StructAtIndex 0 Json.437;
inc Json.133;
dec Json.437;
let Json.436 : I64 = 93i64;
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.433 : U8 = CallByName Num.127 Json.434;
let Json.431 : List U8 = CallByName List.4 Json.432 Json.433;
ret Json.431;
procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.128 : List [] = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
procedure Json.128 (Json.129, Json.428, #Attr.12):
let Json.127 : List [] = StructAtIndex 1 #Attr.12;
inc Json.127;
let Json.126 : Str = StructAtIndex 0 #Attr.12;
inc Json.126;
dec #Attr.12;
let Json.516 : I64 = 123i64;
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.513 : U8 = CallByName Num.127 Json.514;
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.509 : I64 = 34i64;
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.503 : I64 = 91i64;
let Json.502 : U8 = CallByName Num.127 Json.503;
let Json.132 : List U8 = CallByName List.4 Json.501 Json.502;
let Json.500 : U64 = CallByName List.6 Json.128;
let Json.488 : {List U8, U64} = Struct {Json.132, Json.500};
let Json.131 : List U8 = CallByName List.4 Json.501 Json.502;
let Json.500 : U64 = CallByName List.6 Json.127;
let Json.488 : {List U8, U64} = Struct {Json.131, Json.500};
let Json.489 : {} = Struct {};
let Json.487 : {List U8, U64} = CallByName List.18 Json.128 Json.488 Json.489;
dec Json.128;
let Json.134 : List U8 = StructAtIndex 0 Json.487;
inc Json.134;
let Json.487 : {List U8, U64} = CallByName List.18 Json.127 Json.488 Json.489;
dec Json.127;
let Json.133 : List U8 = StructAtIndex 0 Json.487;
inc Json.133;
dec Json.487;
let Json.486 : I64 = 93i64;
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.483 : U8 = CallByName Num.127 Json.484;
let Json.481 : List U8 = CallByName List.4 Json.482 Json.483;
ret Json.481;
procedure Json.131 (Json.430, Json.137):
let Json.135 : List U8 = StructAtIndex 0 Json.430;
inc Json.135;
let Json.136 : U64 = StructAtIndex 1 Json.430;
procedure Json.130 (Json.430, Json.136):
let Json.134 : List U8 = StructAtIndex 0 Json.430;
inc Json.134;
let Json.135 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.449 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.449;
joinpoint Json.444 Json.139:
let Json.137 : List U8 = CallByName Encode.23 Json.134 Json.136 Json.449;
joinpoint Json.444 Json.138:
let Json.442 : U64 = 1i64;
let Json.441 : U64 = CallByName Num.20 Json.136 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.139, Json.441};
let Json.441 : U64 = CallByName Num.20 Json.135 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.138, Json.441};
ret Json.440;
in
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
let Json.447 : I64 = 44i64;
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;
else
jump Json.444 Json.138;
jump Json.444 Json.137;
procedure Json.131 (Json.430, Json.137):
let Json.135 : List U8 = StructAtIndex 0 Json.430;
inc Json.135;
let Json.136 : U64 = StructAtIndex 1 Json.430;
procedure Json.130 (Json.430, Json.136):
let Json.134 : List U8 = StructAtIndex 0 Json.430;
inc Json.134;
let Json.135 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.499 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.499;
dec Json.135;
joinpoint Json.494 Json.139:
let Json.137 : List U8 = CallByName Encode.23 Json.134 Json.136 Json.499;
dec Json.134;
joinpoint Json.494 Json.138:
let Json.492 : U64 = 1i64;
let Json.491 : U64 = CallByName Num.20 Json.136 Json.492;
let Json.490 : {List U8, U64} = Struct {Json.139, Json.491};
let Json.491 : U64 = CallByName Num.20 Json.135 Json.492;
let Json.490 : {List U8, U64} = Struct {Json.138, Json.491};
ret Json.490;
in
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
let Json.497 : I64 = 44i64;
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;
else
jump Json.494 Json.138;
jump Json.494 Json.137;
procedure Json.21 (Json.127, Json.128):
let Json.468 : {Str, List [C {}, C {}]} = Struct {Json.127, Json.128};
procedure Json.21 (Json.126, Json.127):
let Json.468 : {Str, List [C {}, C {}]} = Struct {Json.126, Json.127};
let Json.467 : {Str, List [C {}, C {}]} = CallByName Encode.22 Json.468;
ret Json.467;
procedure Json.21 (Json.127, Json.128):
let Json.518 : {Str, List []} = Struct {Json.127, Json.128};
procedure Json.21 (Json.126, Json.127):
let Json.518 : {Str, List []} = Struct {Json.126, Json.127};
let Json.517 : {Str, List []} = CallByName Encode.22 Json.518;
ret Json.517;
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;
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;
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;
}
section h1,
section h2,
section h3,
section h4,
section p {
padding: 0px 16px;
}