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

Merge pull request #5715 from roc-lang/str-replace

Browse source 
Don't have Str.replace functions return Result
This commit is contained in:
Anton-4 2023-08-01 11:07:07 +02:00 • committed by GitHub
commit 44941db349
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
17 changed files with 226 additions and 221 deletions
Download patch file Download diff file Expand all files Collapse all files

47
crates/compiler/builtins/roc/Str.roc
View file

@ -638,12 +638,13 @@ countUtf8Bytes : Str -> Nat
substringUnsafe : Str, Nat, Nat -> Str
## Returns the given [Str] with each occurrence of a substring replaced.
## Returns [Err NotFound] if the substring is not found.
## If the substring is not found, returns the original string.
##
## ```
## expect Str.replaceEach "foo/bar/baz" "/" "_" == Ok "foo_bar_baz"
## expect Str.replaceEach "not here" "/" "_" == Err NotFound
## expect Str.replaceEach "foo/bar/baz" "/" "_" == "foo_bar_baz"
## expect Str.replaceEach "not here" "/" "_" == "not here"
## ```
replaceEach : Str, Str, Str -> Result Str [NotFound]
replaceEach : Str, Str, Str -> Str
replaceEach = \haystack, needle, flower ->
when splitFirst haystack needle is
Ok { before, after } ->
@ -653,9 +654,8 @@ replaceEach = \haystack, needle, flower ->
|> Str.concat before
|> Str.concat flower
|> replaceEachHelp after needle flower
|> Ok
Err err -> Err err
Err NotFound -> haystack
replaceEachHelp : Str, Str, Str, Str -> Str
replaceEachHelp = \buf, haystack, needle, flower ->
@ -668,39 +668,44 @@ replaceEachHelp = \buf, haystack, needle, flower ->
Err NotFound -> Str.concat buf haystack
expect Str.replaceEach "abXdeXghi" "X" "_" == Ok "ab_de_ghi"
expect Str.replaceEach "abXdeXghi" "X" "_" == "ab_de_ghi"
expect Str.replaceEach "abcdefg" "nothing" "_" == "abcdefg"
## Returns the given [Str] with the first occurrence of a substring replaced.
## Returns [Err NotFound] if the substring is not found.
## If the substring is not found, returns the original string.
##
## ```
## expect Str.replaceFirst "foo/bar/baz" "/" "_" == Ok "foo_bar/baz"
## expect Str.replaceFirst "no slashes here" "/" "_" == Err NotFound
## expect Str.replaceFirst "foo/bar/baz" "/" "_" == "foo_bar/baz"
## expect Str.replaceFirst "no slashes here" "/" "_" == "no slashes here"
## ```
replaceFirst : Str, Str, Str -> Result Str [NotFound]
replaceFirst : Str, Str, Str -> Str
replaceFirst = \haystack, needle, flower ->
when splitFirst haystack needle is
Ok { before, after } ->
Ok "\(before)\(flower)\(after)"
"\(before)\(flower)\(after)"
Err err -> Err err
Err NotFound -> haystack
expect Str.replaceFirst "abXdeXghi" "X" "_" == Ok "ab_deXghi"
expect Str.replaceFirst "abXdeXghi" "X" "_" == "ab_deXghi"
expect Str.replaceFirst "abcdefg" "nothing" "_" == "abcdefg"
## Returns the given [Str] with the last occurrence of a substring replaced.
## Returns [Err NotFound] if the substring is not found.
## If the substring is not found, returns the original string.
##
## ```
## expect Str.replaceLast "foo/bar/baz" "/" "_" == Ok "foo/bar_baz"
## expect Str.replaceLast "no slashes here" "/" "_" == Err NotFound
## expect Str.replaceLast "foo/bar/baz" "/" "_" == "foo/bar_baz"
## expect Str.replaceLast "no slashes here" "/" "_" == "no slashes here"
## ```
replaceLast : Str, Str, Str -> Result Str [NotFound]
replaceLast : Str, Str, Str -> Str
replaceLast = \haystack, needle, flower ->
when splitLast haystack needle is
Ok { before, after } ->
Ok "\(before)\(flower)\(after)"
"\(before)\(flower)\(after)"
Err err -> Err err
Err NotFound -> haystack
expect Str.replaceLast "abXdeXghi" "X" "_" == Ok "abXde_ghi"
expect Str.replaceLast "abXdeXghi" "X" "_" == "abXde_ghi"
expect Str.replaceLast "abcdefg" "nothing" "_" == "abcdefg"
## Returns the given [Str] before the first occurrence of a [delimiter](https://www.computerhope.com/jargon/d/delimite.htm), as well
## as the rest of the string after that occurrence.

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

@ -48,8 +48,8 @@ procedure Num.22 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.300 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.300;
let Str.291 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.291;
procedure Test.1 (Test.5):
ret Test.5;

48
crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt
View file

@ -361,38 +361,38 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.312;
procedure Str.12 (#Attr.2):
let Str.316 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.316;
procedure Str.4 (#Attr.2, #Attr.3):
let Str.319 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
ret Str.319;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
let Str.307 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.307;
procedure Str.4 (#Attr.2, #Attr.3):
let Str.310 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
ret Str.310;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.298;
procedure Str.55 (#Attr.2):
let Str.322 : List Str = lowlevel StrGraphemes #Attr.2;
ret Str.322;
let Str.313 : List Str = lowlevel StrGraphemes #Attr.2;
ret Str.313;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
let Str.296 : U64 = 0i64;
let Str.297 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
let Str.293 : Int1 = StructAtIndex 2 Str.80;
if Str.293 then
let Str.295 : Str = StructAtIndex 1 Str.80;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
ret Str.294;
else
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
let Str.291 : U8 = StructAtIndex 3 Str.80;
let Str.292 : U64 = StructAtIndex 0 Str.80;
let #Derived_gen.57 : Str = StructAtIndex 1 Str.80;
dec #Derived_gen.57;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
ret Str.289;
procedure TotallyNotJson.100 (TotallyNotJson.850):
let TotallyNotJson.1830 : Str = "a";

42
crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt
View file

@ -296,38 +296,38 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.302;
procedure Str.12 (#Attr.2):
let Str.309 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.309;
let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.300;
procedure Str.4 (#Attr.2, #Attr.3):
let Str.312 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
ret Str.312;
let Str.303 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
ret Str.303;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.298;
procedure Str.55 (#Attr.2):
let Str.315 : List Str = lowlevel StrGraphemes #Attr.2;
ret Str.315;
let Str.306 : List Str = lowlevel StrGraphemes #Attr.2;
ret Str.306;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
let Str.296 : U64 = 0i64;
let Str.297 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
let Str.293 : Int1 = StructAtIndex 2 Str.80;
if Str.293 then
let Str.295 : Str = StructAtIndex 1 Str.80;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
ret Str.294;
else
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
let Str.291 : U8 = StructAtIndex 3 Str.80;
let Str.292 : U64 = StructAtIndex 0 Str.80;
let #Derived_gen.36 : Str = StructAtIndex 1 Str.80;
dec #Derived_gen.36;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
ret Str.289;
procedure TotallyNotJson.100 (TotallyNotJson.850):
let TotallyNotJson.1479 : Str = "a";

42
crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt
View file

@ -303,38 +303,38 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.302;
procedure Str.12 (#Attr.2):
let Str.309 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.309;
let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.300;
procedure Str.4 (#Attr.2, #Attr.3):
let Str.312 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
ret Str.312;
let Str.303 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
ret Str.303;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.298;
procedure Str.55 (#Attr.2):
let Str.315 : List Str = lowlevel StrGraphemes #Attr.2;
ret Str.315;
let Str.306 : List Str = lowlevel StrGraphemes #Attr.2;
ret Str.306;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
let Str.296 : U64 = 0i64;
let Str.297 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
let Str.293 : Int1 = StructAtIndex 2 Str.80;
if Str.293 then
let Str.295 : Str = StructAtIndex 1 Str.80;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
ret Str.294;
else
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
let Str.291 : U8 = StructAtIndex 3 Str.80;
let Str.292 : U64 = StructAtIndex 0 Str.80;
let #Derived_gen.40 : Str = StructAtIndex 1 Str.80;
dec #Derived_gen.40;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
ret Str.289;
procedure TotallyNotJson.100 (TotallyNotJson.850):
let TotallyNotJson.1479 : Str = "a";

34
crates/compiler/test_mono/generated/encode_derived_string.txt
View file

@ -166,30 +166,30 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.294;
procedure Str.12 (#Attr.2):
let Str.308 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.308;
let Str.299 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.299;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.298;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
let Str.296 : U64 = 0i64;
let Str.297 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
let Str.293 : Int1 = StructAtIndex 2 Str.80;
if Str.293 then
let Str.295 : Str = StructAtIndex 1 Str.80;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
ret Str.294;
else
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
let Str.291 : U8 = StructAtIndex 3 Str.80;
let Str.292 : U64 = StructAtIndex 0 Str.80;
let #Derived_gen.13 : Str = StructAtIndex 1 Str.80;
dec #Derived_gen.13;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
ret Str.289;
procedure TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1175, TotallyNotJson.181):
let TotallyNotJson.1178 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181;

34
crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt
View file

@ -251,30 +251,30 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.304;
procedure Str.12 (#Attr.2):
let Str.309 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.309;
let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.300;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.298;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
let Str.296 : U64 = 0i64;
let Str.297 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
let Str.293 : Int1 = StructAtIndex 2 Str.80;
if Str.293 then
let Str.295 : Str = StructAtIndex 1 Str.80;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
ret Str.294;
else
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
let Str.291 : U8 = StructAtIndex 3 Str.80;
let Str.292 : U64 = StructAtIndex 0 Str.80;
let #Derived_gen.34 : Str = StructAtIndex 1 Str.80;
dec #Derived_gen.34;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
ret Str.289;
procedure TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1216, TotallyNotJson.181):
let TotallyNotJson.1219 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181;

34
crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt
View file

@ -254,30 +254,30 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.304;
procedure Str.12 (#Attr.2):
let Str.309 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.309;
let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.300;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.298;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
let Str.296 : U64 = 0i64;
let Str.297 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
let Str.293 : Int1 = StructAtIndex 2 Str.80;
if Str.293 then
let Str.295 : Str = StructAtIndex 1 Str.80;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
ret Str.294;
else
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
let Str.291 : U8 = StructAtIndex 3 Str.80;
let Str.292 : U64 = StructAtIndex 0 Str.80;
let #Derived_gen.35 : Str = StructAtIndex 1 Str.80;
dec #Derived_gen.35;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
ret Str.289;
procedure TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1216, TotallyNotJson.181):
let TotallyNotJson.1219 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181;

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

@ -48,27 +48,27 @@ procedure Num.22 (#Attr.2, #Attr.3):
ret Num.292;
procedure Str.27 (Str.99):
let Str.298 : [C Int1, C I64] = CallByName Str.72 Str.99;
ret Str.298;
let Str.289 : [C Int1, C I64] = CallByName Str.72 Str.99;
ret Str.289;
procedure Str.47 (#Attr.2):
let Str.306 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.306;
let Str.297 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.297;
procedure Str.72 (Str.244):
let Str.245 : {I64, U8} = CallByName Str.47 Str.244;
dec Str.244;
let Str.304 : U8 = StructAtIndex 1 Str.245;
let Str.305 : U8 = 0i64;
let Str.301 : Int1 = CallByName Bool.11 Str.304 Str.305;
if Str.301 then
let Str.303 : I64 = StructAtIndex 0 Str.245;
let Str.302 : [C Int1, C I64] = TagId(1) Str.303;
ret Str.302;
procedure Str.72 (Str.235):
let Str.236 : {I64, U8} = CallByName Str.47 Str.235;
dec Str.235;
let Str.295 : U8 = StructAtIndex 1 Str.236;
let Str.296 : U8 = 0i64;
let Str.292 : Int1 = CallByName Bool.11 Str.295 Str.296;
if Str.292 then
let Str.294 : I64 = StructAtIndex 0 Str.236;
let Str.293 : [C Int1, C I64] = TagId(1) Str.294;
ret Str.293;
else
let Str.300 : Int1 = false;
let Str.299 : [C Int1, C I64] = TagId(0) Str.300;
ret Str.299;
let Str.291 : Int1 = false;
let Str.290 : [C Int1, C I64] = TagId(0) Str.291;
ret Str.290;
procedure Test.0 ():
let Test.3 : Int1 = CallByName Bool.2;

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

@ -232,26 +232,26 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.325;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.298;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
let Str.296 : U64 = 0i64;
let Str.297 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
let Str.293 : Int1 = StructAtIndex 2 Str.80;
if Str.293 then
let Str.295 : Str = StructAtIndex 1 Str.80;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
ret Str.294;
else
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
let Str.291 : U8 = StructAtIndex 3 Str.80;
let Str.292 : U64 = StructAtIndex 0 Str.80;
let #Derived_gen.6 : Str = StructAtIndex 1 Str.80;
dec #Derived_gen.6;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
ret Str.289;
procedure Test.3 ():
let Test.0 : List U8 = Array [82i64, 111i64, 99i64];

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

@ -206,53 +206,53 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.325;
procedure Str.12 (#Attr.2):
let Str.307 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.307;
procedure Str.27 (Str.99):
let Str.298 : [C {}, C I64] = CallByName Str.72 Str.99;
let Str.298 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.298;
procedure Str.27 (Str.99):
let Str.289 : [C {}, C I64] = CallByName Str.72 Str.99;
ret Str.289;
procedure Str.47 (#Attr.2):
let Str.306 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.306;
let Str.297 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.297;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.317 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.317;
let Str.308 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.308;
procedure Str.72 (Str.244):
let Str.245 : {I64, U8} = CallByName Str.47 Str.244;
dec Str.244;
let Str.304 : U8 = StructAtIndex 1 Str.245;
let Str.305 : U8 = 0i64;
let Str.301 : Int1 = CallByName Bool.11 Str.304 Str.305;
if Str.301 then
let Str.303 : I64 = StructAtIndex 0 Str.245;
let Str.302 : [C {}, C I64] = TagId(1) Str.303;
ret Str.302;
procedure Str.72 (Str.235):
let Str.236 : {I64, U8} = CallByName Str.47 Str.235;
dec Str.235;
let Str.295 : U8 = StructAtIndex 1 Str.236;
let Str.296 : U8 = 0i64;
let Str.292 : Int1 = CallByName Bool.11 Str.295 Str.296;
if Str.292 then
let Str.294 : I64 = StructAtIndex 0 Str.236;
let Str.293 : [C {}, C I64] = TagId(1) Str.294;
ret Str.293;
else
let Str.300 : {} = Struct {};
let Str.299 : [C {}, C I64] = TagId(0) Str.300;
ret Str.299;
let Str.291 : {} = Struct {};
let Str.290 : [C {}, C I64] = TagId(0) Str.291;
ret Str.290;
procedure Str.9 (Str.79):
let Str.315 : U64 = 0i64;
let Str.316 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.315 Str.316;
let Str.312 : Int1 = StructAtIndex 2 Str.80;
if Str.312 then
let Str.314 : Str = StructAtIndex 1 Str.80;
let Str.313 : [C {U64, U8}, C Str] = TagId(1) Str.314;
ret Str.313;
let Str.306 : U64 = 0i64;
let Str.307 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.306 Str.307;
let Str.303 : Int1 = StructAtIndex 2 Str.80;
if Str.303 then
let Str.305 : Str = StructAtIndex 1 Str.80;
let Str.304 : [C {U64, U8}, C Str] = TagId(1) Str.305;
ret Str.304;
else
let Str.310 : U8 = StructAtIndex 3 Str.80;
let Str.311 : U64 = StructAtIndex 0 Str.80;
let Str.301 : U8 = StructAtIndex 3 Str.80;
let Str.302 : U64 = StructAtIndex 0 Str.80;
let #Derived_gen.7 : Str = StructAtIndex 1 Str.80;
dec #Derived_gen.7;
let Str.309 : {U64, U8} = Struct {Str.311, Str.310};
let Str.308 : [C {U64, U8}, C Str] = TagId(0) Str.309;
ret Str.308;
let Str.300 : {U64, U8} = Struct {Str.302, Str.301};
let Str.299 : [C {U64, U8}, C Str] = TagId(0) Str.300;
ret Str.299;
procedure Test.0 ():
let Test.37 : Str = "-1234";

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

@ -31,12 +31,12 @@ procedure Num.22 (#Attr.2, #Attr.3):
ret Num.292;
procedure Str.16 (#Attr.2, #Attr.3):
let Str.298 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.298;
let Str.289 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.289;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.299 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.299;
let Str.290 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.290;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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

@ -31,8 +31,8 @@ procedure Num.22 (#Attr.2, #Attr.3):
ret Num.292;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.299 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.299;
let Str.290 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.290;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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

@ -3,8 +3,8 @@ procedure Bool.11 (#Attr.2, #Attr.3):
ret Bool.23;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.299 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.299;
let Str.290 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.290;
procedure Test.2 (Test.7):
let Test.24 : Str = ".trace(\"";

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

@ -3,8 +3,8 @@ procedure Num.20 (#Attr.2, #Attr.3):
ret Num.292;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.300 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.300;
let Str.291 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.291;
procedure Test.11 (Test.29, #Attr.12):
let Test.10 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;

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

@ -240,8 +240,8 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.304;
procedure Str.12 (#Attr.2):
let Str.299 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.299;
let Str.290 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.290;
procedure Test.2 (Test.10):
let Test.15 : {Str, Str} = CallByName Encode.23 Test.10;

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

@ -194,8 +194,8 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.313;
procedure Str.12 (#Attr.2):
let Str.299 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.299;
let Str.290 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.290;
procedure Test.2 (Test.11):
let Test.18 : {{}, {}} = CallByName Encode.23 Test.11;