Update stdlib for new struct syntax

7 files changed, 43 insertions, 43 deletions

diff --git a/src/gleam/any.gleam b/src/gleam/any.gleam
index 44e2dd8..ae26bc5 100644
--- a/src/gleam/any.gleam
+++ b/src/gleam/any.gleam
@@ -46,8 +46,8 @@ pub fn list(any, decode) {
   |> result:then(_, list_mod:traverse(_, decode))
 }
 
-pub external fn tuple(Any) -> Result({Any, Any}, String)
-  = "gleam__stdlib" "decode_tuple"
+pub external fn struct2(Any) -> Result(struct(Any, Any), String)
+  = "gleam__stdlib" "decode_struct2"
 
 pub external fn field(Any, a) -> Result(Any, String)
   = "gleam__stdlib" "decode_field"
diff --git a/src/gleam/bool.gleam b/src/gleam/bool.gleam
index e99333b..f003691 100644
--- a/src/gleam/bool.gleam
+++ b/src/gleam/bool.gleam
@@ -8,11 +8,11 @@ pub fn negate(bool) {
 }
 
 pub fn compare(a, b) {
-  case {a, b} {
-  | {True, True} -> order:Eq
-  | {True, False} -> order:Gt
-  | {False, False} -> order:Eq
-  | {False, True} -> order:Lt
+  case struct(a, b) {
+  | struct(True, True) -> order:Eq
+  | struct(True, False) -> order:Gt
+  | struct(False, False) -> order:Eq
+  | struct(False, True) -> order:Lt
   }
 }
 
diff --git a/src/gleam/list.gleam b/src/gleam/list.gleam
index 24437c6..f0adb44 100644
--- a/src/gleam/list.gleam
+++ b/src/gleam/list.gleam
@@ -179,7 +179,7 @@ pub fn all(list, f) {
 pub fn any(list, f) {
   case list {
     | [] -> False
-    | [ x | rest] ->
+    | [x | rest] ->
       case f(x) {
       | False -> any(rest, f)
       | _ -> True
@@ -188,10 +188,10 @@ pub fn any(list, f) {
 }
 
 pub fn zip(l1, l2) {
-  case {l1, l2} {
-    | {[], _} -> []
-    | {_, []} -> []
-    | {[x1 | rest1], [x2 | rest2] } -> [ {x1, x2} | zip(rest1, rest2) ]
+  case struct(l1, l2) {
+    | struct([], _) -> []
+    | struct(_, []) -> []
+    | struct([x1 | rest1], [x2 | rest2]) -> [ struct(x1, x2) | zip(rest1, rest2) ]
   }
 }
 
@@ -233,10 +233,10 @@ pub fn unique(list) {
 }
 
 fn merge_sort(a, b, compare) {
-  case {a, b} {
-    | {[], _} -> b
-    | {_, []} -> a
-    | {[ax | ar], [bx | br]} ->
+  case struct(a, b) {
+    | struct([], _) -> b
+    | struct(_, []) -> a
+    | struct([ax | ar], [bx | br]) ->
       case compare(ax, bx) {
       | order:Lt -> [ax | merge_sort(ar, b, compare)]
       | _ -> [bx | merge_sort(a, br, compare)]
@@ -284,10 +284,10 @@ pub fn repeat(a, times) {
 
 fn do_split(list, n, taken) {
   case n <= 0 {
-  | True -> {reverse(taken), list}
+  | True -> struct(reverse(taken), list)
   | False ->
       case list {
-      | [] -> {reverse(taken), []}
+      | [] -> struct(reverse(taken), [])
       | [x | xs] -> do_split(xs, n - 1, [x | taken])
       }
   }
@@ -299,10 +299,10 @@ pub fn split(list, n) {
 
 fn do_split_while(list, f, acc) {
   case list {
-    | [] -> {reverse(acc), []}
+    | [] -> struct(reverse(acc), [])
     | [x | xs] ->
       case f(x) {
-      | False -> {reverse(acc), list}
+      | False -> struct(reverse(acc), list)
       | _ -> do_split_while(xs, f, [x | acc])
       }
   }
diff --git a/src/gleam/map_dict.gleam b/src/gleam/map_dict.gleam
index bf3ed87..e77e861 100644
--- a/src/gleam/map_dict.gleam
+++ b/src/gleam/map_dict.gleam
@@ -10,10 +10,10 @@ pub enum NotFound =
 pub external fn size(MapDict(k, v)) -> Int
   = "maps" "size"
 
-pub external fn to_list(MapDict(key, value)) -> List({key, value})
+pub external fn to_list(MapDict(key, value)) -> List(struct(key, value))
   = "maps" "to_list"
 
-pub external fn from_list(List({key, value})) -> MapDict(key, value)
+pub external fn from_list(List(struct(key, value))) -> MapDict(key, value)
   = "maps" "from_list"
 
 external fn is_key(key, MapDict(key, v)) -> Bool
@@ -90,7 +90,7 @@ pub fn update(dict, key, f) {
 fn do_fold(list, acc, f) {
   case list {
     | [] -> acc
-    | [{k, v} | tail] -> do_fold(tail, f(k, v, acc), f)
+    | [struct(k, v) | tail] -> do_fold(tail, f(k, v, acc), f)
   }
 }
 
diff --git a/src/gleam/order.gleam b/src/gleam/order.gleam
index 4d39705..48a4b40 100644
--- a/src/gleam/order.gleam
+++ b/src/gleam/order.gleam
@@ -21,28 +21,28 @@ pub fn to_int(order) {
 }
 
 pub fn compare(a, b) {
-  case {a, b} {
-  | {Lt, Lt} -> Eq
-  | {Lt, _} -> Lt
-  | {Eq, Eq} -> Eq
-  | {Gt, Gt} -> Eq
-  | {Eq, Gt} -> Lt
+  case struct(a, b) {
+  | struct(Lt, Lt) -> Eq
+  | struct(Lt, _) -> Lt
+  | struct(Eq, Eq) -> Eq
+  | struct(Gt, Gt) -> Eq
+  | struct(Eq, Gt) -> Lt
   | _ -> Gt
   }
 }
 
 pub fn max(a, b) {
-  case {a, b} {
-  | {Gt, _} -> Gt
-  | {Eq, Lt} -> Eq
+  case struct(a, b) {
+  | struct(Gt, _) -> Gt
+  | struct(Eq, Lt) -> Eq
   | _ -> b
   }
 }
 
 pub fn min(a, b) {
-  case {a, b} {
-  | {Lt, _} -> Lt
-  | {Eq, Gt} -> Eq
+  case struct(a, b) {
+  | struct(Lt, _) -> Lt
+  | struct(Eq, Gt) -> Eq
   | _ -> b
   }
 }
diff --git a/src/gleam/tuple.gleam b/src/gleam/tuple.gleam
index 05968d0..5260682 100644
--- a/src/gleam/tuple.gleam
+++ b/src/gleam/tuple.gleam
@@ -1,22 +1,22 @@
 import gleam/list
 
 pub fn new(a, b) {
-  {a, b}
+  struct(a, b)
 }
 
 pub fn first(tup) {
-  let {a, _} = tup
+  let struct(a, _) = tup
   a
 }
 
 pub fn second(tup) {
-  let {_, a} = tup
+  let struct(_, a) = tup
   a
 }
 
 pub fn swap(tup) {
-  let {a, b} = tup
-  {b, a}
+  let struct(a, b) = tup
+  struct(b, a)
 }
 
 pub fn fetch(haystack, needle) {
diff --git a/src/gleam__stdlib.erl b/src/gleam__stdlib.erl
index 5640e70..8434082 100644
--- a/src/gleam__stdlib.erl
+++ b/src/gleam__stdlib.erl
@@ -6,7 +6,7 @@
          atom_create_from_string/1, atom_to_string/1, map_fetch/2,
          iodata_append/2, iodata_prepend/2, identity/1, decode_int/1,
          decode_string/1, decode_bool/1, decode_float/1, decode_thunk/1, decode_atom/1,
-         decode_tuple/1, decode_list/1, decode_field/2, parse_int/1, parse_float/1]).
+         decode_struct2/1, decode_list/1, decode_field/2, parse_int/1, parse_float/1]).
 
 expect_equal(Actual, Expected) -> ?assertEqual(Expected, Actual).
 expect_not_equal(Actual, Expected) -> ?assertNotEqual(Expected, Actual).
@@ -58,8 +58,8 @@ decode_bool(Data) -> decode_error_msg("a Bool", Data).
 decode_thunk(Data) when is_function(Data, 0) -> {ok, Data};
 decode_thunk(Data) -> decode_error_msg("a zero arity function", Data).
 
-decode_tuple(Data = {_, _}) -> {ok, Data};
-decode_tuple(Data) -> decode_error_msg("a 2 element tuple", Data).
+decode_struct2(Data = {_, _}) -> {ok, Data};
+decode_struct2(Data) -> decode_error_msg("a 2 element struct", Data).
 
 decode_list(Data) when is_list(Data) -> {ok, Data};
 decode_list(Data) -> decode_error_msg("a List", Data).