Add bit_array.split_once

Author: ackurat

Diff for: src/gleam/bit_array.gleam

@@ -59,6 +59,24 @@ pub fn slice(
   take length: Int,
 ) -> Result(BitArray, Nil)
 
+/// Splits a bit array into two parts at the location of the pattern.
+/// 
+/// The result will not include the pattern, and returns an error if the
+/// pattern is not found.
+/// 
+/// ## Examples
+/// 
+/// ```gleam
+/// split_once(from: <<1, 2, 3>>, on: <<2>>)
+/// // -> Ok(#(<<1>>, <<3>>))
+/// ```
+@external(erlang, "gleam_stdlib", "bit_array_split_once")
+@external(javascript, "../gleam_stdlib.mjs", "bit_array_split_once")
+pub fn split_once(
+  from bits: BitArray,
+  on pattern: BitArray,
+) -> Result(#(BitArray, BitArray), Nil)
+
 /// Tests to see whether a bit array is valid UTF-8.
 ///
 pub fn is_utf8(bits: BitArray) -> Bool {

Diff for: src/gleam_stdlib.erl

@@ -14,7 +14,7 @@
     inspect/1, float_to_string/1, int_from_base_string/2,
     utf_codepoint_list_to_string/1, contains_string/2, crop_string/2,
     base16_encode/1, base16_decode/1, string_replace/3, slice/3,
-    bit_array_to_int_and_size/1, bit_array_pad_to_bytes/1
+    bit_array_to_int_and_size/1, bit_array_pad_to_bytes/1, bit_array_split_once/2
 ]).
 
 %% Taken from OTP's uri_string module
@@ -231,6 +231,16 @@ bit_array_slice(Bin, Pos, Len) ->
     catch error:badarg -> {error, nil}
     end.
 
+bit_array_split_once(Bin, Sub) ->
+    try
+        case binary:split(Bin, [Sub]) of
+            [<<>>, <<>>] -> {error, nil};
+            [Part1, Part2] -> {ok, {Part1, Part2}};
+            _ -> {error, nil}
+        end
+    catch error:badarg -> {error, nil}
+    end.
+
 base_decode64(S) ->
     try {ok, base64:decode(S)}
     catch error:_ -> {error, nil}

Diff for: src/gleam_stdlib.mjs

@@ -425,6 +425,30 @@ export function bit_array_slice(bits, position, length) {
   return new Ok(new BitArray(buffer));
 }
 
+export function bit_array_split_once(bits, pattern) {
+  try {
+    if (!(bits instanceof BitArray) || !(pattern instanceof BitArray) || pattern.buffer.length < 1 || pattern.buffer.length >= bits.buffer.length) {
+      return new Error(Nil);
+    }
+
+    let i = 0;
+    const n = bits.buffer.length - pattern.buffer.length + 1;
+
+    find: for (; i < n; i++) {
+      for (let j = 0; j < pattern.buffer.length; j++) {
+        if (bits.buffer[i + j] !== pattern.buffer[j]) continue find;
+      }
+      const before = bits.buffer.slice(0, i);
+      const after = bits.buffer.slice(i + pattern.buffer.length);
+      return new Ok([new BitArray(before), new BitArray(after)]);
+    }
+
+    return new Error(Nil);
+  } catch (e) {
+    return new Error(Nil);
+  }
+}
+
 export function codepoint(int) {
   return new UtfCodepoint(int);
 }

Diff for: test/gleam/bit_array_test.gleam

@@ -202,6 +202,41 @@ pub fn slice_erlang_only_test() {
   |> should.equal(Error(Nil))
 }
 
+pub fn split_once_test() {
+  <<"hello":utf8>>
+  |> bit_array.split_once(<<"l":utf8>>)
+  |> should.equal(Ok(#(<<"he":utf8>>, <<"lo":utf8>>)))
+
+  <<"hello":utf8>>
+  |> bit_array.split_once(<<"o":utf8>>)
+  |> should.equal(Ok(#(<<"hell":utf8>>, <<>>)))
+
+  <<"hello":utf8>>
+  |> bit_array.split_once(<<"h":utf8>>)
+  |> should.equal(Ok(#(<<>>, <<"ello":utf8>>)))
+
+  <<"hello":utf8>>
+  |> bit_array.split_once(<<1>>)
+  |> should.equal(Error(Nil))
+
+  <<"hello":utf8>>
+  |> bit_array.split_once(<<"":utf8>>)
+  |> should.equal(Error(Nil))
+
+  <<"hello":utf8>>
+  |> bit_array.split_once(<<"hello":utf8>>)
+  |> should.equal(Error(Nil))
+}
+
+// This test is target specific since it's using non byte-aligned BitArrays
+// and those are not supported on the JavaScript target.
+@target(erlang)
+pub fn split_once_erlang_only_test() {
+  <<0, 1, 2:7>>
+  |> bit_array.split_once(<<1>>)
+  |> should.equal(Error(Nil))
+}
+
 pub fn to_string_test() {
   <<>>
   |> bit_array.to_string