Remove type_of

Author: lpil

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 - Removed the `raceN` and `awaitN` functions from the `promise` module.
 - Removed the `map` module.
+- Removed the `type_of` function and `TypeOf` type from the `javascript` module.
 
 ## v0.13.0 - 2024-08-30
 

src/gleam/javascript.gleam

@@ -1,41 +1,10 @@
-/// The variants that `type_of` can return.
-pub type TypeOf {
-  /// It is the value `undefined`.
-  UndefinedType
-  /// It is some object, or it is `null`.
-  ObjectType
-  /// It is either `true` or `false`.
-  BooleanType
-  /// It is some number, a 64 bit float.
-  NumberType
-  /// It is a JavaScript big-integer.
-  BigIntType
-  /// It is a string.
-  StringType
-  /// It is a JavaScript symbol.
-  SymbolType
-  /// It is a function of unknown argument types and return type.
-  FunctionType
-}
-
 /// Symbols are special unique values in JavaScript.
 ///
 /// For further information view the MDN documentation: 
 /// <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol>
 ///
 pub type Symbol
 
-/// Determine what category of JavaScript type a value belongs to.
-///
-/// This uses the JavaScript `typeof` operator and has limited accuracy. It
-/// cannot tell you anything about what Gleam type a value has.
-///
-/// For further information view the MDN documentation: 
-/// <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol>
-///
-@external(javascript, "../gleam_javascript_ffi.mjs", "type_of")
-pub fn type_of(a: value) -> TypeOf
-
 /// Use the JavaScript `Symbol.for` method to look up a symbol with the given
 /// string name, creating a new one if one does exist.
 ///

src/gleam_javascript_ffi.mjs

@@ -1,15 +1,4 @@
 import { Ok, Error } from "./gleam.mjs";
-import {
-  UndefinedType,
-  ObjectType,
-  BooleanType,
-  NumberType,
-  BigIntType,
-  StringType,
-  SymbolType,
-  FunctionType,
-} from "./gleam/javascript.mjs";
-
 export function toArray(list) {
   return list.toArray();
 }
@@ -38,29 +27,6 @@ export function object_from_entries(entries) {
   return Object.fromEntries(entries);
 }
 
-export function type_of(value) {
-  switch (typeof value) {
-    case "undefined":
-      return new UndefinedType();
-    case "object":
-      return new ObjectType();
-    case "boolean":
-      return new BooleanType();
-    case "number":
-      return new NumberType();
-    case "bigint":
-      return new BigIntType();
-    case "string":
-      return new StringType();
-    case "symbol":
-      return new SymbolType();
-    case "function":
-      return new FunctionType();
-    default:
-      throw new globalThis.Error(`Unexpected typeof ${typeof value}`);
-  }
-}
-
 export function get_symbol(name) {
   return Symbol.for(name);
 }
@@ -92,9 +58,11 @@ export function newPromise(executor) {
 export function start_promise() {
   let resolve;
   const promise = new Promise((r) => {
-    resolve = (value) => {r(PromiseLayer.wrap(value))}
-  })
-  return [promise, resolve]
+    resolve = (value) => {
+      r(PromiseLayer.wrap(value));
+    };
+  });
+  return [promise, resolve];
 }
 
 export function resolve(value) {
@@ -118,7 +86,7 @@ export function rescue(promise, fn) {
 export function wait(delay) {
   return new Promise((resolve) => {
     globalThis.setTimeout(resolve, delay);
-  })
+  });
 }
 
 export function all_promises(...promises) {

test/gleam/javascript/promise_test.gleam

@@ -1,6 +1,6 @@
-import gleam/javascript.{ObjectType}
 import gleam/javascript/array
 import gleam/javascript/promise.{type Promise}
+import helper.{ObjectType}
 
 pub fn new_promise_test() {
   promise.new(fn(resolve) { resolve(1) })
@@ -15,7 +15,7 @@ pub fn new_does_not_collapse_nested_promise_test() {
     // If the `Promise(Promise(Int))` collapsed into `Promise(Int)` (as they
     // do for normal JS promises) then this would fail as the value would be the
     // int value `1`.
-    let assert ObjectType = javascript.type_of(value)
+    let assert ObjectType = helper.type_of(value)
   })
 }
 
@@ -33,7 +33,7 @@ pub fn start_does_not_collapse_nested_promise_test() {
     // If the `Promise(Promise(Int))` collapsed into `Promise(Int)` (as they
     // do for normal JS promises) then this would fail as the value would be the
     // int value `1`.
-    let assert ObjectType = javascript.type_of(value)
+    let assert ObjectType = helper.type_of(value)
   })
   resolve(promise.resolve(1))
 }
@@ -45,7 +45,7 @@ pub fn map_does_not_collapse_nested_promise_test() -> Promise(Promise(Int)) {
     // If the `Promise(Promise(Int))` collapsed into `Promise(Int)` (as they
     // do for normal JS promises) then this would fail as the value would be the
     // int value `1`.
-    let assert ObjectType = javascript.type_of(value)
+    let assert ObjectType = helper.type_of(value)
   })
 }
 

test/gleam/javascript_test.gleam

@@ -0,0 +1,33 @@
+import {
+  UndefinedType,
+  ObjectType,
+  BooleanType,
+  NumberType,
+  BigIntType,
+  StringType,
+  SymbolType,
+  FunctionType,
+} from "./helper.mjs";
+
+export function type_of(value) {
+  switch (typeof value) {
+    case "undefined":
+      return new UndefinedType();
+    case "object":
+      return new ObjectType();
+    case "boolean":
+      return new BooleanType();
+    case "number":
+      return new NumberType();
+    case "bigint":
+      return new BigIntType();
+    case "string":
+      return new StringType();
+    case "symbol":
+      return new SymbolType();
+    case "function":
+      return new FunctionType();
+    default:
+      throw new globalThis.Error(`Unexpected typeof ${typeof value}`);
+  }
+}

test/gleam_javascript_test_ffi.mjs

@@ -0,0 +1,30 @@
+/// The variants that `type_of` can return.
+pub type TypeOf {
+  /// It is the value `undefined`.
+  UndefinedType
+  /// It is some object, or it is `null`.
+  ObjectType
+  /// It is either `true` or `false`.
+  BooleanType
+  /// It is some number, a 64 bit float.
+  NumberType
+  /// It is a JavaScript big-integer.
+  BigIntType
+  /// It is a string.
+  StringType
+  /// It is a JavaScript symbol.
+  SymbolType
+  /// It is a function of unknown argument types and return type.
+  FunctionType
+}
+
+/// Determine what category of JavaScript type a value belongs to.
+///
+/// This uses the JavaScript `typeof` operator and has limited accuracy. It
+/// cannot tell you anything about what Gleam type a value has.
+///
+/// For further information view the MDN documentation: 
+/// <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol>
+///
+@external(javascript, "./gleam_javascript_test_ffi.mjs", "type_of")
+pub fn type_of(a: value) -> TypeOf