stdlib atom

4 files changed, 87 insertions, 5 deletions

diff --git a/src/atom.gleam b/src/atom.gleam
new file mode 100644
index 0000000..e887a01
--- /dev/null
+++ b/src/atom.gleam
@@ -0,0 +1,64 @@
+import expect
+
+pub external type Atom;
+
+pub enum AtomNotLoaded =
+  | AtomNotLoaded
+
+pub external fn from_string(String) -> Result(Atom, AtomNotLoaded) =
+  "gleam__stdlib" "atom_from_string";
+
+test from_string {
+  "ok"
+  |> from_string
+  |> expect:is_ok
+
+  "expect"
+  |> from_string
+  |> expect:is_ok
+
+  "this is not an atom we have seen before"
+  |> from_string
+  |> expect:equal(_, Error(AtomNotLoaded))
+}
+
+// This function can create a new atom if one does not already exist for
+// the given string. Atoms are not garbage collected so this can result
+// in a memory leak if called over time on new values
+//
+pub external fn create_from_string(String) -> Atom =
+  "gleam__stdlib" "atom_create_from_string";
+
+test create_from_string {
+  let ok = fn(x) { Ok(x) }
+
+  "ok"
+  |> create_from_string
+  |> ok
+  |> expect:equal(_, from_string("ok"))
+
+  "expect"
+  |> create_from_string
+  |> ok
+  |> expect:equal(_, from_string("expect"))
+
+  "this is another atom we have not seen before"
+  |> create_from_string
+  |> ok
+  |> expect:equal(_, from_string("this is another atom we have not seen before"))
+}
+
+pub external fn to_string(Atom) -> String =
+  "gleam__stdlib" "atom_to_string";
+
+test to_string {
+  "ok"
+  |> create_from_string
+  |> to_string
+  |> expect:equal(_, "ok")
+
+  "expect"
+  |> create_from_string
+  |> to_string
+  |> expect:equal(_, "expect")
+}
diff --git a/src/expect.gleam b/src/expect.gleam
index a597d9a..5ea6a93 100644
--- a/src/expect.gleam
+++ b/src/expect.gleam
@@ -11,6 +11,10 @@ pub external fn true(Bool) -> Expectation = "gleam__stdlib" "expect_true";
 
 pub external fn false(Bool) -> Expectation = "gleam__stdlib" "expect_false";
 
+pub external fn is_ok(Result(a, b)) -> Expectation = "gleam__stdlib" "expect_is_ok";
+
+pub external fn is_error(Result(a, b)) -> Expectation = "gleam__stdlib" "expect_is_error";
+
 pub fn fail() {
   true(False)
 }
diff --git a/src/gleam__stdlib.erl b/src/gleam__stdlib.erl
index 25abb25..24668a7 100644
--- a/src/gleam__stdlib.erl
+++ b/src/gleam__stdlib.erl
@@ -1,13 +1,16 @@
 -module(gleam__stdlib).
 -include_lib("eunit/include/eunit.hrl").
 
--export([expect_equal/2, expect_not_equal/2, expect_true/1, expect_false/1, map_fetch/2,
-         iodata_append/2, iodata_prepend/2, identity/1]).
+-export([expect_equal/2, expect_not_equal/2, expect_true/1, expect_false/1, expect_is_ok/1,
+         expect_is_error/1, atom_from_string/1, atom_create_from_string/1, atom_to_string/1,
+         map_fetch/2, iodata_append/2, iodata_prepend/2, identity/1]).
 
 expect_equal(A, Expected) -> ?assertEqual(Expected, A).
 expect_not_equal(A, Expected) -> ?assertNotEqual(Expected, A).
 expect_true(A) -> ?assert(A).
 expect_false(A) -> ?assertNot(A).
+expect_is_ok(A) -> ?assertMatch({ok, _}, A).
+expect_is_error(A) -> ?assertMatch({error, _}, A).
 
 map_fetch(Map, Key) ->
   case maps:find(Key, Map) of
@@ -15,6 +18,17 @@ map_fetch(Map, Key) ->
     OkFound -> OkFound
   end.
 
+atom_create_from_string(S) ->
+  binary_to_atom(S, utf8).
+
+atom_to_string(S) ->
+  atom_to_binary(S, utf8).
+
+atom_from_string(S) ->
+  try {ok, binary_to_existing_atom(S, utf8)} catch
+    error:badarg -> {error, atom_not_loaded}
+  end.
+
 iodata_append(Iodata, String) -> [Iodata, String].
 iodata_prepend(Iodata, String) -> [String, Iodata].
 
diff --git a/src/list.gleam b/src/list.gleam
index 527ec51..6687acf 100644
--- a/src/list.gleam
+++ b/src/list.gleam
@@ -97,11 +97,11 @@ pub fn filter(list, fun) {
 
 test filter {
   []
-    |> filter(_, fn(x) { True })
+    |> filter(_, fn(_) { True })
     |> expect:equal(_, [])
 
   [0, 4, 5, 7, 3]
-    |> filter(_, fn(x) { True })
+    |> filter(_, fn(_) { True })
     |> expect:equal(_, [0, 4, 5, 7, 3])
 
   [0, 4, 5, 7, 3]
@@ -173,7 +173,7 @@ pub fn drop(list, n) {
   | False ->
       case list {
       | [] -> []
-      | [x | xs] -> drop(xs, n - 1)
+      | [_ | xs] -> drop(xs, n - 1)
       }
   }
 }