aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorLouis Pilfold <louis@lpil.uk>2023-10-26 11:09:44 +0100
committerLouis Pilfold <louis@lpil.uk>2023-10-26 12:24:40 +0100
commit1de06a549de458ba54d1fae65514930417b836cf (patch)
treeaa0f46defde6bb680c5cf18e5f7ae665c6eeb524
parentb58aea03d84059fbc8ea51ae349fa098a93a82e0 (diff)
downloadgleam_stdlib-1de06a549de458ba54d1fae65514930417b836cf.tar.gz
gleam_stdlib-1de06a549de458ba54d1fae65514930417b836cf.zip
Rename to bit array
-rw-r--r--src/gleam/base.gleam12
-rw-r--r--src/gleam/bit_array.gleam14
-rw-r--r--src/gleam/dynamic.gleam31
-rw-r--r--src/gleam/string.gleam14
-rw-r--r--src/gleam_stdlib.erl26
-rw-r--r--src/gleam_stdlib.mjs38
-rw-r--r--test/gleam/bytes_builder_test.gleam2
-rw-r--r--test/gleam/dynamic_test.gleam24
-rw-r--r--test/gleam/string_test.gleam6
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()