@fable-org/fable-library-ts 1.5.0 → 1.7.0

package/Async.ts

@@ -1,40 +1,33 @@
 import { OperationCanceledError, Trampoline } from "./AsyncBuilder.js";
 import { Continuation, Continuations } from "./AsyncBuilder.js";
-import { CancellationToken } from "./AsyncBuilder.js";
-import { IAsync } from "./AsyncBuilder.js";
-import { IAsyncContext } from "./AsyncBuilder.js";
-import { protectedCont } from "./AsyncBuilder.js";
-import { protectedBind } from "./AsyncBuilder.js";
-import { protectedReturn } from "./AsyncBuilder.js";
+import { Async, IAsyncContext, CancellationToken } from "./AsyncBuilder.js";
+import { protectedCont, protectedBind, protectedReturn } from "./AsyncBuilder.js";
 import { FSharpChoice$2_$union, Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from "./Choice.js";
 import { TimeoutException } from "./SystemException.js";
 
-// Implemented just for type references
-export class Async<_T> { }
-
 function emptyContinuation<T>(_x: T) {
   // NOP
 }
 
 // see AsyncBuilder.Delay
-function delay<T>(generator: () => IAsync<T>) {
+function delay<T>(generator: () => Async<T>) {
   return protectedCont((ctx: IAsyncContext<T>) => generator()(ctx));
 }
 
 // MakeAsync: body:(AsyncActivation<'T> -> AsyncReturn) -> Async<'T>
-export function makeAsync<T>(body: IAsync<T>) {
+export function makeAsync<T>(body: Async<T>) {
   return body;
 }
 // Invoke: computation: Async<'T> -> ctxt:AsyncActivation<'T> -> AsyncReturn
-export function invoke<T>(computation: IAsync<T>, ctx: IAsyncContext<T>) {
+export function invoke<T>(computation: Async<T>, ctx: IAsyncContext<T>) {
   return computation(ctx);
 }
 // CallThenInvoke: ctxt:AsyncActivation<'T> -> result1:'U -> part2:('U -> Async<'T>) -> AsyncReturn
-export function callThenInvoke<T, U>(ctx: IAsyncContext<T>, result1: U, part2: (x: U) => IAsync<T>) {
+export function callThenInvoke<T, U>(ctx: IAsyncContext<T>, result1: U, part2: (x: U) => Async<T>) {
   return part2(result1)(ctx);
 }
 // Bind: ctxt:AsyncActivation<'T> -> part1:Async<'U> -> part2:('U -> Async<'T>) -> AsyncReturn
-export function bind<T, U>(ctx: IAsyncContext<T>, part1: IAsync<U>, part2: (x: U) => IAsync<T>) {
+export function bind<T, U>(ctx: IAsyncContext<T>, part1: Async<U>, part2: (x: U) => Async<T>) {
   return protectedBind(part1, part2)(ctx);
 }
 
@@ -64,7 +57,7 @@ export function throwIfCancellationRequested(token: CancellationToken) {
   }
 }
 
-function throwAfter(millisecondsDueTime: number) : IAsync<void> {
+function throwAfter(millisecondsDueTime: number): Async<void> {
   return protectedCont((ctx: IAsyncContext<void>) => {
     let tokenId: number;
     const timeoutId = setTimeout(() => {
@@ -78,7 +71,7 @@ function throwAfter(millisecondsDueTime: number) : IAsync<void> {
   });
 }
 
-export function startChild<T>(computation: IAsync<T>, ms?: number): IAsync<IAsync<T>> {
+export function startChild<T>(computation: Async<T>, ms?: number): Async<Async<T>> {
   if (ms) {
     const computationWithTimeout = protectedBind(
       parallel2(
@@ -110,7 +103,7 @@ export function cancellationToken() {
 
 export const defaultCancellationToken = new CancellationToken();
 
-export function catchAsync<T>(work: IAsync<T>) {
+export function catchAsync<T>(work: Async<T>) {
   return protectedCont((ctx: IAsyncContext<FSharpChoice$2_$union<T, Error>>) => {
     work({
       onSuccess: (x) => ctx.onSuccess(Choice_makeChoice1Of2(x)),
@@ -127,21 +120,21 @@ export function fromContinuations<T>(f: (conts: Continuations<T>) => void) {
     f([ctx.onSuccess, ctx.onError, ctx.onCancel]));
 }
 
-export function ignore<T>(computation: IAsync<T>) {
+export function ignore<T>(computation: Async<T>) {
   return protectedBind(computation, (_x) => protectedReturn(void 0));
 }
 
-export function parallel<T>(computations: Iterable<IAsync<T>>) {
+export function parallel<T>(computations: Iterable<Async<T>>) {
   return delay(() => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w)))));
 }
 
-function parallel2<T, U>(a: IAsync<T>, b: IAsync<U>): IAsync<[T, U]> {
-  return delay(() => awaitPromise(Promise.all([ startAsPromise(a), startAsPromise(b) ])));
+function parallel2<T, U>(a: Async<T>, b: Async<U>): Async<[T, U]> {
+  return delay(() => awaitPromise(Promise.all([startAsPromise(a), startAsPromise(b)])));
 }
 
-export function sequential<T>(computations: Iterable<IAsync<T>>) {
+export function sequential<T>(computations: Iterable<Async<T>>) {
 
-  function _sequential<T>(computations: Iterable<IAsync<T>>): Promise<T[]> {
+  function _sequential<T>(computations: Iterable<Async<T>>): Promise<T[]> {
     let pr: Promise<T[]> = Promise.resolve([]);
     for (const c of computations) {
       pr = pr.then(results => startAsPromise(c).then(r => results.concat([r])))
@@ -170,16 +163,16 @@ export function runSynchronously(): never {
   throw new Error("Asynchronous code cannot be run synchronously in JS");
 }
 
-export function start<T>(computation: IAsync<T>, cancellationToken?: CancellationToken) {
+export function start<T>(computation: Async<T>, cancellationToken?: CancellationToken) {
   return startWithContinuations(computation, cancellationToken);
 }
 
-export function startImmediate<T>(computation: IAsync<T>, cancellationToken?: CancellationToken) {
+export function startImmediate<T>(computation: Async<T>, cancellationToken?: CancellationToken) {
   return start(computation, cancellationToken);
 }
 
 export function startWithContinuations<T>(
-  computation: IAsync<T>,
+  computation: Async<T>,
   continuation?: Continuation<T> | CancellationToken,
   exceptionContinuation?: Continuation<any>,
   cancellationContinuation?: Continuation<any>,
@@ -198,10 +191,8 @@ export function startWithContinuations<T>(
   });
 }
 
-export function startAsPromise<T>(computation: IAsync<T>, cancellationToken?: CancellationToken) {
+export function startAsPromise<T>(computation: Async<T>, cancellationToken?: CancellationToken) {
   return new Promise((resolve: Continuation<T>, reject: Continuation<any>) =>
     startWithContinuations(computation, resolve, reject, reject,
       cancellationToken ? cancellationToken : defaultCancellationToken));
 }
-
-export default Async;

package/AsyncBuilder.ts

@@ -86,9 +86,9 @@ export interface IAsyncContext<T> {
   trampoline: Trampoline;
 }
 
-export type IAsync<T> = (x: IAsyncContext<T>) => void;
+export type Async<T> = (x: IAsyncContext<T>) => void;
 
-export function protectedCont<T>(f: IAsync<T>) {
+export function protectedCont<T>(f: Async<T>) {
   return (ctx: IAsyncContext<T>) => {
     if (ctx.cancelToken.isCancelled) {
       ctx.onCancel(new OperationCanceledError());
@@ -110,7 +110,7 @@ export function protectedCont<T>(f: IAsync<T>) {
   };
 }
 
-export function protectedBind<T, U>(computation: IAsync<T>, binder: (x: T) => IAsync<U>) {
+export function protectedBind<T, U>(computation: Async<T>, binder: (x: T) => Async<U>) {
   return protectedCont((ctx: IAsyncContext<U>) => {
     computation({
       onSuccess: (x: T) => {
@@ -133,19 +133,19 @@ export function protectedReturn<T>(value: T) {
 }
 
 export class AsyncBuilder {
-  public Bind<T, U>(computation: IAsync<T>, binder: (x: T) => IAsync<U>) {
+  public Bind<T, U>(computation: Async<T>, binder: (x: T) => Async<U>) {
     return protectedBind(computation, binder);
   }
 
-  public Combine<T>(computation1: IAsync<void>, computation2: IAsync<T>) {
+  public Combine<T>(computation1: Async<void>, computation2: Async<T>) {
     return this.Bind(computation1, () => computation2);
   }
 
-  public Delay<T>(generator: () => IAsync<T>) {
+  public Delay<T>(generator: () => Async<T>) {
     return protectedCont((ctx: IAsyncContext<T>) => generator()(ctx));
   }
 
-  public For<T>(sequence: Iterable<T>, body: (x: T) => IAsync<void>) {
+  public For<T>(sequence: Iterable<T>, body: (x: T) => Async<void>) {
     const iter = sequence[Symbol.iterator]();
     let cur = iter.next();
     return this.While(() => !cur.done, this.Delay(() => {
@@ -155,15 +155,15 @@ export class AsyncBuilder {
     }));
   }
 
-  public Return<T>(value?: T) {
+  public Return<T>(value: T) {
     return protectedReturn(value);
   }
 
-  public ReturnFrom<T>(computation: IAsync<T>) {
+  public ReturnFrom<T>(computation: Async<T>) {
     return computation;
   }
 
-  public TryFinally<T>(computation: IAsync<T>, compensation: () => void) {
+  public TryFinally<T>(computation: Async<T>, compensation: () => void) {
     return protectedCont((ctx: IAsyncContext<T>) => {
       computation({
         onSuccess: (x: T) => {
@@ -184,7 +184,7 @@ export class AsyncBuilder {
     });
   }
 
-  public TryWith<T>(computation: IAsync<T>, catchHandler: (e: any) => IAsync<T>) {
+  public TryWith<T>(computation: Async<T>, catchHandler: (e: any) => Async<T>) {
     return protectedCont((ctx: IAsyncContext<T>) => {
       computation({
         onSuccess: ctx.onSuccess,
@@ -202,11 +202,11 @@ export class AsyncBuilder {
     });
   }
 
-  public Using<T extends IDisposable, U>(resource: T, binder: (x: T) => IAsync<U>) {
+  public Using<T extends IDisposable, U>(resource: T, binder: (x: T) => Async<U>) {
     return this.TryFinally(binder(resource), () => resource.Dispose());
   }
 
-  public While(guard: () => boolean, computation: IAsync<void>): IAsync<void> {
+  public While(guard: () => boolean, computation: Async<void>): Async<void> {
     if (guard()) {
       return this.Bind(computation, () => this.While(guard, computation));
     } else {

package/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 1.7.0 - 2024-11-19
+
+### Fixed
+
+* [JS/TS] Added missing IReadOnlyCollection helpers (#3953)
+
+## 1.6.0 - 2024-10-02
+
+### Removed
+
+* Remove `Async` (from `Async.ts`) class (by @MangelMaxime)
+
+### Changed
+
+* Renamed `IAsync` to `Async` in `AsyncBuilder.ts` (#3906) (by @ncave)
+
 ## 1.5.0 - 2024-09-19
 
 ### Added

package/CollectionUtil.ts

@@ -0,0 +1,161 @@
+import { equals, isArrayLike } from "./Util.js";
+
+export function count<T>(col: Iterable<T>): number {
+  if (typeof (col as any)["System.Collections.Generic.ICollection`1.get_Count"] === "function") {
+    return (col as any)["System.Collections.Generic.ICollection`1.get_Count"](); // collection
+  } else {
+    if (typeof (col as any)["System.Collections.Generic.IReadOnlyCollection`1.get_Count"] === "function") {
+      return (col as any)["System.Collections.Generic.IReadOnlyCollection`1.get_Count"](); // collection
+    } else {
+      if (isArrayLike(col)) {
+        return col.length; // array, resize array
+      } else {
+        if (typeof (col as any).size === "number") {
+          return (col as any).size; // map, set
+        } else {
+          let count = 0;
+          for (const _ of col) {
+            count++;
+          }
+          return count; // other collections
+        }
+      }
+    }
+  }
+}
+
+export function isReadOnly<T>(col: Iterable<T>): boolean {
+  if (typeof (col as any)["System.Collections.Generic.ICollection`1.get_IsReadOnly"] === "function") {
+    return (col as any)["System.Collections.Generic.ICollection`1.get_IsReadOnly"](); // collection
+  } else {
+    if (isArrayLike(col)) {
+      return ArrayBuffer.isView(col); // true for typed arrays, false for other arrays
+    } else {
+      if (typeof (col as any).size === "number") {
+        return false; // map, set
+      } else {
+        return true; // other collections
+      }
+    }
+
+  }
+}
+
+export function copyTo<T>(col: Iterable<T>, array: T[], arrayIndex: number) {
+  if (typeof (col as any)["System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"] === "function") {
+    (col as any)["System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"](array, arrayIndex); // collection
+  } else {
+    let i = arrayIndex;
+    for (const v of col) {
+      array[i] = v;
+      i++;
+    }
+  }
+}
+
+export function contains<T>(col: Iterable<T>, item: T): boolean {
+  if (typeof (col as any)["System.Collections.Generic.ICollection`1.Contains2B595"] === "function") {
+    return (col as any)["System.Collections.Generic.ICollection`1.Contains2B595"](item); // collection
+  } else {
+    if (isArrayLike(col)) {
+      let i = col.findIndex(x => equals(x, item)); // array, resize array
+      return i >= 0;
+    } else {
+      if (typeof (col as any).has === "function") {
+        if (typeof (col as any).set === "function" && isArrayLike(item)) {
+          return (col as any).has(item[0]) && equals((col as any).get(item[0]), item[1]); // map
+        } else {
+          return (col as any).has(item); // set
+        }
+      } else {
+        return false; // other collections
+      }
+    }
+  }
+}
+
+export function add<T>(col: Iterable<T>, item: T): void {
+  if (typeof (col as any)["System.Collections.Generic.ICollection`1.Add2B595"] === "function") {
+    return (col as any)["System.Collections.Generic.ICollection`1.Add2B595"](item); // collection
+  } else {
+    if (isArrayLike(col)) {
+      if (ArrayBuffer.isView(col)) {
+        // TODO: throw for typed arrays?
+      } else {
+        col.push(item); // array, resize array
+      }
+    } else {
+      if (typeof (col as any).add === "function") {
+        return (col as any).add(item); // set
+      } else {
+        if (typeof (col as any).has === "function"
+          && typeof (col as any).set === "function"
+          && isArrayLike(item)) {
+          if ((col as any).has(item[0]) === false) {
+            (col as any).set(item[0], item[1]); // map
+          } else {
+            throw new Error("An item with the same key has already been added. Key: " + item[0]);
+          }
+        } else {
+          // TODO: throw for other collections?
+        }
+      }
+    }
+  }
+}
+
+export function remove<T>(col: Iterable<T>, item: T): boolean {
+  if (typeof (col as any)["System.Collections.Generic.ICollection`1.Remove2B595"] === "function") {
+    return (col as any)["System.Collections.Generic.ICollection`1.Remove2B595"](item); // collection
+  } else {
+    if (isArrayLike(col)) {
+      if (ArrayBuffer.isView(col)) {
+        // TODO: throw for typed arrays
+        return false;
+      } else {
+        let i = col.findIndex(x => equals(x, item));
+        if (i >= 0) {
+          col.splice(i, 1); // array, resize array
+          return true;
+        } else {
+          return false;
+        }
+      }
+    } else {
+      if (typeof (col as any).delete === "function") {
+        if (typeof (col as any).set === "function" && isArrayLike(item)) {
+          if ((col as any).has(item[0]) && equals((col as any).get(item[0]), item[1])) {
+            return (col as any).delete(item[0]); // map
+          } else {
+            return false;
+          }
+        } else {
+          return (col as any).delete(item); // set
+        }
+      } else {
+        // TODO: throw for other collections?
+        return false; // other collections
+      }
+    }
+  }
+}
+
+export function clear<T>(col: Iterable<T>): void {
+  if (typeof (col as any)["System.Collections.Generic.ICollection`1.Clear"] === "function") {
+    return (col as any)["System.Collections.Generic.ICollection`1.Clear"](); // collection
+  } else {
+    if (isArrayLike(col)) {
+      if (ArrayBuffer.isView(col)) {
+        // TODO: throw for typed arrays?
+      } else {
+        col.splice(0); // array, resize array
+      }
+    } else {
+      if (typeof (col as any).clear === "function") {
+        (col as any).clear(); // map, set
+      } else {
+        // TODO: throw for other collections?
+      }
+    }
+  }
+}

package/MailboxProcessor.ts

@@ -1,7 +1,7 @@
 import { defaultCancellationToken } from "./Async.js";
 import { fromContinuations } from "./Async.js";
 import { startImmediate } from "./Async.js";
-import { IAsync } from "./AsyncBuilder.js";
+import { Async } from "./AsyncBuilder.js";
 import { Continuation, Continuations } from "./AsyncBuilder.js";
 import { CancellationToken } from "./AsyncBuilder.js";
 
@@ -41,7 +41,7 @@ class MailboxQueue<Msg> {
   }
 }
 
-export type MailboxBody<Msg> = (m: MailboxProcessor<Msg>) => IAsync<void>;
+export type MailboxBody<Msg> = (m: MailboxProcessor<Msg>) => Async<void>;
 
 export interface AsyncReplyChannel<Reply> {
   reply: (r: Reply) => void;

package/String.ts

@@ -63,7 +63,7 @@ export function compareTo(x: string, y: string) {
   return cmp(x, y, StringComparison.CurrentCulture);
 }
 
-export function startsWith(str: string, pattern: string, ic: number) {
+export function startsWith(str: string, pattern: string, ic: boolean | StringComparison) {
   if (ic === StringComparison.Ordinal) { // to avoid substring allocation
     return str.startsWith(pattern);
   }
@@ -73,7 +73,7 @@ export function startsWith(str: string, pattern: string, ic: number) {
   return false;
 }
 
-export function endsWith(str: string, pattern: string, ic: number) {
+export function endsWith(str: string, pattern: string, ic: boolean | StringComparison) {
   if (ic === StringComparison.Ordinal) { // to avoid substring allocation
     return str.endsWith(pattern);
   }

package/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "type": "module",
   "name": "@fable-org/fable-library-ts",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "Core library used by F# projects compiled with fable.io",
   "author": "Fable Contributors",
   "license": "MIT",