Add bit array FFI functions

Author: lpil

CHANGELOG.md

@@ -20,6 +20,10 @@
 
   ([Adi Salimgereyev](https://github.com/abs0luty))
 
+- The JavaScript prelude JavaScript API now contains the `BitArray$isBitArray`
+  and `BitArray$BitArray$data` functions.
+  ([Louis Pilfold](https://github.com/lpil))
+
 ### Build tool
 
 - When adding a package that does not exist on Hex, the message is a bit

compiler-core/templates/prelude.d.mts

@@ -31,8 +31,8 @@ export const List: {
 }
 export function List$Empty<T>(): List<T>;
 export function List$NonEmpty<T>(head: T, tail: List<T>): List<T>;
-export function List$isEmpty<T>(list: List<T>): boolean;
-export function List$isNonEmpty<T>(list: List<T>): boolean;
+export function List$isEmpty(list: any): boolean;
+export function List$isNonEmpty(list: any): boolean;
 export function List$NonEmpty$first<T>(list: List<T>): T | undefined;
 export function List$NonEmpty$rest<T>(list: List<T>): List<T> | undefined;
 /** @deprecated */
@@ -72,6 +72,8 @@ export function BitArray$BitArray(
   bitSize: number,
   bitOffset: number,
 ): BitArray;
+export function BitArray$isBitArray(value: any): boolean;
+export function BitArray$BitArray$data(value: BitArray): DataView;
 
 export interface UtfCodepoint {
   readonly __gleam: unique symbol;
@@ -95,8 +97,8 @@ export const Result: {
 }
 export function Result$Ok<T, E>(value: T): Result<T, E>;
 export function Result$Error<T, E>(error: E): Result<T, E>;
-export function Result$isError<T, E>(result: Result<T, E>): boolean;
-export function Result$isOk<T, E>(result: Result<T, E>): boolean;
+export function Result$isError(data: any): boolean;
+export function Result$isOk(data: any): boolean;
 export function Result$Ok$0<T, E>(result: Result<T, E>): T | undefined;
 export function Result$Error$0<T, E>(result: Result<T, E>): E | undefined;
 /** @deprecated */

compiler-core/templates/prelude.mjs

@@ -262,16 +262,11 @@ export class BitArray {
   /**
    * Returns this bit array's internal buffer.
    *
-   * @deprecated Use `BitArray.byteAt()` or `BitArray.rawBuffer` instead.
+   * @deprecated
    *
    * @returns {Uint8Array}
    */
   get buffer() {
-    bitArrayPrintDeprecationWarning(
-      "buffer",
-      "Use BitArray.byteAt() or BitArray.rawBuffer instead",
-    );
-
     if (this.bitOffset !== 0 || this.bitSize % 8 !== 0) {
       throw new globalThis.Error(
         "BitArray.buffer does not support unaligned bit arrays",
@@ -284,16 +279,11 @@ export class BitArray {
   /**
    * Returns the length in bytes of this bit array's internal buffer.
    *
-   * @deprecated Use `BitArray.bitSize` or `BitArray.byteSize` instead.
+   * @deprecated
    *
    * @returns {number}
    */
   get length() {
-    bitArrayPrintDeprecationWarning(
-      "length",
-      "Use BitArray.bitSize or BitArray.byteSize instead",
-    );
-
     if (this.bitOffset !== 0 || this.bitSize % 8 !== 0) {
       throw new globalThis.Error(
         "BitArray.length does not support unaligned bit arrays",
@@ -306,6 +296,11 @@ export class BitArray {
 
 export const BitArray$BitArray = (buffer, bitSize, bitOffset) =>
   new BitArray(buffer, bitSize, bitOffset);
+export const BitArray$isBitArray = (value) => value instanceof BitArray;
+export const BitArray$BitArray$data = (bitArray) => {
+  const array = bitArray.rawBuffer;
+  return new DataView(array.buffer, array.byteOffest, bitArray.byteLength);
+};
 
 /**
  * Returns the nth byte in the given buffer, after applying the specified bit
@@ -333,19 +328,6 @@ export class UtfCodepoint {
   }
 }
 
-const isBitArrayDeprecationMessagePrinted = {};
-function bitArrayPrintDeprecationWarning(name, message) {
-  if (isBitArrayDeprecationMessagePrinted[name]) {
-    return;
-  }
-
-  console.warn(
-    `Deprecated BitArray.${name} property used in JavaScript FFI code. ${message}.`,
-  );
-
-  isBitArrayDeprecationMessagePrinted[name] = true;
-}
-
 /**
  * Slices a bit array to produce a new bit array. If `end` is not supplied then
  * all bits from `start` onward are returned.

test/javascript_prelude/main.mjs

@@ -1,5 +1,8 @@
 import {
   BitArray,
+  BitArray$BitArray,
+  BitArray$BitArray$data,
+  BitArray$isBitArray,
   CustomType,
   Error,
   List,
@@ -66,6 +69,14 @@ function assertThrows(msg, callable) {
   }
 }
 
+function assert(msg, value) {
+  if (value) {
+    pass();
+  } else {
+    fail(msg);
+  }
+}
+
 class ExampleRecordImpl extends CustomType {
   constructor(first, detail, boop) {
     super();
@@ -1172,6 +1183,47 @@ assertEqual(new BitArray(new Uint8Array([1, 2])).byteSize, 2);
 assertEqual(new BitArray(new Uint8Array([1, 2, 3, 4])).byteSize, 4);
 assertEqual(new BitArray(new Uint8Array([1, 2, 3, 4], 28)).byteSize, 4);
 
+// BitArray
+
+assert("numbers are not bit arrays", !BitArray$isBitArray(123));
+assert("strings are not bit arrays", !BitArray$isBitArray("!"));
+assert("results are not bit arrays", new Ok("!"));
+assert(
+  "Bit arrays are bit arrays",
+  BitArray$isBitArray(BitArray$BitArray(new Uint8Array([]))),
+);
+
+// Byte aligned bit array
+{
+  const bitArray = BitArray$BitArray(new Uint8Array([1, 2, 3]));
+  assertEqual(bitArray.bitSize, 3 * 8);
+  assertEqual(bitArray.byteSize, 3);
+  assertEqual(bitArray.bitOffset, 0);
+  assertEqual(bitArray.rawBuffer, new Uint8Array([1, 2, 3]));
+  assertEqual(
+    BitArray$BitArray$data(bitArray),
+    new DataView(new Uint8Array([1, 2, 3]).buffer),
+  );
+}
+
+// Non-byte aligned bit array
+{
+  const bitArray = BitArray$BitArray(new Uint8Array([1, 2, 3]), 23, 1);
+  assertEqual(bitArray.bitSize, 23);
+  assertEqual(bitArray.byteSize, 3);
+  assertEqual(bitArray.bitOffset, 1);
+  assertEqual(bitArray.rawBuffer, new Uint8Array([1, 2, 3]));
+  assertEqual(
+    BitArray$BitArray$data(bitArray),
+    new DataView(new Uint8Array([1, 2, 3]).buffer),
+  );
+}
+
+assertEqual(
+  BitArray$BitArray(new Uint8Array([])),
+  new BitArray(new Uint8Array([])),
+);
+
 //
 // Division
 //