Any -> Dynamic

Closes https://github.com/gleam-lang/stdlib/issues/8

10 files changed, 356 insertions, 147 deletions

diff --git a/gen/src/gleam@dynamic.erl b/gen/src/gleam@dynamic.erl
new file mode 100644
index 0000000..e20db87
--- /dev/null
+++ b/gen/src/gleam@dynamic.erl
@@ -0,0 +1,40 @@
+-module(gleam@dynamic).
+-compile(no_auto_import).
+
+-export([from/1, unsafe_coerce/1, string/1, int/1, float/1, atom/1, bool/1, thunk/1, list/2, field/2]).
+
+from(A) ->
+    gleam_stdlib:identity(A).
+
+unsafe_coerce(A) ->
+    gleam_stdlib:identity(A).
+
+string(A) ->
+    gleam_stdlib:decode_string(A).
+
+int(A) ->
+    gleam_stdlib:decode_int(A).
+
+float(A) ->
+    gleam_stdlib:decode_float(A).
+
+atom(A) ->
+    gleam_stdlib:decode_atom(A).
+
+bool(A) ->
+    gleam_stdlib:decode_bool(A).
+
+thunk(A) ->
+    gleam_stdlib:decode_thunk(A).
+
+list_dynamic(A) ->
+    gleam_stdlib:decode_list(A).
+
+list(Dynamic, DecoderType) ->
+    gleam@result:then(
+        list_dynamic(Dynamic),
+        fun(Capture1) -> gleam@list:traverse(Capture1, DecoderType) end
+    ).
+
+field(A, B) ->
+    gleam_stdlib:decode_field(A, B).
diff --git a/gen/src/gleam@list.erl b/gen/src/gleam@list.erl
index 586a5aa..1e19592 100644
--- a/gen/src/gleam@list.erl
+++ b/gen/src/gleam@list.erl
@@ -258,8 +258,8 @@ intersperse(List, Elem) ->
         [X] ->
             [X];
 
-        [X1 | Rest] ->
-            [X1, Elem | intersperse(Rest, Elem)]
+        [X | Rest] ->
+            [X, Elem | intersperse(Rest, Elem)]
     end.
 
 at(List, Index) ->
diff --git a/gen/test/gleam@dynamic_test.erl b/gen/test/gleam@dynamic_test.erl
new file mode 100644
index 0000000..d233dbc
--- /dev/null
+++ b/gen/test/gleam@dynamic_test.erl
@@ -0,0 +1,170 @@
+-module(gleam@dynamic_test).
+-compile(no_auto_import).
+
+-export([string_test/0, int_test/0, float_test/0, thunk_test/0, bool_test/0, atom_test/0, list_test/0, field_test/0]).
+
+string_test() ->
+    gleam@expect:equal(
+        gleam@dynamic:string(gleam@dynamic:from(<<"">>)),
+        {ok, <<"">>}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:string(gleam@dynamic:from(<<"Hello">>)),
+        {ok, <<"Hello">>}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:string(gleam@dynamic:from(1)),
+        {error, <<"Expected a String, got `1`">>}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:string(gleam@dynamic:from([])),
+        {error, <<"Expected a String, got `[]`">>}
+    ).
+
+int_test() ->
+    gleam@expect:equal(gleam@dynamic:int(gleam@dynamic:from(1)), {ok, 1}),
+    gleam@expect:equal(gleam@dynamic:int(gleam@dynamic:from(2)), {ok, 2}),
+    gleam@expect:equal(
+        gleam@dynamic:int(gleam@dynamic:from(1.0)),
+        {error, <<"Expected an Int, got `1.0`">>}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:int(gleam@dynamic:from([])),
+        {error, <<"Expected an Int, got `[]`">>}
+    ).
+
+float_test() ->
+    gleam@expect:equal(gleam@dynamic:float(gleam@dynamic:from(1.0)), {ok, 1.0}),
+    gleam@expect:equal(gleam@dynamic:float(gleam@dynamic:from(2.2)), {ok, 2.2}),
+    gleam@expect:equal(
+        gleam@dynamic:float(gleam@dynamic:from(1)),
+        {error, <<"Expected a Float, got `1`">>}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:float(gleam@dynamic:from([])),
+        {error, <<"Expected a Float, got `[]`">>}
+    ).
+
+thunk_test() ->
+    gleam@expect:is_ok(gleam@dynamic:thunk(gleam@dynamic:from(fun() -> 1 end))),
+    gleam@expect:equal(
+        gleam@result:map(
+            gleam@dynamic:thunk(gleam@dynamic:from(fun() -> 1 end)),
+            fun(F) -> F() end
+        ),
+        {ok, gleam@dynamic:from(1)}
+    ),
+    gleam@expect:is_error(
+        gleam@dynamic:thunk(gleam@dynamic:from(fun(X) -> X end))
+    ),
+    gleam@expect:is_error(gleam@dynamic:thunk(gleam@dynamic:from(1))),
+    gleam@expect:is_error(gleam@dynamic:thunk(gleam@dynamic:from([]))).
+
+bool_test() ->
+    gleam@expect:equal(
+        gleam@dynamic:bool(gleam@dynamic:from(true)),
+        {ok, true}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:bool(gleam@dynamic:from(false)),
+        {ok, false}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:bool(gleam@dynamic:from(1)),
+        {error, <<"Expected a Bool, got `1`">>}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:bool(gleam@dynamic:from([])),
+        {error, <<"Expected a Bool, got `[]`">>}
+    ).
+
+atom_test() ->
+    gleam@expect:equal(
+        gleam@dynamic:atom(
+            gleam@dynamic:from(gleam@atom:create_from_string(<<"">>))
+        ),
+        {ok, gleam@atom:create_from_string(<<"">>)}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:atom(
+            gleam@dynamic:from(gleam@atom:create_from_string(<<"ok">>))
+        ),
+        {ok, gleam@atom:create_from_string(<<"ok">>)}
+    ),
+    gleam@expect:is_error(gleam@dynamic:atom(gleam@dynamic:from(1))),
+    gleam@expect:is_error(gleam@dynamic:atom(gleam@dynamic:from([]))).
+
+list_test() ->
+    gleam@expect:equal(
+        gleam@dynamic:list(gleam@dynamic:from([]), fun gleam@dynamic:string/1),
+        {ok, []}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:list(gleam@dynamic:from([]), fun gleam@dynamic:int/1),
+        {ok, []}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:list(
+            gleam@dynamic:from([1, 2, 3]),
+            fun gleam@dynamic:int/1
+        ),
+        {ok, [1, 2, 3]}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:list(
+            gleam@dynamic:from([[1], [2], [3]]),
+            fun(Capture1) ->
+                gleam@dynamic:list(Capture1, fun gleam@dynamic:int/1)
+            end
+        ),
+        {ok, [[1], [2], [3]]}
+    ),
+    gleam@expect:is_error(
+        gleam@dynamic:list(gleam@dynamic:from(1), fun gleam@dynamic:string/1)
+    ),
+    gleam@expect:is_error(
+        gleam@dynamic:list(gleam@dynamic:from(1.0), fun gleam@dynamic:int/1)
+    ),
+    gleam@expect:is_error(
+        gleam@dynamic:list(
+            gleam@dynamic:from([<<"">>]),
+            fun gleam@dynamic:int/1
+        )
+    ),
+    gleam@expect:is_error(
+        gleam@dynamic:list(
+            gleam@dynamic:from(
+                [gleam@dynamic:from(1), gleam@dynamic:from(<<"not an int">>)]
+            ),
+            fun gleam@dynamic:int/1
+        )
+    ).
+
+field_test() ->
+    {ok, OkAtom} = gleam@atom:from_string(<<"ok">>),
+    {ok, ErrorAtom} = gleam@atom:from_string(<<"error">>),
+    gleam@expect:equal(
+        gleam@dynamic:field(
+            gleam@dynamic:from(gleam@map:insert(gleam@map:new(), OkAtom, 1)),
+            OkAtom
+        ),
+        {ok, gleam@dynamic:from(1)}
+    ),
+    gleam@expect:equal(
+        gleam@dynamic:field(
+            gleam@dynamic:from(
+                gleam@map:insert(
+                    gleam@map:insert(gleam@map:new(), OkAtom, 3),
+                    ErrorAtom,
+                    1
+                )
+            ),
+            OkAtom
+        ),
+        {ok, gleam@dynamic:from(3)}
+    ),
+    gleam@expect:is_error(
+        gleam@dynamic:field(gleam@dynamic:from(gleam@map:new()), OkAtom)
+    ),
+    gleam@expect:is_error(gleam@dynamic:field(gleam@dynamic:from(1), OkAtom)),
+    gleam@expect:is_error(gleam@dynamic:field(gleam@dynamic:from([]), [])).
diff --git a/gen/test/gleam@list_test.erl b/gen/test/gleam@list_test.erl
index 6281c9e..42588da 100644
--- a/gen/test/gleam@list_test.erl
+++ b/gen/test/gleam@list_test.erl
@@ -42,14 +42,14 @@ filter_test() ->
         [5, 7]
     ),
     gleam@expect:equal(
-        gleam@list:filter([0, 4, 5, 7, 3], fun(X) -> X < 4 end),
+        gleam@list:filter([0, 4, 5, 7, 3], fun(X1) -> X1 < 4 end),
         [0, 3]
     ).
 
 map_test() ->
     gleam@expect:equal(gleam@list:map([], fun(X) -> X * 2 end), []),
     gleam@expect:equal(
-        gleam@list:map([0, 4, 5, 7, 3], fun(X) -> X * 2 end),
+        gleam@list:map([0, 4, 5, 7, 3], fun(X1) -> X1 * 2 end),
         [0, 8, 10, 14, 6]
     ).
 
@@ -126,7 +126,7 @@ all_test() ->
         true
     ),
     gleam@expect:equal(
-        gleam@list:all([1, 2, 3, 4, 5], fun(X) -> X < 0 end),
+        gleam@list:all([1, 2, 3, 4, 5], fun(X1) -> X1 < 0 end),
         false
     ),
     gleam@expect:equal(gleam@list:all([], fun(_) -> false end), true).
@@ -137,7 +137,7 @@ any_test() ->
         true
     ),
     gleam@expect:equal(
-        gleam@list:any([1, 2, 3, 4, 5], fun(X) -> X < 0 end),
+        gleam@list:any([1, 2, 3, 4, 5], fun(X1) -> X1 < 0 end),
         false
     ),
     gleam@expect:equal(gleam@list:any([], fun(_) -> false end), false).
@@ -216,7 +216,7 @@ index_map_test() ->
         gleam@list:index_map([3, 4, 5], fun(I, X) -> {I, X} end),
         [{0, 3}, {1, 4}, {2, 5}]
     ),
-    F = fun(I, X) -> gleam@string:append(X, gleam@int:to_string(I)) end,
+    F = fun(I1, X1) -> gleam@string:append(X1, gleam@int:to_string(I1)) end,
     gleam@expect:equal(
         gleam@list:index_map([<<"a">>, <<"b">>, <<"c">>], F),
         [<<"a0">>, <<"b1">>, <<"c2">>]
@@ -268,19 +268,19 @@ split_while_test() ->
         {[], []}
     ),
     gleam@expect:equal(
-        gleam@list:split_while([1, 2, 3, 4, 5], fun(X) -> X =< 5 end),
+        gleam@list:split_while([1, 2, 3, 4, 5], fun(X1) -> X1 =< 5 end),
         {[1, 2, 3, 4, 5], []}
     ),
     gleam@expect:equal(
-        gleam@list:split_while([1, 2, 3, 4, 5], fun(X) -> X =:= 2 end),
+        gleam@list:split_while([1, 2, 3, 4, 5], fun(X2) -> X2 =:= 2 end),
         {[], [1, 2, 3, 4, 5]}
     ),
     gleam@expect:equal(
-        gleam@list:split_while([1, 2, 3, 4, 5], fun(X) -> X =< 3 end),
+        gleam@list:split_while([1, 2, 3, 4, 5], fun(X3) -> X3 =< 3 end),
         {[1, 2, 3], [4, 5]}
     ),
     gleam@expect:equal(
-        gleam@list:split_while([1, 2, 3, 4, 5], fun(X) -> X =< -3 end),
+        gleam@list:split_while([1, 2, 3, 4, 5], fun(X4) -> X4 =< -3 end),
         {[], [1, 2, 3, 4, 5]}
     ).
 
diff --git a/gen/test/gleam@map_test.erl b/gen/test/gleam@map_test.erl
index 5409e85..50dba1a 100644
--- a/gen/test/gleam@map_test.erl
+++ b/gen/test/gleam@map_test.erl
@@ -145,6 +145,6 @@ fold_test() ->
     ),
     Add = fun(_, V, Acc) -> V + Acc end,
     gleam@expect:equal(gleam@map:fold(Dict, 0, Add), 6),
-    Concat = fun(K, _, Acc) -> gleam@string:append(Acc, K) end,
+    Concat = fun(K, _, Acc1) -> gleam@string:append(Acc1, K) end,
     gleam@expect:equal(gleam@map:fold(Dict, <<"">>, Concat), <<"abcd">>),
     gleam@expect:equal(gleam@map:fold(gleam@map:from_list([]), 0, Add), 0).
diff --git a/gen/test/gleam@result_test.erl b/gen/test/gleam@result_test.erl
index ee32547..ae6b760 100644
--- a/gen/test/gleam@result_test.erl
+++ b/gen/test/gleam@result_test.erl
@@ -18,7 +18,7 @@ map_test() ->
         {ok, <<"2">>}
     ),
     gleam@expect:equal(
-        gleam@result:map({error, 1}, fun(X) -> X + 1 end),
+        gleam@result:map({error, 1}, fun(X1) -> X1 + 1 end),
         {error, 1}
     ).
 
@@ -28,7 +28,7 @@ map_error_test() ->
         {ok, 1}
     ),
     gleam@expect:equal(
-        gleam@result:map_error({error, 1}, fun(X) -> {<<"ok">>, X + 1} end),
+        gleam@result:map_error({error, 1}, fun(X1) -> {<<"ok">>, X1 + 1} end),
         {error, {<<"ok">>, 2}}
     ).
 
@@ -47,7 +47,7 @@ then_test() ->
         {error, 1}
     ),
     gleam@expect:equal(
-        gleam@result:then({ok, 1}, fun(X) -> {ok, X + 1} end),
+        gleam@result:then({ok, 1}, fun(X1) -> {ok, X1 + 1} end),
         {ok, 2}
     ),
     gleam@expect:equal(
diff --git a/src/gleam/any.gleam b/src/gleam/any.gleam
deleted file mode 100644
index a54f632..0000000
--- a/src/gleam/any.gleam
+++ /dev/null
@@ -1,50 +0,0 @@
-import gleam/list as list_mod
-import gleam/atom
-import gleam/result
-
-// `Any` data is data that we don"t know the type of yet.
-// We likely get data like this from interop with Erlang, or from
-// IO with the outside world.
-//
-pub external type Any;
-
-// Convert any Gleam data into `Any` data.
-//
-pub external fn from(a) -> Any = "gleam_stdlib" "identity";
-
-// Unsafely cast any type into any other type.
-//
-// This is an escape hatch for the type system that may be useful when wrapping
-// native Erlang APIs. It is to be used as a last measure only.
-//
-pub external fn unsafe_coerce(a) -> b = "gleam_stdlib" "identity";
-
-pub external fn string(from: Any) -> Result(String, String)
-  = "gleam_stdlib" "decode_string"
-
-pub external fn int(from: Any) -> Result(Int, String)
-  = "gleam_stdlib" "decode_int"
-
-pub external fn float(from: Any) -> Result(Float, String)
-  = "gleam_stdlib" "decode_float"
-
-pub external fn atom(from: Any) -> Result(atom.Atom, String)
-  = "gleam_stdlib" "decode_atom"
-
-pub external fn bool(from: Any) -> Result(Bool, String)
-  = "gleam_stdlib" "decode_bool"
-
-pub external fn thunk(from: Any) -> Result(fn() -> Any, String)
-  = "gleam_stdlib" "decode_thunk"
-
-external fn list_any(from: Any) -> Result(List(Any), String)
-  = "gleam_stdlib" "decode_list"
-
-pub fn list(from any, containing decoder_type) {
-  any
-  |> list_any
-  |> result.then(_, list_mod.traverse(_, decoder_type))
-}
-
-pub external fn field(from: Any, named: a) -> Result(Any, String)
-  = "gleam_stdlib" "decode_field"
diff --git a/src/gleam/dynamic.gleam b/src/gleam/dynamic.gleam
new file mode 100644
index 0000000..8086aeb
--- /dev/null
+++ b/src/gleam/dynamic.gleam
@@ -0,0 +1,50 @@
+import gleam/list as list_mod
+import gleam/atom
+import gleam/result
+
+// `Dynamic` data is data that we don"t know the type of yet.
+// We likely get data like this from interop with Erlang, or from
+// IO with the outside world.
+//
+pub external type Dynamic;
+
+// Convert any Gleam data into `Dynamic` data.
+//
+pub external fn from(a) -> Dynamic = "gleam_stdlib" "identity";
+
+// Unsafely cast a Dynamic value into any other type.
+//
+// This is an escape hatch for the type system that may be useful when wrapping
+// native Erlang APIs. It is to be used as a last measure only.
+//
+pub external fn unsafe_coerce(a) -> b = "gleam_stdlib" "identity";
+
+pub external fn string(from: Dynamic) -> Result(String, String)
+  = "gleam_stdlib" "decode_string"
+
+pub external fn int(from: Dynamic) -> Result(Int, String)
+  = "gleam_stdlib" "decode_int"
+
+pub external fn float(from: Dynamic) -> Result(Float, String)
+  = "gleam_stdlib" "decode_float"
+
+pub external fn atom(from: Dynamic) -> Result(atom.Atom, String)
+  = "gleam_stdlib" "decode_atom"
+
+pub external fn bool(from: Dynamic) -> Result(Bool, String)
+  = "gleam_stdlib" "decode_bool"
+
+pub external fn thunk(from: Dynamic) -> Result(fn() -> Dynamic, String)
+  = "gleam_stdlib" "decode_thunk"
+
+external fn list_dynamic(from: Dynamic) -> Result(List(Dynamic), String)
+  = "gleam_stdlib" "decode_list"
+
+pub fn list(from dynamic, containing decoder_type) {
+  dynamic
+  |> list_dynamic
+  |> result.then(_, list_mod.traverse(_, decoder_type))
+}
+
+pub external fn field(from: Dynamic, named: a) -> Result(Dynamic, String)
+  = "gleam_stdlib" "decode_field"
diff --git a/src/gleam/map.gleam b/src/gleam/map.gleam
index 4f11f89..d103d01 100644
--- a/src/gleam/map.gleam
+++ b/src/gleam/map.gleam
@@ -1,4 +1,3 @@
-import gleam/any
 import gleam/result
 import gleam/list
 
diff --git a/test/gleam/any_test.gleam b/test/gleam/dynamic_test.gleam
index dc0c859..f840ce8 100644
--- a/test/gleam/any_test.gleam
+++ b/test/gleam/dynamic_test.gleam
@@ -1,4 +1,4 @@
-import gleam/any
+import gleam/dynamic
 import gleam/atom
 import gleam/list
 import gleam/expect
@@ -7,183 +7,183 @@ import gleam/map
 
 pub fn string_test() {
   ""
-  |> any.from
-  |> any.string
+  |> dynamic.from
+  |> dynamic.string
   |> expect.equal(_, Ok(""))
 
   "Hello"
-  |> any.from
-  |> any.string
+  |> dynamic.from
+  |> dynamic.string
   |> expect.equal(_, Ok("Hello"))
 
   1
-  |> any.from
-  |> any.string
+  |> dynamic.from
+  |> dynamic.string
   |> expect.equal(_, Error("Expected a String, got `1`"))
 
   []
-  |> any.from
-  |> any.string
+  |> dynamic.from
+  |> dynamic.string
   |> expect.equal(_, Error("Expected a String, got `[]`"))
 }
 
 pub fn int_test() {
   1
-  |> any.from
-  |> any.int
+  |> dynamic.from
+  |> dynamic.int
   |> expect.equal(_, Ok(1))
 
   2
-  |> any.from
-  |> any.int
+  |> dynamic.from
+  |> dynamic.int
   |> expect.equal(_, Ok(2))
 
   1.0
-  |> any.from
-  |> any.int
+  |> dynamic.from
+  |> dynamic.int
   |> expect.equal(_, Error("Expected an Int, got `1.0`"))
 
   []
-  |> any.from
-  |> any.int
+  |> dynamic.from
+  |> dynamic.int
   |> expect.equal(_, Error("Expected an Int, got `[]`"))
 }
 
 pub fn float_test() {
   1.0
-  |> any.from
-  |> any.float
+  |> dynamic.from
+  |> dynamic.float
   |> expect.equal(_, Ok(1.0))
 
   2.2
-  |> any.from
-  |> any.float
+  |> dynamic.from
+  |> dynamic.float
   |> expect.equal(_, Ok(2.2))
 
   1
-  |> any.from
-  |> any.float
+  |> dynamic.from
+  |> dynamic.float
   |> expect.equal(_, Error("Expected a Float, got `1`"))
 
   []
-  |> any.from
-  |> any.float
+  |> dynamic.from
+  |> dynamic.float
   |> expect.equal(_, Error("Expected a Float, got `[]`"))
 }
 
 pub fn thunk_test() {
   fn() { 1 }
-  |> any.from
-  |> any.thunk
+  |> dynamic.from
+  |> dynamic.thunk
   |> expect.is_ok
 
   fn() { 1 }
-  |> any.from
-  |> any.thunk
+  |> dynamic.from
+  |> dynamic.thunk
   |> result.map(_, fn(f) { f() })
-  |> expect.equal(_, Ok(any.from(1)))
+  |> expect.equal(_, Ok(dynamic.from(1)))
 
   fn(x) { x }
-  |> any.from
-  |> any.thunk
+  |> dynamic.from
+  |> dynamic.thunk
   |> expect.is_error
 
   1
-  |> any.from
-  |> any.thunk
+  |> dynamic.from
+  |> dynamic.thunk
   |> expect.is_error
 
   []
-  |> any.from
-  |> any.thunk
+  |> dynamic.from
+  |> dynamic.thunk
   |> expect.is_error
 }
 
 pub fn bool_test() {
   True
-  |> any.from
-  |> any.bool
+  |> dynamic.from
+  |> dynamic.bool
   |> expect.equal(_, Ok(True))
 
   False
-  |> any.from
-  |> any.bool
+  |> dynamic.from
+  |> dynamic.bool
   |> expect.equal(_, Ok(False))
 
   1
-  |> any.from
-  |> any.bool
+  |> dynamic.from
+  |> dynamic.bool
   |> expect.equal(_, Error("Expected a Bool, got `1`"))
 
   []
-  |> any.from
-  |> any.bool
+  |> dynamic.from
+  |> dynamic.bool
   |> expect.equal(_, Error("Expected a Bool, got `[]`"))
 }
 
 pub fn atom_test() {
   ""
     |> atom.create_from_string
-    |> any.from
-    |> any.atom
+    |> dynamic.from
+    |> dynamic.atom
     |> expect.equal(_, Ok(atom.create_from_string("")))
 
   "ok"
     |> atom.create_from_string
-    |> any.from
-    |> any.atom
+    |> dynamic.from
+    |> dynamic.atom
     |> expect.equal(_, Ok(atom.create_from_string("ok")))
 
   1
-    |> any.from
-    |> any.atom
+    |> dynamic.from
+    |> dynamic.atom
     |> expect.is_error
 
   []
-    |> any.from
-    |> any.atom
+    |> dynamic.from
+    |> dynamic.atom
     |> expect.is_error
 }
 
 pub fn list_test() {
   []
-  |> any.from
-  |> any.list(_, any.string)
+  |> dynamic.from
+  |> dynamic.list(_, dynamic.string)
   |> expect.equal(_, Ok([]))
 
   []
-  |> any.from
-  |> any.list(_, any.int)
+  |> dynamic.from
+  |> dynamic.list(_, dynamic.int)
   |> expect.equal(_, Ok([]))
 
   [1, 2, 3]
-  |> any.from
-  |> any.list(_, any.int)
+  |> dynamic.from
+  |> dynamic.list(_, dynamic.int)
   |> expect.equal(_, Ok([1, 2, 3]))
 
   [[1], [2], [3]]
-  |> any.from
-  |> any.list(_, any.list(_, any.int))
+  |> dynamic.from
+  |> dynamic.list(_, dynamic.list(_, dynamic.int))
   |> expect.equal(_, Ok([[1], [2], [3]]))
 
   1
-  |> any.from
-  |> any.list(_, any.string)
+  |> dynamic.from
+  |> dynamic.list(_, dynamic.string)
   |> expect.is_error
 
   1.0
-  |> any.from
-  |> any.list(_, any.int)
+  |> dynamic.from
+  |> dynamic.list(_, dynamic.int)
   |> expect.is_error
 
   [""]
-  |> any.from
-  |> any.list(_, any.int)
+  |> dynamic.from
+  |> dynamic.list(_, dynamic.int)
   |> expect.is_error
 
-  [any.from(1), any.from("not an int")]
-  |> any.from
-  |> any.list(_, any.int)
+  [dynamic.from(1), dynamic.from("not an int")]
+  |> dynamic.from
+  |> dynamic.list(_, dynamic.int)
   |> expect.is_error
 }
 
@@ -195,29 +195,29 @@ pub fn field_test() {
 
   map.new()
   |> map.insert(_, ok_atom, 1)
-  |> any.from
-  |> any.field(_, ok_atom)
-  |> expect.equal(_, Ok(any.from(1)))
+  |> dynamic.from
+  |> dynamic.field(_, ok_atom)
+  |> expect.equal(_, Ok(dynamic.from(1)))
 
   map.new()
   |> map.insert(_, ok_atom, 3)
   |> map.insert(_, error_atom, 1)
-  |> any.from
-  |> any.field(_, ok_atom)
-  |> expect.equal(_, Ok(any.from(3)))
+  |> dynamic.from
+  |> dynamic.field(_, ok_atom)
+  |> expect.equal(_, Ok(dynamic.from(3)))
 
   map.new()
-  |> any.from
-  |> any.field(_, ok_atom)
+  |> dynamic.from
+  |> dynamic.field(_, ok_atom)
   |> expect.is_error
 
   1
-  |> any.from
-  |> any.field(_, ok_atom)
+  |> dynamic.from
+  |> dynamic.field(_, ok_atom)
   |> expect.is_error
 
   []
-  |> any.from
-  |> any.field(_, [])
+  |> dynamic.from
+  |> dynamic.field(_, [])
   |> expect.is_error
 }