@fable-org/fable-library-ts 1.0.0-beta-001

package/Long.ts

@@ -0,0 +1,49 @@
+import { getPrefix, isValid } from "./Int32.js";
+import { fromString } from "./BigInt.js";
+import { FSharpRef } from "./Types.js";
+
+function getMaxValue(unsigned: boolean, radix: number, isNegative: boolean) {
+  switch (radix) {
+    case 2: return unsigned ?
+      "1111111111111111111111111111111111111111111111111111111111111111" :
+      (isNegative ? "1000000000000000000000000000000000000000000000000000000000000000"
+        : "111111111111111111111111111111111111111111111111111111111111111");
+    case 8: return unsigned ?
+      "1777777777777777777777" :
+      (isNegative ? "1000000000000000000000" : "777777777777777777777");
+    case 10: return unsigned ?
+      "18446744073709551615" :
+      (isNegative ? "9223372036854775808" : "9223372036854775807");
+    case 16: return unsigned ?
+      "FFFFFFFFFFFFFFFF" :
+      (isNegative ? "8000000000000000" : "7FFFFFFFFFFFFFFF");
+    default: throw new Error("Invalid radix.");
+  }
+}
+
+export function parse(str: string, style: number, unsigned: boolean, _bitsize: number, radix?: number) {
+  const res = isValid(str, style, radix);
+  if (res != null) {
+    const lessOrEqual = (x: string, y: string) => {
+      const len = Math.max(x.length, y.length);
+      return x.padStart(len, "0") <= y.padStart(len, "0");
+    };
+    const isNegative = res.sign === "-";
+    const maxValue = getMaxValue(unsigned || res.radix !== 10, res.radix, isNegative);
+    if (lessOrEqual(res.digits.toUpperCase(), maxValue)) {
+      str = getPrefix(res.radix) + res.digits;
+      str = isNegative ? res.sign + str : str;
+      return fromString(str);
+    }
+  }
+  throw new Error(`The input string ${str} was not in a correct format.`);
+}
+
+export function tryParse(str: string, style: number, unsigned: boolean, bitsize: number, defValue: FSharpRef<bigint>) {
+  try {
+    defValue.contents = parse(str, style, unsigned, bitsize);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/MailboxProcessor.ts

@@ -0,0 +1,125 @@
+import { defaultCancellationToken } from "./Async.js";
+import { fromContinuations } from "./Async.js";
+import { startImmediate } from "./Async.js";
+import { IAsync } from "./AsyncBuilder.js";
+import { Continuation, Continuations } from "./AsyncBuilder.js";
+import { CancellationToken } from "./AsyncBuilder.js";
+
+class QueueCell<Msg> {
+  public value: Msg;
+  public next?: QueueCell<Msg>;
+
+  constructor(message: Msg) {
+    this.value = message;
+  }
+}
+
+class MailboxQueue<Msg> {
+  private firstAndLast?: [QueueCell<Msg>, QueueCell<Msg>];
+
+  public add(message: Msg) {
+    const itCell = new QueueCell(message);
+    if (this.firstAndLast) {
+      this.firstAndLast[1].next = itCell;
+      this.firstAndLast = [this.firstAndLast[0], itCell];
+    } else {
+      this.firstAndLast = [itCell, itCell];
+    }
+  }
+
+  public tryGet() {
+    if (this.firstAndLast) {
+      const value = this.firstAndLast[0].value;
+      if (this.firstAndLast[0].next) {
+        this.firstAndLast = [this.firstAndLast[0].next, this.firstAndLast[1]];
+      } else {
+        delete this.firstAndLast;
+      }
+      return value;
+    }
+    return void 0;
+  }
+}
+
+export type MailboxBody<Msg> = (m: MailboxProcessor<Msg>) => IAsync<void>;
+
+export interface AsyncReplyChannel<Reply> {
+  reply: (r: Reply) => void;
+}
+
+export class MailboxProcessor<Msg> {
+  public body: MailboxBody<Msg>;
+  public cancellationToken: CancellationToken;
+  public messages: MailboxQueue<Msg>;
+
+  public continuation?: Continuation<Msg>;
+
+  constructor(body: MailboxBody<Msg>, cancellationToken?: CancellationToken) {
+    this.body = body;
+    this.cancellationToken = cancellationToken || defaultCancellationToken;
+    this.messages = new MailboxQueue<Msg>();
+  }
+}
+
+function __processEvents<Msg>($this: MailboxProcessor<Msg>) {
+  if ($this.continuation) {
+    const value = $this.messages.tryGet();
+    if (value) {
+      const cont = $this.continuation;
+      delete $this.continuation;
+      cont(value);
+    }
+  }
+}
+
+export function startInstance<Msg>($this: MailboxProcessor<Msg>) {
+  startImmediate($this.body($this), $this.cancellationToken);
+}
+
+export function receive<Msg>($this: MailboxProcessor<Msg>) {
+  return fromContinuations((conts: Continuations<Msg>) => {
+    if ($this.continuation) {
+      throw new Error("Receive can only be called once!");
+    }
+    $this.continuation = conts[0];
+    __processEvents($this);
+  });
+}
+
+export function post<Msg>($this: MailboxProcessor<Msg>, message: Msg) {
+  $this.messages.add(message);
+  __processEvents($this);
+}
+
+export function postAndAsyncReply<Reply, Msg>(
+  $this: MailboxProcessor<Msg>,
+  buildMessage: (c: AsyncReplyChannel<Reply>) => Msg,
+) {
+  let result: Reply;
+  let continuation: Continuation<Reply>;
+  function checkCompletion() {
+    if (result !== void 0 && continuation !== void 0) {
+      continuation(result);
+    }
+  }
+  const reply = {
+    reply: (res: Reply) => {
+      result = res;
+      checkCompletion();
+    },
+  };
+  $this.messages.add(buildMessage(reply));
+  __processEvents($this);
+  return fromContinuations((conts: Continuations<Reply>) => {
+    continuation = conts[0];
+    checkCompletion();
+  });
+}
+
+export function start<Msg>(body: MailboxBody<Msg>, cancellationToken?: CancellationToken) {
+  const mbox = new MailboxProcessor(body, cancellationToken);
+  startInstance(mbox);
+  return mbox;
+}
+
+export default MailboxProcessor;