Rename to bit array

9 files changed, 86 insertions, 81 deletions

diff --git a/src/gleam/base.gleam b/src/gleam/base.gleam
index 5877f3d..1cf9985 100644
--- a/src/gleam/base.gleam
+++ b/src/gleam/base.gleam
@@ -1,7 +1,7 @@
-import gleam/bit_string
+import gleam/bit_array
 import gleam/string
 
-/// Encodes a BitString into a base 64 encoded string.
+/// Encodes a BitArray into a base 64 encoded string.
 ///
 pub fn encode64(input: BitArray, padding: Bool) -> String {
   let encoded = do_encode64(input)
@@ -15,10 +15,10 @@ pub fn encode64(input: BitArray, padding: Bool) -> String {
 @external(javascript, "../gleam_stdlib.mjs", "encode64")
 fn do_encode64(a: BitArray) -> String
 
-/// Decodes a base 64 encoded string into a `BitString`.
+/// Decodes a base 64 encoded string into a `BitArray`.
 ///
 pub fn decode64(encoded: String) -> Result(BitArray, Nil) {
-  let padded = case bit_string.byte_size(bit_string.from_string(encoded)) % 4 {
+  let padded = case bit_array.byte_size(bit_array.from_string(encoded)) % 4 {
     0 -> encoded
     n -> string.append(encoded, string.repeat("=", 4 - n))
   }
@@ -29,7 +29,7 @@ pub fn decode64(encoded: String) -> Result(BitArray, Nil) {
 @external(javascript, "../gleam_stdlib.mjs", "decode64")
 fn do_decode64(a: String) -> Result(BitArray, Nil)
 
-/// Encodes a `BitString` into a base 64 encoded string with URL and filename safe alphabet.
+/// Encodes a `BitArray` into a base 64 encoded string with URL and filename safe alphabet.
 ///
 pub fn url_encode64(input: BitArray, padding: Bool) -> String {
   encode64(input, padding)
@@ -37,7 +37,7 @@ pub fn url_encode64(input: BitArray, padding: Bool) -> String {
   |> string.replace("/", "_")
 }
 
-/// Decodes a base 64 encoded string with URL and filename safe alphabet into a `BitString`.
+/// Decodes a base 64 encoded string with URL and filename safe alphabet into a `BitArray`.
 ///
 pub fn url_decode64(encoded: String) -> Result(BitArray, Nil) {
   encoded
diff --git a/src/gleam/bit_array.gleam b/src/gleam/bit_array.gleam
index 6ea94d8..4a50c62 100644
--- a/src/gleam/bit_array.gleam
+++ b/src/gleam/bit_array.gleam
@@ -3,7 +3,7 @@
 /// Converts a UTF-8 `String` type into a `BitArray`.
 ///
 @external(erlang, "gleam_stdlib", "identity")
-@external(javascript, "../gleam_stdlib.mjs", "bit_string_from_string")
+@external(javascript, "../gleam_stdlib.mjs", "bit_array_from_string")
 pub fn from_string(x: String) -> BitArray
 
 /// Returns an integer which is the number of bytes in the bit array.
@@ -33,8 +33,8 @@ pub fn append(to first: BitArray, suffix second: BitArray) -> BitArray {
 ///
 /// This function runs in constant time.
 ///
-@external(erlang, "gleam_stdlib", "bit_string_slice")
-@external(javascript, "../gleam_stdlib.mjs", "bit_string_slice")
+@external(erlang, "gleam_stdlib", "bit_array_slice")
+@external(javascript, "../gleam_stdlib.mjs", "bit_array_slice")
 pub fn slice(
   from string: BitArray,
   at position: Int,
@@ -85,7 +85,7 @@ fn do_to_string(bits: BitArray) -> Result(String, Nil) {
 }
 
 @target(javascript)
-@external(javascript, "../gleam_stdlib.mjs", "bit_string_to_string")
+@external(javascript, "../gleam_stdlib.mjs", "bit_array_to_string")
 fn do_to_string(a: BitArray) -> Result(String, Nil)
 
 /// Creates a new bit array by joining multiple binaries.
@@ -97,6 +97,6 @@ fn do_to_string(a: BitArray) -> Result(String, Nil)
 /// from_string("butterfly")
 /// ```
 ///
-@external(erlang, "gleam_stdlib", "bit_string_concat")
-@external(javascript, "../gleam_stdlib.mjs", "bit_string_concat")
-pub fn concat(bit_strings: List(BitArray)) -> BitArray
+@external(erlang, "gleam_stdlib", "bit_array_concat")
+@external(javascript, "../gleam_stdlib.mjs", "bit_array_concat")
+pub fn concat(bit_arrays: List(BitArray)) -> BitArray
diff --git a/src/gleam/dynamic.gleam b/src/gleam/dynamic.gleam
index d12f85c..2e57176 100644
--- a/src/gleam/dynamic.gleam
+++ b/src/gleam/dynamic.gleam
@@ -5,7 +5,7 @@ import gleam/option.{type Option}
 import gleam/result
 import gleam/string_builder
 @target(erlang)
-import gleam/bit_string
+import gleam/bit_array
 
 /// `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
@@ -60,28 +60,33 @@ pub fn dynamic(value: Dynamic) -> Result(Dynamic, List(DecodeError)) {
   Ok(value)
 }
 
-/// Checks to see whether a `Dynamic` value is a bit_string, and returns that bit string if
-/// it is.
+/// Checks to see whether a `Dynamic` value is a bit array, and returns that bit
+/// array if it is.
 ///
 /// ## Examples
 ///
 /// ```gleam
-/// > bit_string(from("Hello")) == bit_string.from_string("Hello")
+/// > bit_array(from("Hello")) == bit_array.from_string("Hello")
 /// True
 /// ```
 ///
 /// ```gleam
-/// > bit_string(from(123))
-/// Error([DecodeError(expected: "BitString", found: "Int", path: [])])
+/// > bit_array(from(123))
+/// Error([DecodeError(expected: "BitArray", found: "Int", path: [])])
 /// ```
 ///
+pub fn bit_array(from data: Dynamic) -> Result(BitArray, DecodeErrors) {
+  decode_bit_array(data)
+}
+
+@deprecated("Please use `bit_array` instead")
 pub fn bit_string(from data: Dynamic) -> Result(BitArray, DecodeErrors) {
-  decode_bit_string(data)
+  bit_array(data)
 }
 
-@external(erlang, "gleam_stdlib", "decode_bit_string")
-@external(javascript, "../gleam_stdlib.mjs", "decode_bit_string")
-fn decode_bit_string(a: Dynamic) -> Result(BitArray, DecodeErrors)
+@external(erlang, "gleam_stdlib", "decode_bit_array")
+@external(javascript, "../gleam_stdlib.mjs", "decode_bit_array")
+fn decode_bit_array(a: Dynamic) -> Result(BitArray, DecodeErrors)
 
 /// Checks to see whether a `Dynamic` value is a string, and returns that string if
 /// it is.
@@ -111,13 +116,13 @@ fn map_errors(
 
 @target(erlang)
 fn decode_string(data: Dynamic) -> Result(String, DecodeErrors) {
-  bit_string(data)
+  bit_array(data)
   |> map_errors(put_expected(_, "String"))
   |> result.try(fn(raw) {
-    case bit_string.to_string(raw) {
+    case bit_array.to_string(raw) {
       Ok(string) -> Ok(string)
       Error(Nil) ->
-        Error([DecodeError(expected: "String", found: "BitString", path: [])])
+        Error([DecodeError(expected: "String", found: "BitArray", path: [])])
     }
   })
 }
diff --git a/src/gleam/string.gleam b/src/gleam/string.gleam
index 39d0e5a..94c9dad 100644
--- a/src/gleam/string.gleam
+++ b/src/gleam/string.gleam
@@ -7,7 +7,7 @@ import gleam/option.{type Option, None, Some}
 import gleam/order
 import gleam/string_builder.{type StringBuilder}
 @target(erlang)
-import gleam/bit_string
+import gleam/bit_array
 @target(erlang)
 import gleam/dynamic.{type Dynamic}
 @target(erlang)
@@ -338,7 +338,7 @@ pub fn contains(does haystack: String, contain needle: String) -> Bool {
 fn do_contains(haystack: String, needle: String) -> Bool {
   haystack
   |> erl_contains(needle)
-  |> dynamic.bit_string
+  |> dynamic.bit_array
   |> result.is_ok
 }
 
@@ -755,16 +755,16 @@ pub fn to_utf_codepoints(string: String) -> List(UtfCodepoint) {
 
 @target(erlang)
 fn do_to_utf_codepoints(string: String) -> List(UtfCodepoint) {
-  do_to_utf_codepoints_impl(bit_string.from_string(string), [])
+  do_to_utf_codepoints_impl(bit_array.from_string(string), [])
   |> list.reverse
 }
 
 @target(erlang)
 fn do_to_utf_codepoints_impl(
-  bit_string: BitArray,
+  bit_array: BitArray,
   acc: List(UtfCodepoint),
 ) -> List(UtfCodepoint) {
-  case bit_string {
+  case bit_array {
     <<first:utf8_codepoint, rest:bytes>> ->
       do_to_utf_codepoints_impl(rest, [first, ..acc])
     <<>> -> acc
@@ -810,8 +810,8 @@ pub fn from_utf_codepoints(utf_codepoints: List(UtfCodepoint)) -> String {
 @target(erlang)
 fn do_from_utf_codepoints(utf_codepoints: List(UtfCodepoint)) -> String {
   let assert Ok(string) =
-    do_from_utf_codepoints_impl(utf_codepoints, bit_string.from_string(""))
-    |> bit_string.to_string
+    do_from_utf_codepoints_impl(utf_codepoints, bit_array.from_string(""))
+    |> bit_array.to_string
   string
 }
 
diff --git a/src/gleam_stdlib.erl b/src/gleam_stdlib.erl
index 9f3bd02..4c2a859 100644
--- a/src/gleam_stdlib.erl
+++ b/src/gleam_stdlib.erl
@@ -5,10 +5,10 @@
          decode_field/2, parse_int/1, parse_float/1, less_than/2,
          string_pop_grapheme/1, string_starts_with/2, wrap_list/1,
          string_ends_with/2, string_pad/4, decode_map/1, uri_parse/1,
-         bit_string_int_to_u32/1, bit_string_int_from_u32/1, decode_result/1,
-         bit_string_slice/3, decode_bit_string/1, compile_regex/2, regex_scan/2,
+         bit_array_int_to_u32/1, bit_array_int_from_u32/1, decode_result/1,
+         bit_array_slice/3, decode_bit_array/1, compile_regex/2, regex_scan/2,
          percent_encode/1, percent_decode/1, regex_check/2, regex_split/2,
-         base_decode64/1, parse_query/1, bit_string_concat/1, size_of_tuple/1,
+         base_decode64/1, parse_query/1, bit_array_concat/1, size_of_tuple/1,
          decode_tuple/1, decode_tuple2/1, decode_tuple3/1, decode_tuple4/1,
          decode_tuple5/1, decode_tuple6/1, tuple_get/2, classify_dynamic/1,
          print/1, println/1, print_error/1, println_error/1, inspect/1,
@@ -51,7 +51,7 @@ decode_error(Expected, Got) when is_binary(Expected) andalso is_binary(Got) ->
 classify_dynamic(nil) -> <<"Nil">>;
 classify_dynamic(X) when is_atom(X) -> <<"Atom">>;
 classify_dynamic(X) when is_binary(X) -> <<"String">>;
-classify_dynamic(X) when is_bitstring(X) -> <<"BitString">>;
+classify_dynamic(X) when is_bitstring(X) -> <<"BitArray">>;
 classify_dynamic(X) when is_integer(X) -> <<"Int">>;
 classify_dynamic(X) when is_float(X) -> <<"Float">>;
 classify_dynamic(X) when is_list(X) -> <<"List">>;
@@ -70,8 +70,8 @@ classify_dynamic(_) -> <<"Some other type">>.
 decode_map(Data) when is_map(Data) -> {ok, Data};
 decode_map(Data) -> decode_error_msg(<<"Map">>, Data).
 
-decode_bit_string(Data) when is_bitstring(Data) -> {ok, Data};
-decode_bit_string(Data) -> decode_error_msg(<<"BitString">>, Data).
+decode_bit_array(Data) when is_bitstring(Data) -> {ok, Data};
+decode_bit_array(Data) -> decode_error_msg(<<"BitArray">>, Data).
 
 decode_int(Data) when is_integer(Data) -> {ok, Data};
 decode_int(Data) -> decode_error_msg(<<"Int">>, Data).
@@ -196,22 +196,22 @@ string_pop_grapheme(String) ->
         _ -> {error, nil}
     end.
 
-bit_string_concat(BitStrings) ->
-    list_to_bitstring(BitStrings).
+bit_array_concat(BitArrays) ->
+    list_to_bitstring(BitArrays).
 
-bit_string_slice(Bin, Pos, Len) ->
+bit_array_slice(Bin, Pos, Len) ->
     try {ok, binary:part(Bin, Pos, Len)}
     catch error:badarg -> {error, nil}
     end.
 
-bit_string_int_to_u32(I) when 0 =< I, I < 4294967296 ->
+bit_array_int_to_u32(I) when 0 =< I, I < 4294967296 ->
     {ok, <<I:32>>};
-bit_string_int_to_u32(_) ->
+bit_array_int_to_u32(_) ->
     {error, nil}.
 
-bit_string_int_from_u32(<<I:32>>) ->
+bit_array_int_from_u32(<<I:32>>) ->
     {ok, I};
-bit_string_int_from_u32(_) ->
+bit_array_int_from_u32(_) ->
     {error, nil}.
 
 compile_regex(String, Options) ->
diff --git a/src/gleam_stdlib.mjs b/src/gleam_stdlib.mjs
index 8edbe2f..5c55b24 100644
--- a/src/gleam_stdlib.mjs
+++ b/src/gleam_stdlib.mjs
@@ -1,12 +1,12 @@
 import {
-  BitString,
+  BitArray,
   Error,
   List,
   Ok,
   Result,
   UtfCodepoint,
   stringBits,
-  toBitString,
+  toBitArray,
   NonEmpty,
   CustomType,
   BitArray,
@@ -260,12 +260,12 @@ export function trim_right(string) {
   return string.trimRight();
 }
 
-export function bit_string_from_string(string) {
-  return toBitString([stringBits(string)]);
+export function bit_array_from_string(string) {
+  return toBitArray([stringBits(string)]);
 }
 
-export function bit_string_concat(bit_strings) {
-  return toBitString(bit_strings.toArray().map((b) => b.buffer));
+export function bit_array_concat(bit_arrays) {
+  return toBitArray(bit_arrays.toArray().map((b) => b.buffer));
 }
 
 export function console_log(term) {
@@ -280,10 +280,10 @@ export function crash(message) {
   throw new globalThis.Error(message);
 }
 
-export function bit_string_to_string(bit_string) {
+export function bit_array_to_string(bit_array) {
   try {
     const decoder = new TextDecoder("utf-8", { fatal: true });
-    return new Ok(decoder.decode(bit_string.buffer));
+    return new Ok(decoder.decode(bit_array.buffer));
   } catch (_error) {
     return new Error(Nil);
   }
@@ -360,12 +360,12 @@ export function random_uniform() {
   return random_uniform_result;
 }
 
-export function bit_string_slice(bits, position, length) {
+export function bit_array_slice(bits, position, length) {
   const start = Math.min(position, position + length);
   const end = Math.max(position, position + length);
   if (start < 0 || end > bits.length) return new Error(Nil);
   const buffer = new Uint8Array(bits.buffer.buffer, start, Math.abs(length));
-  return new Ok(new BitString(buffer));
+  return new Ok(new BitArray(buffer));
 }
 
 export function codepoint(int) {
@@ -481,8 +481,8 @@ export function parse_query(query) {
 }
 
 // From https://developer.mozilla.org/en-US/docs/Glossary/Base64#Solution_2_%E2%80%93_rewrite_the_DOMs_atob()_and_btoa()_using_JavaScript's_TypedArrays_and_UTF-8
-export function encode64(bit_string) {
-  const aBytes = bit_string.buffer;
+export function encode64(bit_array) {
+  const aBytes = bit_array.buffer;
   let nMod3 = 2;
   let sB64Enc = "";
 
@@ -562,7 +562,7 @@ export function decode64(sBase64) {
     }
   }
 
-  return new Ok(new BitString(taBytes));
+  return new Ok(new BitArray(taBytes));
 }
 
 export function classify_dynamic(data) {
@@ -572,8 +572,8 @@ export function classify_dynamic(data) {
     return "Result";
   } else if (data instanceof List) {
     return "List";
-  } else if (data instanceof BitString) {
-    return "BitString";
+  } else if (data instanceof BitArray) {
+    return "BitArray";
   } else if (data instanceof PMap) {
     return "Map";
   } else if (Number.isInteger(data)) {
@@ -620,14 +620,14 @@ export function decode_bool(data) {
   return typeof data === "boolean" ? new Ok(data) : decoder_error("Bool", data);
 }
 
-export function decode_bit_string(data) {
-  if (data instanceof BitString) {
+export function decode_bit_array(data) {
+  if (data instanceof BitArray) {
     return new Ok(data);
   }
   if (data instanceof Uint8Array) {
-    return new Ok(new BitString(data));
+    return new Ok(new BitArray(data));
   }
-  return decoder_error("BitString", data);
+  return decoder_error("BitArray", data);
 }
 
 export function decode_tuple(data) {
diff --git a/test/gleam/bytes_builder_test.gleam b/test/gleam/bytes_builder_test.gleam
index acea7ab..208b22c 100644
--- a/test/gleam/bytes_builder_test.gleam
+++ b/test/gleam/bytes_builder_test.gleam
@@ -61,7 +61,7 @@ pub fn concat_test() {
   |> should.equal(<<1, 2, 3, 4, 5, 6>>)
 }
 
-pub fn concat_bit_strings_test() {
+pub fn concat_bit_arrays_test() {
   bytes_builder.concat_bit_arrays([<<"h":utf8>>, <<"e":utf8>>, <<"y":utf8>>])
   |> bytes_builder.to_bit_array
   |> should.equal(<<"hey":utf8>>)
diff --git a/test/gleam/dynamic_test.gleam b/test/gleam/dynamic_test.gleam
index ab25fb8..06941f3 100644
--- a/test/gleam/dynamic_test.gleam
+++ b/test/gleam/dynamic_test.gleam
@@ -4,37 +4,37 @@ import gleam/option.{None, Some}
 import gleam/result
 import gleam/should
 
-pub fn bit_string_test() {
+pub fn bit_array_test() {
   <<>>
   |> dynamic.from
-  |> dynamic.bit_string
+  |> dynamic.bit_array
   |> should.equal(Ok(<<>>))
 
   <<"Hello":utf8>>
   |> dynamic.from
-  |> dynamic.bit_string
+  |> dynamic.bit_array
   |> should.equal(Ok(<<"Hello":utf8>>))
 
   1
   |> dynamic.from
-  |> dynamic.bit_string
+  |> dynamic.bit_array
   |> should.equal(Error([
-    DecodeError(expected: "BitString", found: "Int", path: []),
+    DecodeError(expected: "BitArray", found: "Int", path: []),
   ]))
 
   []
   |> dynamic.from
-  |> dynamic.bit_string
+  |> dynamic.bit_array
   |> should.equal(Error([
-    DecodeError(expected: "BitString", found: "List", path: []),
+    DecodeError(expected: "BitArray", found: "List", path: []),
   ]))
 }
 
 @target(erlang)
-pub fn bit_string_erlang_test() {
+pub fn bit_array_erlang_test() {
   <<65_535:16>>
   |> dynamic.from
-  |> dynamic.bit_string
+  |> dynamic.bit_array
   |> should.equal(Ok(<<65_535:16>>))
 }
 
@@ -43,10 +43,10 @@ pub fn bit_string_erlang_test() {
 fn uint8array(a: List(Int)) -> dynamic.Dynamic
 
 @target(javascript)
-pub fn bit_string_erlang_test() {
+pub fn bit_array_erlang_test() {
   [1, 1, 2, 3, 5, 8]
   |> uint8array
-  |> dynamic.bit_string
+  |> dynamic.bit_array
   |> should.equal(Ok(<<1, 1, 2, 3, 5, 8>>))
 }
 
@@ -107,7 +107,7 @@ pub fn string_non_utf8_test() {
   |> dynamic.from
   |> dynamic.string
   |> should.equal(Error([
-    DecodeError(expected: "String", found: "BitString", path: []),
+    DecodeError(expected: "String", found: "BitArray", path: []),
   ]))
 }
 
diff --git a/test/gleam/string_test.gleam b/test/gleam/string_test.gleam
index f4ff645..c6b9540 100644
--- a/test/gleam/string_test.gleam
+++ b/test/gleam/string_test.gleam
@@ -484,7 +484,7 @@ pub fn utf_codepoint_test() {
   |> should.be_error
 }
 
-pub fn bit_string_utf_codepoint_test() {
+pub fn bit_array_utf_codepoint_test() {
   let assert Ok(snake) = string.utf_codepoint(128_013)
   should.equal(<<snake:utf8_codepoint>>, <<"🐍":utf8>>)
 }
@@ -907,7 +907,7 @@ pub fn target_inspect_test() {
   string.inspect(#(1.0))
   |> should.equal("#(1)")
 
-  // Unlike on Erlang, on JavaScript `BitString` and `String` do have a
+  // Unlike on Erlang, on JavaScript `BitArray` and `String` do have a
   // different runtime representation.
   <<"abc":utf8>>
   |> string.inspect()
@@ -971,7 +971,7 @@ pub fn target_inspect_test() {
   |> regex.check(regular_expression, _)
   |> should.be_true
 
-  // On Erlang the representation between `String` and `BitString` is
+  // On Erlang the representation between `String` and `BitArray` is
   // indistinguishable at runtime.
   <<"abc":utf8>>
   |> string.inspect()