Gleam fix

6 files changed, 353 insertions, 359 deletions

diff --git a/test/gleam/bit_string_test.gleam b/test/gleam/bit_string_test.gleam
index 581cc1c..67e791b 100644
--- a/test/gleam/bit_string_test.gleam
+++ b/test/gleam/bit_string_test.gleam
@@ -28,12 +28,11 @@ pub fn append_test() {
   |> should.equal(<<1, 2, 3, 4>>)
 }
 
-if erlang {
-  pub fn append_erlang_only_test() {
-    <<1, 2:4>>
-    |> bit_string.append(<<3>>)
-    |> should.equal(<<1, 2:4, 3>>)
-  }
+@target(erlang)
+pub fn append_erlang_only_test() {
+  <<1, 2:4>>
+  |> bit_string.append(<<3>>)
+  |> should.equal(<<1, 2:4, 3>>)
 }
 
 pub fn concat_test() {
@@ -46,12 +45,11 @@ pub fn concat_test() {
   |> should.equal(<<1, 2, 3, 4>>)
 }
 
-if erlang {
-  pub fn concat_erlang_only_test() {
-    [<<1, 2:4>>, <<3>>]
-    |> bit_string.concat
-    |> should.equal(<<1, 2:4, 3>>)
-  }
+@target(erlang)
+pub fn concat_erlang_only_test() {
+  [<<1, 2:4>>, <<3>>]
+  |> bit_string.concat
+  |> should.equal(<<1, 2:4, 3>>)
 }
 
 pub fn slice_test() {
diff --git a/test/gleam/dynamic_test.gleam b/test/gleam/dynamic_test.gleam
index 87eef32..ab25fb8 100644
--- a/test/gleam/dynamic_test.gleam
+++ b/test/gleam/dynamic_test.gleam
@@ -30,54 +30,49 @@ pub fn bit_string_test() {
   ]))
 }
 
-if erlang {
-  pub fn bit_string_erlang_test() {
-    <<65_535:16>>
-    |> dynamic.from
-    |> dynamic.bit_string
-    |> should.equal(Ok(<<65_535:16>>))
-  }
+@target(erlang)
+pub fn bit_string_erlang_test() {
+  <<65_535:16>>
+  |> dynamic.from
+  |> dynamic.bit_string
+  |> should.equal(Ok(<<65_535:16>>))
 }
 
-if javascript {
-  external fn uint8array(List(Int)) -> dynamic.Dynamic =
-    "../gleam_stdlib_test_ffi.mjs" "uint8array"
+@target(javascript)
+@external(javascript, "../gleam_stdlib_test_ffi.mjs", "uint8array")
+fn uint8array(a: List(Int)) -> dynamic.Dynamic
 
-  pub fn bit_string_erlang_test() {
-    [1, 1, 2, 3, 5, 8]
-    |> uint8array
-    |> dynamic.bit_string
-    |> should.equal(Ok(<<1, 1, 2, 3, 5, 8>>))
-  }
+@target(javascript)
+pub fn bit_string_erlang_test() {
+  [1, 1, 2, 3, 5, 8]
+  |> uint8array
+  |> dynamic.bit_string
+  |> should.equal(Ok(<<1, 1, 2, 3, 5, 8>>))
 }
 
-if erlang {
-  pub type MyAtom {
-    ThisIsAnAtom
-  }
-
-  pub fn map_from_atom_test() {
-    ThisIsAnAtom
-    |> dynamic.from
-    |> dynamic.map(dynamic.string, dynamic.int)
-    |> should.equal(Error([
-      DecodeError(expected: "Map", found: "Atom", path: []),
-    ]))
-  }
+@target(erlang)
+pub type MyAtom {
+  ThisIsAnAtom
 }
 
-if javascript {
-  external fn get_null() -> dynamic.Dynamic =
-    "../gleam_stdlib_test_ffi.mjs" "get_null"
-
-  pub fn map_from_null_test() {
-    get_null()
-    |> dynamic.from
-    |> dynamic.map(dynamic.string, dynamic.int)
-    |> should.equal(Error([
-      DecodeError(expected: "Map", found: "Null", path: []),
-    ]))
-  }
+@target(erlang)
+pub fn map_from_atom_test() {
+  ThisIsAnAtom
+  |> dynamic.from
+  |> dynamic.map(dynamic.string, dynamic.int)
+  |> should.equal(Error([DecodeError(expected: "Map", found: "Atom", path: [])]))
+}
+
+@target(javascript)
+@external(javascript, "../gleam_stdlib_test_ffi.mjs", "get_null")
+fn get_null() -> dynamic.Dynamic
+
+@target(javascript)
+pub fn map_from_null_test() {
+  get_null()
+  |> dynamic.from
+  |> dynamic.map(dynamic.string, dynamic.int)
+  |> should.equal(Error([DecodeError(expected: "Map", found: "Null", path: [])]))
 }
 
 pub fn string_test() {
@@ -106,15 +101,14 @@ pub fn string_test() {
   ]))
 }
 
-if erlang {
-  pub fn string_non_utf8_test() {
-    <<65_535:16>>
-    |> dynamic.from
-    |> dynamic.string
-    |> should.equal(Error([
-      DecodeError(expected: "String", found: "BitString", path: []),
-    ]))
-  }
+@target(erlang)
+pub fn string_non_utf8_test() {
+  <<65_535:16>>
+  |> dynamic.from
+  |> dynamic.string
+  |> should.equal(Error([
+    DecodeError(expected: "String", found: "BitString", path: []),
+  ]))
 }
 
 pub fn int_test() {
@@ -153,36 +147,30 @@ pub fn float_test() {
   ]))
 }
 
-if erlang {
-  pub fn float_on_js_is_also_int_test() {
-    1
-    |> dynamic.from
-    |> dynamic.float
-    |> should.equal(Error([
-      DecodeError(expected: "Float", found: "Int", path: []),
-    ]))
-
-    1.0
-    |> dynamic.from
-    |> dynamic.int
-    |> should.equal(Error([
-      DecodeError(expected: "Int", found: "Float", path: []),
-    ]))
-  }
+@target(erlang)
+pub fn float_on_js_is_also_int_test() {
+  1
+  |> dynamic.from
+  |> dynamic.float
+  |> should.equal(Error([DecodeError(expected: "Float", found: "Int", path: [])]))
+
+  1.0
+  |> dynamic.from
+  |> dynamic.int
+  |> should.equal(Error([DecodeError(expected: "Int", found: "Float", path: [])]))
 }
 
-if javascript {
-  pub fn float_on_js_is_also_int_test() {
-    1
-    |> dynamic.from
-    |> dynamic.float
-    |> should.equal(Ok(1.0))
-
-    1.0
-    |> dynamic.from
-    |> dynamic.int
-    |> should.equal(Ok(1))
-  }
+@target(javascript)
+pub fn float_on_js_is_also_int_test() {
+  1
+  |> dynamic.from
+  |> dynamic.float
+  |> should.equal(Ok(1.0))
+
+  1.0
+  |> dynamic.from
+  |> dynamic.int
+  |> should.equal(Ok(1))
 }
 
 pub fn bool_test() {
@@ -284,25 +272,24 @@ pub fn optional_test() {
   |> should.be_error
 }
 
-if javascript {
-  pub fn javascript_object_field_test() {
-    Ok(123)
-    |> dynamic.from
-    |> dynamic.field("0", dynamic.int)
-    |> should.equal(Ok(123))
-
-    Ok(123)
-    |> dynamic.from
-    |> dynamic.field(0, dynamic.int)
-    |> should.equal(Ok(123))
-
-    Ok(123)
-    |> dynamic.from
-    |> dynamic.field("Nope", dynamic.int)
-    |> should.equal(Error([
-      DecodeError(expected: "Map", found: "Result", path: []),
-    ]))
-  }
+@target(javascript)
+pub fn javascript_object_field_test() {
+  Ok(123)
+  |> dynamic.from
+  |> dynamic.field("0", dynamic.int)
+  |> should.equal(Ok(123))
+
+  Ok(123)
+  |> dynamic.from
+  |> dynamic.field(0, dynamic.int)
+  |> should.equal(Ok(123))
+
+  Ok(123)
+  |> dynamic.from
+  |> dynamic.field("Nope", dynamic.int)
+  |> should.equal(Error([
+    DecodeError(expected: "Map", found: "Result", path: []),
+  ]))
 }
 
 pub fn field_test() {
@@ -1083,18 +1070,17 @@ pub fn shallow_list_test() {
   |> should.equal(Error([DecodeError(expected: "List", found: "Int", path: [])]))
 }
 
-if javascript {
-  pub fn array_on_js_is_also_list_test() {
-    #()
-    |> dynamic.from
-    |> dynamic.shallow_list
-    |> should.equal(Ok([]))
-
-    #(1, 2)
-    |> dynamic.from
-    |> dynamic.list(of: dynamic.int)
-    |> should.equal(Ok([1, 2]))
-  }
+@target(javascript)
+pub fn array_on_js_is_also_list_test() {
+  #()
+  |> dynamic.from
+  |> dynamic.shallow_list
+  |> should.equal(Ok([]))
+
+  #(1, 2)
+  |> dynamic.from
+  |> dynamic.list(of: dynamic.int)
+  |> should.equal(Ok([1, 2]))
 }
 
 pub fn result_test() {
diff --git a/test/gleam/list_test.gleam b/test/gleam/list_test.gleam
index 2883535..c4305f5 100644
--- a/test/gleam/list_test.gleam
+++ b/test/gleam/list_test.gleam
@@ -5,18 +5,16 @@ import gleam/list
 import gleam/map
 import gleam/should
 
-if erlang {
-  const recursion_test_cycles = 1_000_000
-}
-
-if javascript {
-  // JavaScript engines crash when exceeding a certain stack size:
-  //
-  // - Chrome 106 and NodeJS V16, V18, and V19 crash around 10_000+
-  // - Firefox 106 crashes around 35_000+.
-  // - Safari 16 crashes around 40_000+.
-  const recursion_test_cycles = 40_000
-}
+@target(erlang)
+const recursion_test_cycles = 1_000_000
+
+// JavaScript engines crash when exceeding a certain stack size:
+//
+// - Chrome 106 and NodeJS V16, V18, and V19 crash around 10_000+
+// - Firefox 106 crashes around 35_000+.
+// - Safari 16 crashes around 40_000+.
+@target(javascript)
+const recursion_test_cycles = 40_000
 
 pub fn length_test() {
   list.length([])
diff --git a/test/gleam/should.gleam b/test/gleam/should.gleam
index 7ae0408..acfeacd 100644
--- a/test/gleam/should.gleam
+++ b/test/gleam/should.gleam
@@ -4,67 +4,74 @@
 //// More information on running eunit can be found in [the rebar3
 //// documentation](https://rebar3.org/docs/testing/eunit/).
 
-if erlang {
-  pub external fn equal(a, a) -> Nil =
-    "gleam_stdlib_test_ffi" "should_equal"
+@target(erlang)
+@external(erlang, "gleam_stdlib_test_ffi", "should_equal")
+pub fn equal(a: a, b: a) -> Nil
 
-  pub external fn not_equal(a, a) -> Nil =
-    "gleam_stdlib_test_ffi" "should_not_equal"
+@target(erlang)
+@external(erlang, "gleam_stdlib_test_ffi", "should_not_equal")
+pub fn not_equal(a: a, b: a) -> Nil
 
-  pub external fn be_ok(Result(a, b)) -> Nil =
-    "gleam_stdlib_test_ffi" "should_be_ok"
+@target(erlang)
+@external(erlang, "gleam_stdlib_test_ffi", "should_be_ok")
+pub fn be_ok(a: Result(a, b)) -> Nil
 
-  pub external fn be_error(Result(a, b)) -> Nil =
-    "gleam_stdlib_test_ffi" "should_be_error"
-}
+@target(erlang)
+@external(erlang, "gleam_stdlib_test_ffi", "should_be_error")
+pub fn be_error(a: Result(a, b)) -> Nil
 
-if javascript {
-  import gleam/string
+@target(javascript)
+import gleam/string
 
-  external fn stringify(anything) -> String =
-    "../gleam.mjs" "inspect"
+@target(javascript)
+@external(javascript, "../gleam.mjs", "inspect")
+fn stringify(a: anything) -> String
 
-  external fn crash(String) -> anything =
-    "../gleam_stdlib.mjs" "crash"
+@target(javascript)
+@external(javascript, "../gleam_stdlib.mjs", "crash")
+fn crash(a: String) -> anything
 
-  pub fn equal(a, b) {
-    case a == b {
-      True -> Nil
-      _ ->
-        crash(string.concat([
-          "\n\t",
-          stringify(a),
-          "\n\tshould equal \n\t",
-          stringify(b),
-        ]))
-    }
+@target(javascript)
+pub fn equal(a, b) {
+  case a == b {
+    True -> Nil
+    _ ->
+      crash(string.concat([
+        "\n\t",
+        stringify(a),
+        "\n\tshould equal \n\t",
+        stringify(b),
+      ]))
   }
+}
 
-  pub fn not_equal(a, b) {
-    case a != b {
-      True -> Nil
-      _ ->
-        crash(string.concat([
-          "\n",
-          stringify(a),
-          "\nshould not equal \n",
-          stringify(b),
-        ]))
-    }
+@target(javascript)
+pub fn not_equal(a, b) {
+  case a != b {
+    True -> Nil
+    _ ->
+      crash(string.concat([
+        "\n",
+        stringify(a),
+        "\nshould not equal \n",
+        stringify(b),
+      ]))
   }
+}
 
-  pub fn be_ok(a) {
-    case a {
-      Ok(_) -> Nil
-      _ -> crash(string.concat(["\n", stringify(a), "\nshould be ok"]))
-    }
+@target(javascript)
+pub fn be_ok(a) {
+  case a {
+    Ok(_) -> Nil
+    _ -> crash(string.concat(["\n", stringify(a), "\nshould be ok"]))
   }
+}
 
-  pub fn be_error(a) {
-    case a {
-      Error(_) -> Nil
-      _ -> crash(string.concat(["\n", stringify(a), "\nshould be error"]))
-    }
+@target(javascript)
+pub fn be_error(a) {
+  case a {
+    Error(_) -> Nil
+    _ -> crash(string.concat(["\n", stringify(a), "\nshould be error"]))
   }
 }
 
diff --git a/test/gleam/string_test.gleam b/test/gleam/string_test.gleam
index 0fa860f..c072800 100644
--- a/test/gleam/string_test.gleam
+++ b/test/gleam/string_test.gleam
@@ -882,191 +882,202 @@ pub fn inspect_test() {
   |> should.equal("<<255, 2, 0>>")
 }
 
-if javascript {
-  pub fn target_inspect_test() {
-    // Due to Erlang's internal representation, on Erlang this passes, instead:
-    // string.inspect(#(InspectTypeZero, InspectTypeZero))
-    // |> should.equal("InspectTypeZero(InspectTypeZero)")
-    string.inspect(#(InspectTypeZero, InspectTypeZero))
-    |> should.equal("#(InspectTypeZero, InspectTypeZero)")
-
-    // Due to JavaScript's `Number` type `Float`s without digits return as
-    // `Int`s.
-    string.inspect(-1.0)
-    |> should.equal("-1")
-
-    string.inspect(0.0)
-    |> should.equal("0")
-
-    string.inspect(1.0)
-    |> should.equal("1")
-
-    string.inspect([1.0])
-    |> should.equal("[1]")
-
-    string.inspect(#(1.0))
-    |> should.equal("#(1)")
-
-    // Unlike on Erlang, on JavaScript `BitString` and `String` do have a
-    // different runtime representation.
-    <<"abc":utf8>>
-    |> string.inspect()
-    |> should.equal("<<97, 98, 99>>")
-  }
+@target(javascript)
+pub fn target_inspect_test() {
+  // Due to Erlang's internal representation, on Erlang this passes, instead:
+  // string.inspect(#(InspectTypeZero, InspectTypeZero))
+  // |> should.equal("InspectTypeZero(InspectTypeZero)")
+  string.inspect(#(InspectTypeZero, InspectTypeZero))
+  |> should.equal("#(InspectTypeZero, InspectTypeZero)")
+
+  // Due to JavaScript's `Number` type `Float`s without digits return as
+  // `Int`s.
+  string.inspect(-1.0)
+  |> should.equal("-1")
+
+  string.inspect(0.0)
+  |> should.equal("0")
+
+  string.inspect(1.0)
+  |> should.equal("1")
+
+  string.inspect([1.0])
+  |> should.equal("[1]")
+
+  string.inspect(#(1.0))
+  |> should.equal("#(1)")
+
+  // Unlike on Erlang, on JavaScript `BitString` and `String` do have a
+  // different runtime representation.
+  <<"abc":utf8>>
+  |> string.inspect()
+  |> should.equal("<<97, 98, 99>>")
 }
 
-if erlang {
-  import gleam/regex
-  import gleam/dynamic.{Dynamic}
-
-  // Test inspect on Erlang atoms valid and invalid in Gleam
-
-  external fn create_erlang_pid() -> String =
-    "erlang" "self"
-
-  external fn create_erlang_reference() -> String =
-    "erlang" "make_ref"
-
-  pub fn target_inspect_test() {
-    // Erlang's internal representation does not allow a correct
-    // differentiation at runtime and thus this does not pass:
-    // string.inspect(#(InspectTypeZero, InspectTypeZero))
-    // |> should.equal("#(InspectTypeZero, InspectTypeZero)")
-    string.inspect(#(InspectTypeZero, InspectTypeZero))
-    |> should.equal("InspectTypeZero(InspectTypeZero)")
-
-    // Unlike JavaScript, Erlang correctly differentiates between `1` and `1.0`
-    // at runtime.
-    string.inspect(-1.0)
-    |> should.equal("-1.0")
-
-    string.inspect(0.0)
-    |> should.equal("0.0")
-
-    string.inspect(1.0)
-    |> should.equal("1.0")
-
-    string.inspect([1.0])
-    |> should.equal("[1.0]")
-
-    string.inspect(#(1.0))
-    |> should.equal("#(1.0)")
-
-    // Looks like `//erl(<0.83.0>)`.
-    let assert Ok(regular_expression) =
-      regex.from_string("^\\/\\/erl\\(<[0-9]+\\.[0-9]+\\.[0-9]+>\\)$")
-    string.inspect(create_erlang_pid())
-    |> regex.check(regular_expression, _)
-    |> should.be_true
-
-    // Looks like: `//erl(#Ref<0.1809744150.4035444737.100468>)`.
-    let assert Ok(regular_expression) =
-      regex.from_string(
-        "^\\/\\/erl\\(#Ref<[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+>\\)$",
-      )
-    string.inspect(create_erlang_reference())
-    |> regex.check(regular_expression, _)
-    |> should.be_true
-
-    // On Erlang the representation between `String` and `BitString` is
-    // indistinguishable at runtime.
-    <<"abc":utf8>>
-    |> string.inspect()
-    |> should.equal("\"abc\"")
-  }
+@target(erlang)
+import gleam/regex
+@target(erlang)
+import gleam/dynamic.{Dynamic}
 
-  pub fn improper_list_inspect_test() {
-    let list = improper_list_append(1, 2, 3)
-    let assert "//erl([1, 2 | 3])" = string.inspect(list)
-  }
+// Test inspect on Erlang atoms valid and invalid in Gleam
 
-  // Warning: The type of this function is incorrect
-  external fn improper_list_append(
-    item_a,
-    item_b,
-    improper_tail,
-  ) -> List(anything) =
-    "gleam_stdlib_test_ffi" "improper_list_append"
+@target(erlang)
+@external(erlang, "erlang", "self")
+fn create_erlang_pid() -> String
 
-  external fn string_to_erlang_atom(String) -> Dynamic =
-    "erlang" "binary_to_atom"
+@target(erlang)
+@external(erlang, "erlang", "make_ref")
+fn create_erlang_reference() -> String
 
-  pub fn inspect_erlang_atom_is_valid_in_gleam_test() {
-    string_to_erlang_atom("a_common_erlang_atom_is_valid_in_gleam")
-    |> string.inspect
-    |> should.equal("ACommonErlangAtomIsValidInGleam")
+@target(erlang)
+pub fn target_inspect_test() {
+  // Erlang's internal representation does not allow a correct
+  // differentiation at runtime and thus this does not pass:
+  // string.inspect(#(InspectTypeZero, InspectTypeZero))
+  // |> should.equal("#(InspectTypeZero, InspectTypeZero)")
+  string.inspect(#(InspectTypeZero, InspectTypeZero))
+  |> should.equal("InspectTypeZero(InspectTypeZero)")
 
-    string_to_erlang_atom(
-      "an_erlang_atom_with_1_or_many_non_leading_digits_is_valid_in_gleam",
-    )
-    |> string.inspect
-    |> should.equal("AnErlangAtomWith1OrManyNonLeadingDigitsIsValidInGleam")
-  }
+  // Unlike JavaScript, Erlang correctly differentiates between `1` and `1.0`
+  // at runtime.
+  string.inspect(-1.0)
+  |> should.equal("-1.0")
 
-  pub fn inspect_erlang_atom_with_a_leading_underscore_is_invalid_in_gleam_test() {
-    string_to_erlang_atom(
-      "_an_erlang_atom_with_a_leading_underscore_is_invalid_in_gleam",
-    )
-    |> string.inspect
-    |> should.equal(
-      "//erl('_an_erlang_atom_with_a_leading_underscore_is_invalid_in_gleam')",
-    )
-  }
+  string.inspect(0.0)
+  |> should.equal("0.0")
 
-  pub fn inspect_erlang_atom_with_a_trailing_underscore_is_invalid_in_gleam_test() {
-    string_to_erlang_atom(
-      "an_erlang_atom_with_a_trailing_underscore_is_invalid_in_gleam_",
-    )
-    |> string.inspect
-    |> should.equal(
-      "//erl('an_erlang_atom_with_a_trailing_underscore_is_invalid_in_gleam_')",
-    )
-  }
+  string.inspect(1.0)
+  |> should.equal("1.0")
 
-  pub fn inspect_erlang_atom_with_a_double_underscore_is_invalid_in_gleam_test() {
-    string_to_erlang_atom("an_erlang_atom_with_a_double__underscore_is_invalid")
-    |> string.inspect
-    |> should.equal(
-      "//erl('an_erlang_atom_with_a_double__underscore_is_invalid')",
-    )
-  }
+  string.inspect([1.0])
+  |> should.equal("[1.0]")
 
-  pub fn inspect_erlang_atom_with_white_spaces_is_invalid_in_gleam_test() {
-    string_to_erlang_atom(
-      "an erlang atom with white spaces is invalid in gleam",
-    )
-    |> string.inspect
-    |> should.equal(
-      "//erl('an erlang atom with white spaces is invalid in gleam')",
+  string.inspect(#(1.0))
+  |> should.equal("#(1.0)")
+
+  // Looks like `//erl(<0.83.0>)`.
+  let assert Ok(regular_expression) =
+    regex.from_string("^\\/\\/erl\\(<[0-9]+\\.[0-9]+\\.[0-9]+>\\)$")
+  string.inspect(create_erlang_pid())
+  |> regex.check(regular_expression, _)
+  |> should.be_true
+
+  // Looks like: `//erl(#Ref<0.1809744150.4035444737.100468>)`.
+  let assert Ok(regular_expression) =
+    regex.from_string(
+      "^\\/\\/erl\\(#Ref<[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+>\\)$",
     )
-  }
+  string.inspect(create_erlang_reference())
+  |> regex.check(regular_expression, _)
+  |> should.be_true
 
-  pub fn inspect_erlang_atom_that_is_an_empty_string_is_invalid_in_gleam_test() {
-    // An empty string based atom is invalid in gleam
-    string_to_erlang_atom("")
-    |> string.inspect
-    |> should.equal("//erl('')")
-  }
+  // On Erlang the representation between `String` and `BitString` is
+  // indistinguishable at runtime.
+  <<"abc":utf8>>
+  |> string.inspect()
+  |> should.equal("\"abc\"")
+}
 
-  pub fn inspect_erlang_atom_with_uppercases_invalid_in_gleam_test() {
-    string_to_erlang_atom("AnErlangAtomWithUpperCasesIsInvalidInGleam")
-    |> string.inspect
-    |> should.equal("//erl('AnErlangAtomWithUpperCasesIsInvalidInGleam')")
-  }
+@target(erlang)
+pub fn improper_list_inspect_test() {
+  let list = improper_list_append(1, 2, 3)
+  let assert "//erl([1, 2 | 3])" = string.inspect(list)
+}
 
-  pub fn inspect_erlang_atom_with_leading_digit_invalid_in_gleam_test() {
-    string_to_erlang_atom(
-      "1_erlang_atom_with_a_leading_digit_is_invalid_in_gleam",
-    )
-    |> string.inspect
-    |> should.equal(
-      "//erl('1_erlang_atom_with_a_leading_digit_is_invalid_in_gleam')",
-    )
+// Warning: The type of this function is incorrect
+@target(erlang)
+@external(erlang, "gleam_stdlib_test_ffi", "improper_list_append")
+fn improper_list_append(
+  a: item_a,
+  b: item_b,
+  c: improper_tail,
+) -> List(anything)
+
+@target(erlang)
+@external(erlang, "erlang", "binary_to_atom")
+fn string_to_erlang_atom(a: String) -> Dynamic
+
+@target(erlang)
+pub fn inspect_erlang_atom_is_valid_in_gleam_test() {
+  string_to_erlang_atom("a_common_erlang_atom_is_valid_in_gleam")
+  |> string.inspect
+  |> should.equal("ACommonErlangAtomIsValidInGleam")
+
+  string_to_erlang_atom(
+    "an_erlang_atom_with_1_or_many_non_leading_digits_is_valid_in_gleam",
+  )
+  |> string.inspect
+  |> should.equal("AnErlangAtomWith1OrManyNonLeadingDigitsIsValidInGleam")
+}
 
-    string_to_erlang_atom("1ErlangAtomWithALeadingDigitIsInvalidInGleam")
-    |> string.inspect
-    |> should.equal("//erl('1ErlangAtomWithALeadingDigitIsInvalidInGleam')")
-  }
+@target(erlang)
+pub fn inspect_erlang_atom_with_a_leading_underscore_is_invalid_in_gleam_test() {
+  string_to_erlang_atom(
+    "_an_erlang_atom_with_a_leading_underscore_is_invalid_in_gleam",
+  )
+  |> string.inspect
+  |> should.equal(
+    "//erl('_an_erlang_atom_with_a_leading_underscore_is_invalid_in_gleam')",
+  )
+}
+
+@target(erlang)
+pub fn inspect_erlang_atom_with_a_trailing_underscore_is_invalid_in_gleam_test() {
+  string_to_erlang_atom(
+    "an_erlang_atom_with_a_trailing_underscore_is_invalid_in_gleam_",
+  )
+  |> string.inspect
+  |> should.equal(
+    "//erl('an_erlang_atom_with_a_trailing_underscore_is_invalid_in_gleam_')",
+  )
+}
+
+@target(erlang)
+pub fn inspect_erlang_atom_with_a_double_underscore_is_invalid_in_gleam_test() {
+  string_to_erlang_atom("an_erlang_atom_with_a_double__underscore_is_invalid")
+  |> string.inspect
+  |> should.equal(
+    "//erl('an_erlang_atom_with_a_double__underscore_is_invalid')",
+  )
+}
+
+@target(erlang)
+pub fn inspect_erlang_atom_with_white_spaces_is_invalid_in_gleam_test() {
+  string_to_erlang_atom("an erlang atom with white spaces is invalid in gleam")
+  |> string.inspect
+  |> should.equal(
+    "//erl('an erlang atom with white spaces is invalid in gleam')",
+  )
+}
+
+@target(erlang)
+pub fn inspect_erlang_atom_that_is_an_empty_string_is_invalid_in_gleam_test() {
+  // An empty string based atom is invalid in gleam
+  string_to_erlang_atom("")
+  |> string.inspect
+  |> should.equal("//erl('')")
+}
+
+@target(erlang)
+pub fn inspect_erlang_atom_with_uppercases_invalid_in_gleam_test() {
+  string_to_erlang_atom("AnErlangAtomWithUpperCasesIsInvalidInGleam")
+  |> string.inspect
+  |> should.equal("//erl('AnErlangAtomWithUpperCasesIsInvalidInGleam')")
+}
+
+@target(erlang)
+pub fn inspect_erlang_atom_with_leading_digit_invalid_in_gleam_test() {
+  string_to_erlang_atom(
+    "1_erlang_atom_with_a_leading_digit_is_invalid_in_gleam",
+  )
+  |> string.inspect
+  |> should.equal(
+    "//erl('1_erlang_atom_with_a_leading_digit_is_invalid_in_gleam')",
+  )
+
+  string_to_erlang_atom("1ErlangAtomWithALeadingDigitIsInvalidInGleam")
+  |> string.inspect
+  |> should.equal("//erl('1ErlangAtomWithALeadingDigitIsInvalidInGleam')")
 }
 
 pub fn byte_size_test() {
diff --git a/test/gleam_stdlib_test.gleam b/test/gleam_stdlib_test.gleam
index fabc311..ed09793 100644
--- a/test/gleam_stdlib_test.gleam
+++ b/test/gleam_stdlib_test.gleam
@@ -1,9 +1,3 @@
-if erlang {
-  pub external fn main() -> Nil =
-    "gleam_stdlib_test_ffi" "main"
-}
-
-if javascript {
-  pub external fn main() -> Nil =
-    "././gleeunit.mjs" "main"
-}
+@external(erlang, "gleam_stdlib_test_ffi", "main")
+@external(javascript, "././gleeunit.mjs", "main")
+pub fn main() -> Nil