compostjs 0.0.11 → 0.1.0

package/dist/fable-library.2.10.1/Async.js

@@ -1,121 +0,0 @@
-import { OperationCanceledError, Trampoline } from "./AsyncBuilder";
-import { CancellationToken } from "./AsyncBuilder";
-import { protectedCont } from "./AsyncBuilder";
-import { protectedBind } from "./AsyncBuilder";
-import { protectedReturn } from "./AsyncBuilder";
-import { choice1Of2, choice2Of2 } from "./Option";
-import { map } from "./Seq"; // Implemented just for type references
-
-export default class Async {}
-
-function emptyContinuation(_x) {} // NOP
-// MakeAsync: body:(AsyncActivation<'T> -> AsyncReturn) -> Async<'T>
-
-
-export function makeAsync(body) {
-  return body;
-} // Invoke: computation: Async<'T> -> ctxt:AsyncActivation<'T> -> AsyncReturn
-
-export function invoke(computation, ctx) {
-  return computation(ctx);
-} // CallThenInvoke: ctxt:AsyncActivation<'T> -> result1:'U -> part2:('U -> Async<'T>) -> AsyncReturn
-
-export function callThenInvoke(ctx, result1, part2) {
-  return part2(result1)(ctx);
-} // Bind: ctxt:AsyncActivation<'T> -> part1:Async<'U> -> part2:('U -> Async<'T>) -> AsyncReturn
-
-export function bind(ctx, part1, part2) {
-  return protectedBind(part1, part2)(ctx);
-}
-export function createCancellationToken(arg) {
-  const token = new CancellationToken(typeof arg === "boolean" ? arg : false);
-
-  if (typeof arg === "number") {
-    setTimeout(() => {
-      token.cancel();
-    }, arg);
-  }
-
-  return token;
-}
-export function cancel(token) {
-  token.cancel();
-}
-export function cancelAfter(token, ms) {
-  setTimeout(() => {
-    token.cancel();
-  }, ms);
-}
-export function isCancellationRequested(token) {
-  return token != null && token.isCancelled;
-}
-export function startChild(computation) {
-  const promise = startAsPromise(computation); // JS Promises are hot, computation has already started
-  // but we delay returning the result
-
-  return protectedCont(ctx => protectedReturn(awaitPromise(promise))(ctx));
-}
-export function awaitPromise(p) {
-  return fromContinuations(conts => p.then(conts[0]).catch(err => (err instanceof OperationCanceledError ? conts[2] : conts[1])(err)));
-}
-export function cancellationToken() {
-  return protectedCont(ctx => ctx.onSuccess(ctx.cancelToken));
-}
-export const defaultCancellationToken = new CancellationToken();
-export function catchAsync(work) {
-  return protectedCont(ctx => {
-    work({
-      onSuccess: x => ctx.onSuccess(choice1Of2(x)),
-      onError: ex => ctx.onSuccess(choice2Of2(ex)),
-      onCancel: ctx.onCancel,
-      cancelToken: ctx.cancelToken,
-      trampoline: ctx.trampoline
-    });
-  });
-}
-export function fromContinuations(f) {
-  return protectedCont(ctx => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));
-}
-export function ignore(computation) {
-  return protectedBind(computation, _x => protectedReturn(void 0));
-}
-export function parallel(computations) {
-  return awaitPromise(Promise.all(map(w => startAsPromise(w), computations)));
-}
-export function sleep(millisecondsDueTime) {
-  return protectedCont(ctx => {
-    let tokenId;
-    const timeoutId = setTimeout(() => {
-      ctx.cancelToken.removeListener(tokenId);
-      ctx.onSuccess(void 0);
-    }, millisecondsDueTime);
-    tokenId = ctx.cancelToken.addListener(() => {
-      clearTimeout(timeoutId);
-      ctx.onCancel(new OperationCanceledError());
-    });
-  });
-}
-export function start(computation, cancellationToken) {
-  return startWithContinuations(computation, cancellationToken);
-}
-export function startImmediate(computation, cancellationToken) {
-  return start(computation, cancellationToken);
-}
-export function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {
-  if (typeof continuation !== "function") {
-    cancelToken = continuation;
-    continuation = undefined;
-  }
-
-  const trampoline = new Trampoline();
-  computation({
-    onSuccess: continuation ? continuation : emptyContinuation,
-    onError: exceptionContinuation ? exceptionContinuation : emptyContinuation,
-    onCancel: cancellationContinuation ? cancellationContinuation : emptyContinuation,
-    cancelToken: cancelToken ? cancelToken : defaultCancellationToken,
-    trampoline
-  });
-}
-export function startAsPromise(computation, cancellationToken) {
-  return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, cancellationToken ? cancellationToken : defaultCancellationToken));
-}

package/dist/fable-library.2.10.1/AsyncBuilder.js

@@ -1,200 +0,0 @@
-export class CancellationToken {
-  constructor(cancelled = false) {
-    this._id = 0;
-    this._cancelled = cancelled;
-    this._listeners = new Map();
-  }
-
-  get isCancelled() {
-    return this._cancelled;
-  }
-
-  cancel() {
-    if (!this._cancelled) {
-      this._cancelled = true;
-
-      for (const [, listener] of this._listeners) {
-        listener();
-      }
-    }
-  }
-
-  addListener(f) {
-    const id = this._id;
-
-    this._listeners.set(this._id++, f);
-
-    return id;
-  }
-
-  removeListener(id) {
-    return this._listeners.delete(id);
-  }
-
-  register(f, state) {
-    const $ = this;
-    const id = this.addListener(state == null ? f : () => f(state));
-    return {
-      Dispose() {
-        $.removeListener(id);
-      }
-
-    };
-  }
-
-}
-export class OperationCanceledError extends Error {
-  constructor() {
-    super("The operation was canceled");
-    Object.setPrototypeOf(this, OperationCanceledError.prototype);
-  }
-
-}
-export class Trampoline {
-  constructor() {
-    this.callCount = 0;
-  }
-
-  static get maxTrampolineCallCount() {
-    return 2000;
-  }
-
-  incrementAndCheck() {
-    return this.callCount++ > Trampoline.maxTrampolineCallCount;
-  }
-
-  hijack(f) {
-    this.callCount = 0;
-    setTimeout(f, 0);
-  }
-
-}
-export function protectedCont(f) {
-  return ctx => {
-    if (ctx.cancelToken.isCancelled) {
-      ctx.onCancel(new OperationCanceledError());
-    } else if (ctx.trampoline.incrementAndCheck()) {
-      ctx.trampoline.hijack(() => {
-        try {
-          f(ctx);
-        } catch (err) {
-          ctx.onError(err);
-        }
-      });
-    } else {
-      try {
-        f(ctx);
-      } catch (err) {
-        ctx.onError(err);
-      }
-    }
-  };
-}
-export function protectedBind(computation, binder) {
-  return protectedCont(ctx => {
-    computation({
-      onSuccess: x => {
-        try {
-          binder(x)(ctx);
-        } catch (ex) {
-          ctx.onError(ex);
-        }
-      },
-      onError: ctx.onError,
-      onCancel: ctx.onCancel,
-      cancelToken: ctx.cancelToken,
-      trampoline: ctx.trampoline
-    });
-  });
-}
-export function protectedReturn(value) {
-  return protectedCont(ctx => ctx.onSuccess(value));
-}
-export class AsyncBuilder {
-  Bind(computation, binder) {
-    return protectedBind(computation, binder);
-  }
-
-  Combine(computation1, computation2) {
-    return this.Bind(computation1, () => computation2);
-  }
-
-  Delay(generator) {
-    return protectedCont(ctx => generator()(ctx));
-  }
-
-  For(sequence, body) {
-    const iter = sequence[Symbol.iterator]();
-    let cur = iter.next();
-    return this.While(() => !cur.done, this.Delay(() => {
-      const res = body(cur.value);
-      cur = iter.next();
-      return res;
-    }));
-  }
-
-  Return(value) {
-    return protectedReturn(value);
-  }
-
-  ReturnFrom(computation) {
-    return computation;
-  }
-
-  TryFinally(computation, compensation) {
-    return protectedCont(ctx => {
-      computation({
-        onSuccess: x => {
-          compensation();
-          ctx.onSuccess(x);
-        },
-        onError: x => {
-          compensation();
-          ctx.onError(x);
-        },
-        onCancel: x => {
-          compensation();
-          ctx.onCancel(x);
-        },
-        cancelToken: ctx.cancelToken,
-        trampoline: ctx.trampoline
-      });
-    });
-  }
-
-  TryWith(computation, catchHandler) {
-    return protectedCont(ctx => {
-      computation({
-        onSuccess: ctx.onSuccess,
-        onCancel: ctx.onCancel,
-        cancelToken: ctx.cancelToken,
-        trampoline: ctx.trampoline,
-        onError: ex => {
-          try {
-            catchHandler(ex)(ctx);
-          } catch (ex2) {
-            ctx.onError(ex2);
-          }
-        }
-      });
-    });
-  }
-
-  Using(resource, binder) {
-    return this.TryFinally(binder(resource), () => resource.Dispose());
-  }
-
-  While(guard, computation) {
-    if (guard()) {
-      return this.Bind(computation, () => this.While(guard, computation));
-    } else {
-      return this.Return(void 0);
-    }
-  }
-
-  Zero() {
-    return protectedCont(ctx => ctx.onSuccess(void 0));
-  }
-
-}
-export const singleton = new AsyncBuilder();