diff options
author | Louis Pilfold <louis@lpil.uk> | 2023-10-26 11:09:44 +0100 |
---|---|---|
committer | Louis Pilfold <louis@lpil.uk> | 2023-10-26 12:24:40 +0100 |
commit | 1de06a549de458ba54d1fae65514930417b836cf (patch) | |
tree | aa0f46defde6bb680c5cf18e5f7ae665c6eeb524 | |
parent | b58aea03d84059fbc8ea51ae349fa098a93a82e0 (diff) | |
download | gleam_stdlib-1de06a549de458ba54d1fae65514930417b836cf.tar.gz gleam_stdlib-1de06a549de458ba54d1fae65514930417b836cf.zip |
Rename to bit array
-rw-r--r-- | src/gleam/base.gleam | 12 | ||||
-rw-r--r-- | src/gleam/bit_array.gleam | 14 | ||||
-rw-r--r-- | src/gleam/dynamic.gleam | 31 | ||||
-rw-r--r-- | src/gleam/string.gleam | 14 | ||||
-rw-r--r-- | src/gleam_stdlib.erl | 26 | ||||
-rw-r--r-- | src/gleam_stdlib.mjs | 38 | ||||
-rw-r--r-- | test/gleam/bytes_builder_test.gleam | 2 | ||||
-rw-r--r-- | test/gleam/dynamic_test.gleam | 24 | ||||
-rw-r--r-- | test/gleam/string_test.gleam | 6 |
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() |