language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-03 19:58:18 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Merge pull request #3369 from rtfeldman/pure-roc-list-walk

Browse source 
List.walk and friends in pure Roc
This commit is contained in:
Folkert de Vries 2022-07-03 02:32:43 +02:00 • committed by GitHub
commit 2a82d24847
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
39 changed files with 344 additions and 1630 deletions
Download patch file Download diff file Expand all files Collapse all files

17
crates/compiler/test_mono/generated/aliased_polymorphic_closure.txt
View file

@ -1,17 +0,0 @@
procedure Test.2 (Test.6, #Attr.12):
let Test.1 : U8 = StructAtIndex 0 #Attr.12;
let Test.11 : {U8} = Struct {Test.1};
ret Test.11;
procedure Test.4 (Test.5, #Attr.12):
let Test.1 : U8 = StructAtIndex 0 #Attr.12;
ret Test.1;
procedure Test.0 ():
let Test.1 : U8 = 1i64;
let Test.8 : {} = Struct {};
let Test.10 : {} = Struct {};
let Test.14 : {U8} = Struct {Test.1};
let Test.9 : {U8} = CallByName Test.2 Test.10 Test.14;
let Test.7 : U8 = CallByName Test.4 Test.8 Test.9;
ret Test.7;

4
crates/compiler/test_mono/generated/closure_in_list.txt
View file

@ -1,6 +1,6 @@
procedure List.6 (#Attr.2):
let List.259 : U64 = lowlevel ListLen #Attr.2;
ret List.259;
let List.284 : U64 = lowlevel ListLen #Attr.2;
ret List.284;
procedure Test.1 (Test.5):
let Test.2 : I64 = 41i64;

28
crates/compiler/test_mono/generated/empty_list_of_function_type.txt
View file

@ -1,22 +1,22 @@
procedure List.2 (List.73, List.74):
let List.265 : U64 = CallByName List.6 List.73;
let List.261 : Int1 = CallByName Num.22 List.74 List.265;
if List.261 then
let List.263 : {} = CallByName List.60 List.73 List.74;
let List.262 : [C {}, C {}] = Ok List.263;
ret List.262;
procedure List.2 (List.75, List.76):
let List.290 : U64 = CallByName List.6 List.75;
let List.286 : Int1 = CallByName Num.22 List.76 List.290;
if List.286 then
let List.288 : {} = CallByName List.60 List.75 List.76;
let List.287 : [C {}, C {}] = Ok List.288;
ret List.287;
else
let List.260 : {} = Struct {};
let List.259 : [C {}, C {}] = Err List.260;
ret List.259;
let List.285 : {} = Struct {};
let List.284 : [C {}, C {}] = Err List.285;
ret List.284;
procedure List.6 (#Attr.2):
let List.268 : U64 = lowlevel ListLen #Attr.2;
ret List.268;
let List.293 : U64 = lowlevel ListLen #Attr.2;
ret List.293;
procedure List.60 (#Attr.2, #Attr.3):
let List.267 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.267;
let List.292 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.292;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

4
crates/compiler/test_mono/generated/encode.txt
View file

@ -1,6 +1,6 @@
procedure List.4 (#Attr.2, #Attr.3):
let List.259 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.259;
let List.284 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.284;
procedure Test.20 (Test.22):
let Test.34 : {U8} = Struct {Test.22};

104
crates/compiler/test_mono/generated/encode_custom_type.txt
View file

@ -1,104 +0,0 @@
procedure Encode.22 (Encode.93):
ret Encode.93;
procedure Encode.22 (Encode.93):
ret Encode.93;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.107 : List U8 = CallByName Test.3 Encode.94 Encode.96;
ret Encode.107;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.114 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102;
ret Encode.114;
procedure Encode.25 (Encode.100, Encode.101):
let Encode.104 : List U8 = Array [];
let Encode.105 : {} = CallByName Test.2 Encode.100;
let Encode.103 : List U8 = CallByName Encode.23 Encode.104 Encode.105 Encode.101;
ret Encode.103;
procedure Json.1 ():
let Json.102 : {} = Struct {};
ret Json.102;
procedure Json.17 (Json.64):
let Json.104 : {Str} = Struct {Json.64};
let Json.103 : {Str} = CallByName Encode.22 Json.104;
ret Json.103;
procedure Json.65 (Json.66, Json.105, #Attr.12):
let Json.64 : Str = StructAtIndex 0 #Attr.12;
inc Json.64;
dec #Attr.12;
let Json.114 : I32 = 34i64;
let Json.113 : U8 = CallByName Num.122 Json.114;
let Json.111 : List U8 = CallByName List.4 Json.66 Json.113;
let Json.112 : List U8 = CallByName Str.12 Json.64;
let Json.108 : List U8 = CallByName List.8 Json.111 Json.112;
let Json.110 : I32 = 34i64;
let Json.109 : U8 = CallByName Num.122 Json.110;
let Json.107 : List U8 = CallByName List.4 Json.108 Json.109;
ret Json.107;
procedure List.4 (#Attr.2, #Attr.3):
let List.141 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.141;
procedure List.8 (#Attr.2, #Attr.3):
let List.142 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
ret List.142;
procedure Num.122 (#Attr.2):
let Num.272 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.272;
procedure Str.12 (#Attr.2):
let Str.73 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.73;
procedure Str.9 (#Attr.2):
let #Attr.3 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
let Str.69 : Int1 = StructAtIndex 2 #Attr.3;
if Str.69 then
let Str.71 : Str = StructAtIndex 1 #Attr.3;
inc Str.71;
dec #Attr.3;
let Str.70 : [C {U64, U8}, C Str] = Ok Str.71;
ret Str.70;
else
let Str.67 : U8 = StructAtIndex 3 #Attr.3;
let Str.68 : U64 = StructAtIndex 0 #Attr.3;
dec #Attr.3;
let Str.66 : {U64, U8} = Struct {Str.68, Str.67};
let Str.65 : [C {U64, U8}, C Str] = Err Str.66;
ret Str.65;
procedure Test.2 (Test.8):
let Test.18 : {} = Struct {};
let Test.17 : {} = CallByName Encode.22 Test.18;
ret Test.17;
procedure Test.3 (Test.4, Test.5):
let Test.21 : Str = "Hello, World!\n";
let Test.20 : {Str} = CallByName Json.17 Test.21;
let Test.19 : List U8 = CallByName Encode.23 Test.4 Test.20 Test.5;
ret Test.19;
procedure Test.0 ():
let Test.15 : {} = Struct {};
let Test.16 : {} = CallByName Json.1;
let Test.14 : List U8 = CallByName Encode.25 Test.15 Test.16;
let Test.6 : [C {U64, U8}, C Str] = CallByName Str.9 Test.14;
let Test.11 : U8 = 1i64;
let Test.12 : U8 = GetTagId Test.6;
let Test.13 : Int1 = lowlevel Eq Test.11 Test.12;
if Test.13 then
let Test.7 : Str = UnionAtIndex (Id 1) (Index 0) Test.6;
inc Test.7;
dec Test.6;
ret Test.7;
else
dec Test.6;
let Test.10 : Str = "<bad>";
ret Test.10;

30
crates/compiler/test_mono/generated/has_none.txt
View file

@ -1,30 +0,0 @@
procedure Test.4 (Test.30):
joinpoint Test.14 Test.5:
let Test.24 : Int1 = 1i64;
let Test.25 : Int1 = GetTagId Test.5;
let Test.26 : Int1 = lowlevel Eq Test.24 Test.25;
if Test.26 then
let Test.15 : Int1 = false;
ret Test.15;
else
let Test.20 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.5;
let Test.21 : U8 = 1i64;
let Test.22 : U8 = GetTagId Test.20;
let Test.23 : Int1 = lowlevel Eq Test.21 Test.22;
if Test.23 then
let Test.16 : Int1 = true;
ret Test.16;
else
let Test.8 : [<rnu><null>, C [C I64, C ] *self] = UnionAtIndex (Id 0) (Index 1) Test.5;
jump Test.14 Test.8;
in
jump Test.14 Test.30;
procedure Test.0 ():
let Test.29 : I64 = 3i64;
let Test.27 : [C I64, C ] = Just Test.29;
let Test.28 : [<rnu><null>, C [C I64, C ] *self] = Nil ;
let Test.13 : [<rnu><null>, C [C I64, C ] *self] = Cons Test.27 Test.28;
let Test.12 : Int1 = CallByName Test.4 Test.13;
dec Test.13;
ret Test.12;

4
crates/compiler/test_mono/generated/ir_int_add.txt
View file

@ -1,6 +1,6 @@
procedure List.6 (#Attr.2):
let List.259 : U64 = lowlevel ListLen #Attr.2;
ret List.259;
let List.284 : U64 = lowlevel ListLen #Attr.2;
ret List.284;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.275 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;

54
crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt
View file

@ -1,37 +1,37 @@
procedure List.2 (List.73, List.74):
let List.274 : U64 = CallByName List.6 List.73;
let List.270 : Int1 = CallByName Num.22 List.74 List.274;
if List.270 then
let List.272 : I64 = CallByName List.60 List.73 List.74;
let List.271 : [C {}, C I64] = Ok List.272;
ret List.271;
procedure List.2 (List.75, List.76):
let List.299 : U64 = CallByName List.6 List.75;
let List.295 : Int1 = CallByName Num.22 List.76 List.299;
if List.295 then
let List.297 : I64 = CallByName List.60 List.75 List.76;
let List.296 : [C {}, C I64] = Ok List.297;
ret List.296;
else
let List.269 : {} = Struct {};
let List.268 : [C {}, C I64] = Err List.269;
ret List.268;
let List.294 : {} = Struct {};
let List.293 : [C {}, C I64] = Err List.294;
ret List.293;
procedure List.6 (#Attr.2):
let List.275 : U64 = lowlevel ListLen #Attr.2;
ret List.275;
let List.300 : U64 = lowlevel ListLen #Attr.2;
ret List.300;
procedure List.60 (#Attr.2, #Attr.3):
let List.273 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.273;
let List.298 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.298;
procedure List.9 (List.184):
let List.266 : U64 = 0i64;
let List.259 : [C {}, C I64] = CallByName List.2 List.184 List.266;
let List.263 : U8 = 1i64;
let List.264 : U8 = GetTagId List.259;
let List.265 : Int1 = lowlevel Eq List.263 List.264;
if List.265 then
let List.185 : I64 = UnionAtIndex (Id 1) (Index 0) List.259;
let List.260 : [C Int1, C I64] = Ok List.185;
ret List.260;
procedure List.9 (List.202):
let List.291 : U64 = 0i64;
let List.284 : [C {}, C I64] = CallByName List.2 List.202 List.291;
let List.288 : U8 = 1i64;
let List.289 : U8 = GetTagId List.284;
let List.290 : Int1 = lowlevel Eq List.288 List.289;
if List.290 then
let List.203 : I64 = UnionAtIndex (Id 1) (Index 0) List.284;
let List.285 : [C Int1, C I64] = Ok List.203;
ret List.285;
else
let List.262 : Int1 = true;
let List.261 : [C Int1, C I64] = Err List.262;
ret List.261;
let List.287 : Int1 = true;
let List.286 : [C Int1, C I64] = Err List.287;
ret List.286;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

25
crates/compiler/test_mono/generated/linked_list_length_twice.txt
View file

@ -1,25 +0,0 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.274;
procedure Test.4 (Test.6):
let Test.16 : Int1 = 1i64;
let Test.17 : Int1 = GetTagId Test.6;
let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
if Test.18 then
let Test.12 : I64 = 0i64;
ret Test.12;
else
let Test.7 : [<rnu><null>, C I64 *self] = UnionAtIndex (Id 0) (Index 1) Test.6;
let Test.14 : I64 = 1i64;
let Test.15 : I64 = CallByName Test.4 Test.7;
let Test.13 : I64 = CallByName Num.19 Test.14 Test.15;
ret Test.13;
procedure Test.0 ():
let Test.3 : [<rnu><null>, C I64 *self] = Nil ;
let Test.9 : I64 = CallByName Test.4 Test.3;
let Test.10 : I64 = CallByName Test.4 Test.3;
dec Test.3;
let Test.8 : I64 = CallByName Num.19 Test.9 Test.10;
ret Test.8;

4
crates/compiler/test_mono/generated/list_append.txt
View file

@ -1,6 +1,6 @@
procedure List.4 (#Attr.2, #Attr.3):
let List.259 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.259;
let List.284 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.284;
procedure Test.0 ():
let Test.2 : List I64 = Array [1i64];

4
crates/compiler/test_mono/generated/list_append_closure.txt
View file

@ -1,6 +1,6 @@
procedure List.4 (#Attr.2, #Attr.3):
let List.259 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.259;
let List.284 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.284;
procedure Test.1 (Test.2):
let Test.6 : I64 = 42i64;

36
crates/compiler/test_mono/generated/list_cannot_update_inplace.txt
View file

@ -1,27 +1,27 @@
procedure List.3 (List.82, List.83, List.84):
let List.262 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
let List.261 : List I64 = StructAtIndex 0 List.262;
inc List.261;
dec List.262;
ret List.261;
procedure List.3 (List.84, List.85, List.86):
let List.287 : {List I64, I64} = CallByName List.57 List.84 List.85 List.86;
let List.286 : List I64 = StructAtIndex 0 List.287;
inc List.286;
dec List.287;
ret List.286;
procedure List.57 (List.79, List.80, List.81):
let List.268 : U64 = CallByName List.6 List.79;
let List.265 : Int1 = CallByName Num.22 List.80 List.268;
if List.265 then
let List.266 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
ret List.266;
procedure List.57 (List.81, List.82, List.83):
let List.293 : U64 = CallByName List.6 List.81;
let List.290 : Int1 = CallByName Num.22 List.82 List.293;
if List.290 then
let List.291 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
ret List.291;
else
let List.264 : {List I64, I64} = Struct {List.79, List.81};
ret List.264;
let List.289 : {List I64, I64} = Struct {List.81, List.83};
ret List.289;
procedure List.6 (#Attr.2):
let List.260 : U64 = lowlevel ListLen #Attr.2;
ret List.260;
let List.285 : U64 = lowlevel ListLen #Attr.2;
ret List.285;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.267 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.267;
let List.292 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.292;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;

28
crates/compiler/test_mono/generated/list_get.txt
View file

@ -1,22 +1,22 @@
procedure List.2 (List.73, List.74):
let List.265 : U64 = CallByName List.6 List.73;
let List.261 : Int1 = CallByName Num.22 List.74 List.265;
if List.261 then
let List.263 : I64 = CallByName List.60 List.73 List.74;
let List.262 : [C {}, C I64] = Ok List.263;
ret List.262;
procedure List.2 (List.75, List.76):
let List.290 : U64 = CallByName List.6 List.75;
let List.286 : Int1 = CallByName Num.22 List.76 List.290;
if List.286 then
let List.288 : I64 = CallByName List.60 List.75 List.76;
let List.287 : [C {}, C I64] = Ok List.288;
ret List.287;
else
let List.260 : {} = Struct {};
let List.259 : [C {}, C I64] = Err List.260;
ret List.259;
let List.285 : {} = Struct {};
let List.284 : [C {}, C I64] = Err List.285;
ret List.284;
procedure List.6 (#Attr.2):
let List.268 : U64 = lowlevel ListLen #Attr.2;
ret List.268;
let List.293 : U64 = lowlevel ListLen #Attr.2;
ret List.293;
procedure List.60 (#Attr.2, #Attr.3):
let List.267 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.267;
let List.292 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.292;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

8
crates/compiler/test_mono/generated/list_len.txt
View file

@ -1,10 +1,10 @@
procedure List.6 (#Attr.2):
let List.259 : U64 = lowlevel ListLen #Attr.2;
ret List.259;
let List.284 : U64 = lowlevel ListLen #Attr.2;
ret List.284;
procedure List.6 (#Attr.2):
let List.260 : U64 = lowlevel ListLen #Attr.2;
ret List.260;
let List.285 : U64 = lowlevel ListLen #Attr.2;
ret List.285;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;

32
crates/compiler/test_mono/generated/list_map_closure_borrows.txt
View file

@ -1,26 +1,26 @@
procedure List.2 (List.73, List.74):
let List.265 : U64 = CallByName List.6 List.73;
let List.261 : Int1 = CallByName Num.22 List.74 List.265;
if List.261 then
let List.263 : Str = CallByName List.60 List.73 List.74;
let List.262 : [C {}, C Str] = Ok List.263;
ret List.262;
procedure List.2 (List.75, List.76):
let List.290 : U64 = CallByName List.6 List.75;
let List.286 : Int1 = CallByName Num.22 List.76 List.290;
if List.286 then
let List.288 : Str = CallByName List.60 List.75 List.76;
let List.287 : [C {}, C Str] = Ok List.288;
ret List.287;
else
let List.260 : {} = Struct {};
let List.259 : [C {}, C Str] = Err List.260;
ret List.259;
let List.285 : {} = Struct {};
let List.284 : [C {}, C Str] = Err List.285;
ret List.284;
procedure List.5 (#Attr.2, #Attr.3):
let List.267 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
ret List.267;
let List.292 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
ret List.292;
procedure List.6 (#Attr.2):
let List.269 : U64 = lowlevel ListLen #Attr.2;
ret List.269;
let List.294 : U64 = lowlevel ListLen #Attr.2;
ret List.294;
procedure List.60 (#Attr.2, #Attr.3):
let List.268 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.268;
let List.293 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.293;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

32
crates/compiler/test_mono/generated/list_map_closure_owns.txt
View file

@ -1,28 +1,28 @@
procedure List.2 (List.73, List.74):
let List.265 : U64 = CallByName List.6 List.73;
let List.261 : Int1 = CallByName Num.22 List.74 List.265;
if List.261 then
let List.263 : Str = CallByName List.60 List.73 List.74;
let List.262 : [C {}, C Str] = Ok List.263;
ret List.262;
procedure List.2 (List.75, List.76):
let List.290 : U64 = CallByName List.6 List.75;
let List.286 : Int1 = CallByName Num.22 List.76 List.290;
if List.286 then
let List.288 : Str = CallByName List.60 List.75 List.76;
let List.287 : [C {}, C Str] = Ok List.288;
ret List.287;
else
let List.260 : {} = Struct {};
let List.259 : [C {}, C Str] = Err List.260;
ret List.259;
let List.285 : {} = Struct {};
let List.284 : [C {}, C Str] = Err List.285;
ret List.284;
procedure List.5 (#Attr.2, #Attr.3):
inc #Attr.2;
let List.267 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
let List.292 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
decref #Attr.2;
ret List.267;
ret List.292;
procedure List.6 (#Attr.2):
let List.269 : U64 = lowlevel ListLen #Attr.2;
ret List.269;
let List.294 : U64 = lowlevel ListLen #Attr.2;
ret List.294;
procedure List.60 (#Attr.2, #Attr.3):
let List.268 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.268;
let List.293 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.293;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

36
crates/compiler/test_mono/generated/list_pass_to_function.txt
View file

@ -1,27 +1,27 @@
procedure List.3 (List.82, List.83, List.84):
let List.260 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
let List.259 : List I64 = StructAtIndex 0 List.260;
inc List.259;
dec List.260;
ret List.259;
procedure List.3 (List.84, List.85, List.86):
let List.285 : {List I64, I64} = CallByName List.57 List.84 List.85 List.86;
let List.284 : List I64 = StructAtIndex 0 List.285;
inc List.284;
dec List.285;
ret List.284;
procedure List.57 (List.79, List.80, List.81):
let List.266 : U64 = CallByName List.6 List.79;
let List.263 : Int1 = CallByName Num.22 List.80 List.266;
if List.263 then
let List.264 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
ret List.264;
procedure List.57 (List.81, List.82, List.83):
let List.291 : U64 = CallByName List.6 List.81;
let List.288 : Int1 = CallByName Num.22 List.82 List.291;
if List.288 then
let List.289 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
ret List.289;
else
let List.262 : {List I64, I64} = Struct {List.79, List.81};
ret List.262;
let List.287 : {List I64, I64} = Struct {List.81, List.83};
ret List.287;
procedure List.6 (#Attr.2):
let List.267 : U64 = lowlevel ListLen #Attr.2;
ret List.267;
let List.292 : U64 = lowlevel ListLen #Attr.2;
ret List.292;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.265 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.265;
let List.290 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.290;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

14
crates/compiler/test_mono/generated/list_sort_asc.txt
View file

@ -1,16 +1,16 @@
procedure List.28 (#Attr.2, #Attr.3):
let List.262 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
let List.287 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
let Bool.14 : Int1 = lowlevel ListIsUnique #Attr.2;
if Bool.14 then
ret List.262;
ret List.287;
else
decref #Attr.2;
ret List.262;
ret List.287;
procedure List.54 (List.178):
let List.260 : {} = Struct {};
let List.259 : List I64 = CallByName List.28 List.178 List.260;
ret List.259;
procedure List.54 (List.196):
let List.285 : {} = Struct {};
let List.284 : List I64 = CallByName List.28 List.196 List.285;
ret List.284;
procedure Num.46 (#Attr.2, #Attr.3):
let Num.273 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;

21
crates/compiler/test_mono/generated/monomorphized_ints_aliased.txt
View file

@ -1,21 +0,0 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.5 (Test.7, Test.8):
let Test.17 : U64 = 1i64;
ret Test.17;
procedure Test.6 (Test.7, Test.8):
let Test.14 : U64 = 1i64;
ret Test.14;
procedure Test.0 ():
let Test.15 : U8 = 100i64;
let Test.16 : U32 = 100i64;
let Test.10 : U64 = CallByName Test.5 Test.15 Test.16;
let Test.12 : U32 = 100i64;
let Test.13 : U8 = 100i64;
let Test.11 : U64 = CallByName Test.6 Test.12 Test.13;
let Test.9 : U64 = CallByName Num.19 Test.10 Test.11;
ret Test.9;

70
crates/compiler/test_mono/generated/quicksort_swap.txt
View file

@ -1,43 +1,43 @@
procedure List.2 (List.73, List.74):
let List.279 : U64 = CallByName List.6 List.73;
let List.275 : Int1 = CallByName Num.22 List.74 List.279;
if List.275 then
let List.277 : I64 = CallByName List.60 List.73 List.74;
let List.276 : [C {}, C I64] = Ok List.277;
ret List.276;
procedure List.2 (List.75, List.76):
let List.304 : U64 = CallByName List.6 List.75;
let List.300 : Int1 = CallByName Num.22 List.76 List.304;
if List.300 then
let List.302 : I64 = CallByName List.60 List.75 List.76;
let List.301 : [C {}, C I64] = Ok List.302;
ret List.301;
else
let List.274 : {} = Struct {};
let List.273 : [C {}, C I64] = Err List.274;
ret List.273;
let List.299 : {} = Struct {};
let List.298 : [C {}, C I64] = Err List.299;
ret List.298;
procedure List.3 (List.82, List.83, List.84):
let List.263 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
let List.262 : List I64 = StructAtIndex 0 List.263;
inc List.262;
dec List.263;
ret List.262;
procedure List.57 (List.79, List.80, List.81):
let List.285 : U64 = CallByName List.6 List.79;
let List.282 : Int1 = CallByName Num.22 List.80 List.285;
if List.282 then
let List.283 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
ret List.283;
else
let List.281 : {List I64, I64} = Struct {List.79, List.81};
ret List.281;
procedure List.6 (#Attr.2):
let List.286 : U64 = lowlevel ListLen #Attr.2;
ret List.286;
procedure List.60 (#Attr.2, #Attr.3):
let List.287 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
procedure List.3 (List.84, List.85, List.86):
let List.288 : {List I64, I64} = CallByName List.57 List.84 List.85 List.86;
let List.287 : List I64 = StructAtIndex 0 List.288;
inc List.287;
dec List.288;
ret List.287;
procedure List.57 (List.81, List.82, List.83):
let List.310 : U64 = CallByName List.6 List.81;
let List.307 : Int1 = CallByName Num.22 List.82 List.310;
if List.307 then
let List.308 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
ret List.308;
else
let List.306 : {List I64, I64} = Struct {List.81, List.83};
ret List.306;
procedure List.6 (#Attr.2):
let List.311 : U64 = lowlevel ListLen #Attr.2;
ret List.311;
procedure List.60 (#Attr.2, #Attr.3):
let List.312 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.312;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.284 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.284;
let List.309 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.309;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

70
crates/compiler/test_mono/generated/rigids.txt
View file

@ -1,43 +1,43 @@
procedure List.2 (List.73, List.74):
let List.279 : U64 = CallByName List.6 List.73;
let List.275 : Int1 = CallByName Num.22 List.74 List.279;
if List.275 then
let List.277 : I64 = CallByName List.60 List.73 List.74;
let List.276 : [C {}, C I64] = Ok List.277;
ret List.276;
procedure List.2 (List.75, List.76):
let List.304 : U64 = CallByName List.6 List.75;
let List.300 : Int1 = CallByName Num.22 List.76 List.304;
if List.300 then
let List.302 : I64 = CallByName List.60 List.75 List.76;
let List.301 : [C {}, C I64] = Ok List.302;
ret List.301;
else
let List.274 : {} = Struct {};
let List.273 : [C {}, C I64] = Err List.274;
ret List.273;
let List.299 : {} = Struct {};
let List.298 : [C {}, C I64] = Err List.299;
ret List.298;
procedure List.3 (List.82, List.83, List.84):
let List.263 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
let List.262 : List I64 = StructAtIndex 0 List.263;
inc List.262;
dec List.263;
ret List.262;
procedure List.57 (List.79, List.80, List.81):
let List.285 : U64 = CallByName List.6 List.79;
let List.282 : Int1 = CallByName Num.22 List.80 List.285;
if List.282 then
let List.283 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
ret List.283;
else
let List.281 : {List I64, I64} = Struct {List.79, List.81};
ret List.281;
procedure List.6 (#Attr.2):
let List.286 : U64 = lowlevel ListLen #Attr.2;
ret List.286;
procedure List.60 (#Attr.2, #Attr.3):
let List.287 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
procedure List.3 (List.84, List.85, List.86):
let List.288 : {List I64, I64} = CallByName List.57 List.84 List.85 List.86;
let List.287 : List I64 = StructAtIndex 0 List.288;
inc List.287;
dec List.288;
ret List.287;
procedure List.57 (List.81, List.82, List.83):
let List.310 : U64 = CallByName List.6 List.81;
let List.307 : Int1 = CallByName Num.22 List.82 List.310;
if List.307 then
let List.308 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
ret List.308;
else
let List.306 : {List I64, I64} = Struct {List.81, List.83};
ret List.306;
procedure List.6 (#Attr.2):
let List.311 : U64 = lowlevel ListLen #Attr.2;
ret List.311;
procedure List.60 (#Attr.2, #Attr.3):
let List.312 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.312;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.284 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.284;
let List.309 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.309;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

53
crates/compiler/test_mono/generated/somehow_drops_definitions.txt
View file

@ -1,53 +0,0 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.274;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 ():
let Test.26 : I64 = 1i64;
ret Test.26;
procedure Test.2 ():
let Test.22 : I64 = 2i64;
ret Test.22;
procedure Test.3 (Test.6):
let Test.25 : I64 = CallByName Test.1;
let Test.24 : I64 = CallByName Num.19 Test.6 Test.25;
ret Test.24;
procedure Test.4 (Test.7):
let Test.21 : I64 = CallByName Test.2;
let Test.20 : I64 = CallByName Num.21 Test.7 Test.21;
ret Test.20;
procedure Test.5 (Test.8, Test.9):
joinpoint Test.15 Test.14:
ret Test.14;
in
switch Test.8:
case 0:
let Test.16 : I64 = CallByName Test.3 Test.9;
jump Test.15 Test.16;
default:
let Test.17 : I64 = CallByName Test.4 Test.9;
jump Test.15 Test.17;
procedure Test.0 ():
joinpoint Test.19 Test.12:
let Test.13 : I64 = 42i64;
let Test.11 : I64 = CallByName Test.5 Test.12 Test.13;
ret Test.11;
in
let Test.23 : Int1 = true;
if Test.23 then
let Test.3 : Int1 = false;
jump Test.19 Test.3;
else
let Test.4 : Int1 = true;
jump Test.19 Test.4;