@typed/fx 0.0.6 → 0.0.8

package/esm/Supervisor/inheritFiberRefs.js

@@ -0,0 +1,14 @@
+import { isRight } from 'hkt-ts/Either';
+import { isJust } from 'hkt-ts/Maybe';
+import { None } from './Supervisor.js';
+import { join } from "../FiberRefs/FiberRefs.js";
+export const inheritFiberRefs = None.extend({
+    onEnd: () => (fiber, exit) => {
+        const parentContext = fiber.context.parent;
+        // Merge FiberRefs upon successful completion
+        if (isRight(exit) && isJust(parentContext)) {
+            join(parentContext.value.fiberRefs, fiber.context.fiberRefs);
+        }
+    },
+});
+//# sourceMappingURL=inheritFiberRefs.js.map

package/esm/Supervisor/inheritFiberRefs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inheritFiberRefs.js","sourceRoot":"","sources":["../../src/Supervisor/inheritFiberRefs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAErC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAEtC,OAAO,EAAE,IAAI,EAAE,kCAAgC;AAE/C,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,CAAC,MAAM,CAAC;IAC1C,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QAC3B,MAAM,aAAa,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAA;QAE1C,6CAA6C;QAC7C,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,aAAa,CAAC,EAAE;YAC1C,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;SAC7D;IACH,CAAC;CACF,CAAC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typed/fx",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "High-performance Asynchronous Effects",
   "type": "module",
   "main": "esm/index.js",
@@ -25,7 +25,7 @@
     "preversion": "npm test",
     "postversion": "npm run build && npm publish --access=public",
     "prepare": "ts-patch install -s",
-    "example": "node --loader @esbuild-kit/esm-loader --experimental-specifier-resolution=node ./src/example.ts"
+    "perf:stream:filter-map-reduce": "node --loader @esbuild-kit/esm-loader perf/Stream-filter-map-reduce.test.ts"
   },
   "keywords": [
     "Fx",
@@ -51,12 +51,17 @@
   },
   "devDependencies": {
     "@esbuild-kit/esm-loader": "^2.4.2",
+    "@most/core": "^1.6.1",
+    "@most/scheduler": "^1.3.0",
+    "@most/types": "^1.1.0",
+    "@types/benchmark": "^2.1.2",
     "@types/mocha": "^9.1.1",
     "@types/node": "^17.0.45",
     "@types/prettier": "^2.7.0",
     "@typescript-eslint/eslint-plugin": "^5.34.0",
     "@typescript-eslint/parser": "^5.34.0",
     "@zoltu/typescript-transformer-append-js-extension": "^1.0.1",
+    "benchmark": "^2.1.4",
     "c8": "^7.12.0",
     "concurrently": "^7.3.0",
     "eslint": "^8.22.0",
@@ -71,6 +76,7 @@
     "lint-staged": "^12.5.0",
     "mocha": "^10.0.0",
     "prettier": "^2.7.1",
+    "rxjs": "^7.5.6",
     "source-map-support": "^0.5.21",
     "ts-morph": "^15.1.0",
     "ts-node": "^10.9.1",
@@ -1196,6 +1202,16 @@
         "types": "./esm/Stream/continueWith.d.ts"
       }
     },
+    "./Stream/delay": {
+      "require": {
+        "default": "./cjs/Stream/delay.js",
+        "types": "./cjs/Stream/delay.d.ts"
+      },
+      "import": {
+        "default": "./esm/Stream/delay.js",
+        "types": "./esm/Stream/delay.d.ts"
+      }
+    },
     "./Stream/drain": {
       "require": {
         "default": "./cjs/Stream/drain.js",
@@ -1246,6 +1262,26 @@
         "types": "./esm/Stream/flatMapFx.d.ts"
       }
     },
+    "./Stream/foldMap": {
+      "require": {
+        "default": "./cjs/Stream/foldMap.js",
+        "types": "./cjs/Stream/foldMap.d.ts"
+      },
+      "import": {
+        "default": "./esm/Stream/foldMap.js",
+        "types": "./esm/Stream/foldMap.d.ts"
+      }
+    },
+    "./Stream/fromArray": {
+      "require": {
+        "default": "./cjs/Stream/fromArray.js",
+        "types": "./cjs/Stream/fromArray.d.ts"
+      },
+      "import": {
+        "default": "./esm/Stream/fromArray.js",
+        "types": "./esm/Stream/fromArray.d.ts"
+      }
+    },
     "./Stream/fromCallback": {
       "require": {
         "default": "./cjs/Stream/fromCallback.js",
@@ -1296,16 +1332,6 @@
         "types": "./esm/Stream/lazy.d.ts"
       }
     },
-    "./Stream/map": {
-      "require": {
-        "default": "./cjs/Stream/map.js",
-        "types": "./cjs/Stream/map.d.ts"
-      },
-      "import": {
-        "default": "./esm/Stream/map.js",
-        "types": "./esm/Stream/map.d.ts"
-      }
-    },
     "./Stream/merge": {
       "require": {
         "default": "./cjs/Stream/merge.js",
@@ -1346,6 +1372,16 @@
         "types": "./esm/Stream/periodic.d.ts"
       }
     },
+    "./Stream/provide": {
+      "require": {
+        "default": "./cjs/Stream/provide.js",
+        "types": "./cjs/Stream/provide.d.ts"
+      },
+      "import": {
+        "default": "./esm/Stream/provide.js",
+        "types": "./esm/Stream/provide.d.ts"
+      }
+    },
     "./Stream/run": {
       "require": {
         "default": "./cjs/Stream/run.js",
@@ -1386,6 +1422,16 @@
         "types": "./esm/Stream/setFiberRefLocally.d.ts"
       }
     },
+    "./Stream/skipRepeats": {
+      "require": {
+        "default": "./cjs/Stream/skipRepeats.js",
+        "types": "./cjs/Stream/skipRepeats.d.ts"
+      },
+      "import": {
+        "default": "./esm/Stream/skipRepeats.js",
+        "types": "./esm/Stream/skipRepeats.d.ts"
+      }
+    },
     "./Stream/switchMap": {
       "require": {
         "default": "./cjs/Stream/switchMap.js",
@@ -1426,6 +1472,16 @@
         "types": "./esm/Supervisor/Supervisor.d.ts"
       }
     },
+    "./Supervisor/inheritFiberRefs": {
+      "require": {
+        "default": "./cjs/Supervisor/inheritFiberRefs.js",
+        "types": "./cjs/Supervisor/inheritFiberRefs.d.ts"
+      },
+      "import": {
+        "default": "./esm/Supervisor/inheritFiberRefs.js",
+        "types": "./esm/Supervisor/inheritFiberRefs.d.ts"
+      }
+    },
     "./Supervisor/maxFailures": {
       "require": {
         "default": "./cjs/Supervisor/maxFailures.js",
@@ -1585,16 +1641,6 @@
         "default": "./esm/_internal/suite.js",
         "types": "./esm/_internal/suite.d.ts"
       }
-    },
-    "./test": {
-      "require": {
-        "default": "./cjs/test.js",
-        "types": "./cjs/test.d.ts"
-      },
-      "import": {
-        "default": "./esm/test.js",
-        "types": "./esm/test.d.ts"
-      }
     }
   }
 }

package/perf/Stream-filter-map-reduce.test.ts

@@ -0,0 +1,103 @@
+import * as M from '@most/core'
+import * as MS from '@most/scheduler'
+import benchmark from 'benchmark'
+import { pipe } from 'hkt-ts'
+import * as rxjs from 'rxjs'
+
+import * as Stream from './index.js'
+
+import * as Fx from '@/Fx/index.js'
+import { RootScheduler } from '@/Scheduler/RootScheduler.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+
+const filterEvens = (x: number) => x % 2 === 0
+const addOne = (x: number) => x + 1
+const sum = (x: number, y: number) => x + y
+
+const iterations = 1000000
+const array = Array.from({ length: iterations }, (_, i) => i)
+
+const fxStream = pipe(
+  Stream.fromArray(array),
+  Stream.filter(filterEvens),
+  Stream.map(addOne),
+  Stream.reduce(sum, 0),
+  Fx.provideService(Scheduler, RootScheduler()),
+)
+
+const mostStream = pipe(
+  M.periodic(0),
+  M.withItems(array),
+  M.filter(filterEvens),
+  M.map(addOne),
+  M.scan(sum, 0),
+)
+
+const mostScheduler = MS.newDefaultScheduler()
+
+const rxjsStream = pipe(
+  rxjs.from(array),
+  rxjs.filter(filterEvens),
+  rxjs.map(addOne),
+  rxjs.scan(sum, 0),
+)
+
+// eslint-disable-next-line import/no-named-as-default-member
+const suite = new benchmark.Suite('filter -> map -> reduce ' + iterations + ' integers')
+
+suite
+  .add('@typed/fx', function (deferred: benchmark.Deferred) {
+    Fx.runMain(fxStream).then(() => deferred.resolve())
+  })
+  .add('@most/core', function (deferred: benchmark.Deferred) {
+    M.runEffects(mostStream, mostScheduler).then(() => deferred.resolve())
+  })
+  .add('rxjs @7', function (deferred: benchmark.Deferred) {
+    rxjsStream.subscribe({
+      complete: () => deferred.resolve(),
+    })
+  })
+  .on('start', logStart)
+  .on('cycle', logResults)
+  .on('complete', logComplete)
+  .run()
+
+function logResults(e: any) {
+  const t = e.target
+
+  if (t.failure) {
+    console.error(padl(10, t.name) + 'FAILED: ' + e.target.failure)
+  } else {
+    const result =
+      padl(18, t.name) +
+      padr(13, t.hz.toFixed(2) + ' op/s') +
+      ' \xb1' +
+      padr(7, t.stats.rme.toFixed(2) + '%') +
+      padr(15, ' (' + t.stats.sample.length + ' samples)')
+
+    console.log(result)
+  }
+}
+
+function logStart(this: any) {
+  console.log(this.name)
+  console.log('-------------------------------------------------------')
+}
+
+function logComplete() {
+  console.log('-------------------------------------------------------')
+}
+
+function padl(n: number, s: string) {
+  while (s.length < n) {
+    s += ' '
+  }
+  return s
+}
+
+function padr(n: number, s: string) {
+  while (s.length < n) {
+    s = ' ' + s
+  }
+  return s
+}

package/src/Env/Env.ts

@@ -1,14 +1,24 @@
-import { getServiceFromFiberRefs } from '@/FiberRef/builtins.js'
+import { makeEnvFromFiberRefs } from '@/FiberRef/builtins.js'
 import * as FiberRefs from '@/FiberRefs/FiberRefs.js'
 import { Of } from '@/Fx/Fx.js'
 import { Service } from '@/Service/Service.js'
 
+/**
+ * Env is an abstraction over FiberRefs which keeps track of services and joining them back together.
+ */
 export interface Env<R> {
+  readonly fiberRefs: FiberRefs.FiberRefs
   readonly get: <S extends R>(service: Service<S>) => Of<S>
+  readonly addService: <S, I extends S>(service: Service<S>, impl: I) => Env<R | S>
+  readonly join: <S>(other: Env<S>) => Env<R | S>
 }
 
-export function Env<R>(fiberRefs: FiberRefs.FiberRefs): Env<R> {
-  return {
-    get: getServiceFromFiberRefs(fiberRefs.fork()),
-  }
+export const Empty = makeEnvFromFiberRefs<never>(FiberRefs.FiberRefs())
+
+export function Env<S, I extends S>(service: Service<S>, impl: I): Env<S> {
+  return Empty.addService(service, impl)
+}
+
+export function fromFiberRefs<R>(fiberRefs: FiberRefs.FiberRefs): Env<R> {
+  return makeEnvFromFiberRefs(fiberRefs)
 }

package/src/FiberContext/FiberContext.ts

@@ -61,7 +61,7 @@ export function fork<Id extends FiberId.FiberId = FiberId.Live, Id2 extends Fibe
     platform: overrides?.platform ?? context.platform.fork(),
     fiberRefs: overrides?.fiberRefs ?? context.fiberRefs.fork(),
     scope: overrides?.scope ?? context.scope.fork(),
-    supervisor: overrides?.supervisor ?? context.supervisor,
+    supervisor: overrides?.supervisor ?? None,
     logger: overrides?.logger ?? context.logger,
     parent: overrides?.parent ?? Just(context),
   })

package/src/FiberRef/builtins.ts

@@ -19,8 +19,7 @@ import { Trace } from '@/Trace/Trace.js'
 export const CurrentEnv = make(
   pipe(
     Fx.getFiberContext,
-    // Always use a snapshot of the FiberRefs to avoid mutability problems.
-    Fx.map((c): Env<any> => ({ get: getServiceFromFiberRefs(c.fiberRefs.fork()) })),
+    Fx.map((c) => makeEnvFromFiberRefs(c.fiberRefs)),
   ),
   {
     fork: constant(Nothing), // Always create a new Env for each Fiber.
@@ -28,6 +27,18 @@ export const CurrentEnv = make(
   },
 )
 
+export function makeEnvFromFiberRefs<R>(fiberRefs: FiberRefs.FiberRefs): Env<R> {
+  // Always use a snapshot of the FiberRefs to avoid mutability problems.
+  const forked = FiberRefs.fork(fiberRefs)
+
+  return {
+    fiberRefs: forked,
+    get: getServiceFromFiberRefs(forked),
+    addService: addServiceFromFiberRefs(forked),
+    join: joinEnvFromFiberRefs(forked),
+  }
+}
+
 export const CurrentConcurrencyLevel = make(
   Fx.fromLazy(() => new Semaphore(NonNegativeInteger(Infinity))),
   {
@@ -121,3 +132,35 @@ const getLayerFromFiberRefs = <S>(id: Service<S>, fiberRefs: FiberRefs.FiberRefs
 
     return join(fiber)
   })
+
+export function addServiceFromFiberRefs<R>(fiberRefs: FiberRefs.FiberRefs): Env<R>['addService'] {
+  return (id, impl) => {
+    const forked = fiberRefs.fork()
+
+    // AddService
+    FiberRefs.setFiberRef(
+      Services,
+      pipe(
+        forked,
+        FiberRefs.maybeGetFiberRefValue(Services),
+        Maybe.match(
+          () => ImmutableMap<Service<any>, any>().set(id, impl),
+          (s) => s.set(id, impl),
+        ),
+      ),
+    )(forked)
+
+    return makeEnvFromFiberRefs(forked)
+  }
+}
+
+export function joinEnvFromFiberRefs<R>(fiberRefs: FiberRefs.FiberRefs): Env<R>['join'] {
+  return (other) => {
+    const forked = other.fiberRefs.fork()
+
+    // Reverse the order to ensure incoming values take precedence for Services + Layers
+    FiberRefs.join(forked, fiberRefs)
+
+    return makeEnvFromFiberRefs(forked)
+  }
+}

package/src/FiberRuntime/FiberRuntime.ts

@@ -456,12 +456,12 @@ export class FiberRuntime<F extends Fx.AnyFx>
   protected processProvideService(
     instr: Extract<AnyInstruction, { readonly tag: 'ProvideService' }>,
   ) {
-    this.withFiberRef(Builtin.Services, (services) =>
+    this.withFiberRef(Builtin.CurrentEnv, (env) =>
       pipe(
         instr.fx,
         Fx.fiberRefLocally(
-          Builtin.Services,
-          services.value.set(instr.service, instr.implementation),
+          Builtin.CurrentEnv,
+          env.value.addService(instr.service, instr.implementation),
         ),
       ),
     )

package/src/Fx/Fx.ts

@@ -527,7 +527,7 @@ export const Top: T.Top3REC<FxHKT, never, never> = {
   top: now<unknown>([]),
 }
 
-export const top = T.top
+export const top = Top.top
 
 export const never = async<never, never, never>(() => Either.Left(unit))
 

package/src/Stream/Stream.ts

@@ -10,12 +10,10 @@ import { Sink } from '@/Sink/Sink.js'
  * - Loop
  * - zipItems
  * - withItems
- * - concatMap
  * - combine/combineArray
  * - zip/zipArray
  * - sample
  * - snapshot
- * - skipRepeats
  * - slice/take/skip
  * - takeWhile/skipWhile
  * - takeUntil/skipUntil
@@ -23,10 +21,8 @@ import { Sink } from '@/Sink/Sink.js'
  * - since
  * - during
  * - until
- * - delay
  * - throttle
  * - debounce
- * - reduce
  * - Fusion/Commutation
  * - Unique Identification for streams to add to tracing
  *    - How to build a dynamic stream graph?

package/src/Stream/bimap.ts

@@ -1,13 +1,14 @@
-import { flow } from 'hkt-ts/function'
+import { Maybe } from 'hkt-ts'
+import { flow, pipe } from 'hkt-ts/function'
 
 import { Stream } from './Stream.js'
-import { MapStream } from './map.js'
 
 import * as Cause from '@/Cause/index.js'
 import { FiberContext } from '@/FiberContext/FiberContext.js'
 import { Live } from '@/FiberId/FiberId.js'
+import { unit } from '@/Fx/Fx.js'
 import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Sink } from '@/Sink/Sink.js'
+import { Sink, addTrace } from '@/Sink/Sink.js'
 
 export function bimap<A, B, C, D>(
   f: (a: A) => B,
@@ -64,3 +65,147 @@ class BimapSink<A, B, C, D, E> implements Sink<A, C, E> {
   error = flow(Cause.map(this.f), this.sink.error)
   end = this.sink.end
 }
+
+export function map<A, B>(
+  f: (a: A) => B,
+  __trace?: string,
+): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, B> {
+  return (stream) => MapStream.make(stream, f, __trace)
+}
+
+export class MapStream<R, E, A, B> implements Stream<R, E, B> {
+  constructor(
+    readonly stream: Stream<R, E, A>,
+    readonly f: (a: A) => B,
+    readonly __trace?: string,
+  ) {}
+
+  fork<E2>(sink: Sink<E, B, E2>, scheduler: Scheduler, context: FiberContext<Live>) {
+    return this.stream.fork(
+      addTrace(
+        {
+          ...sink,
+          event: flow(this.f, sink.event),
+        },
+        this.__trace,
+      ),
+      scheduler,
+      context,
+    )
+  }
+
+  static make<R, E, A, B>(
+    stream: Stream<R, E, A>,
+    f: (a: A) => B,
+    __trace?: string,
+  ): Stream<R, E, B> {
+    if (stream instanceof MapStream) {
+      return MapStream.make(stream.stream, flow(stream.f, f), __trace)
+    }
+
+    if (stream instanceof MapLeftStream) {
+      return BimapStream.make(stream.stream, stream.f, f, __trace)
+    }
+
+    if (stream instanceof FilterMapStream) {
+      return FilterMapStream.make(stream.stream, flow(stream.f, Maybe.map(f)), __trace)
+    }
+
+    return new MapStream(stream, f, __trace)
+  }
+}
+
+export function mapLeft<E1, E2>(
+  f: (error: E1) => E2,
+  __trace?: string,
+): <R, A>(stream: Stream<R, E1, A>) => Stream<R, E2, A> {
+  return (stream) => MapLeftStream.make(stream, f, __trace)
+}
+
+export class MapLeftStream<R, E1, A, E2> implements Stream<R, E2, A> {
+  constructor(
+    readonly stream: Stream<R, E1, A>,
+    readonly f: (error: E1) => E2,
+    readonly __trace?: string,
+  ) {}
+
+  fork<E3>(sink: Sink<E2, A, E3>, scheduler: Scheduler, context: FiberContext<Live>) {
+    return this.stream.fork(
+      addTrace(
+        {
+          ...sink,
+          error: flow(Cause.map(this.f), sink.error),
+        },
+        this.__trace,
+      ),
+      scheduler,
+      context,
+    )
+  }
+
+  static make<R, E1, A, E2>(
+    stream: Stream<R, E1, A>,
+    f: (e: E1) => E2,
+    __trace?: string,
+  ): Stream<R, E2, A> {
+    if (stream instanceof MapLeftStream) {
+      return MapLeftStream.make(stream.stream, flow(stream.f, f), __trace)
+    }
+
+    if (stream instanceof MapStream) {
+      return BimapStream.make(stream.stream, f, stream.f, __trace)
+    }
+
+    return new MapLeftStream(stream, f, __trace)
+  }
+}
+
+export function filterMap<A, B>(
+  f: (a: A) => Maybe.Maybe<B>,
+  __trace?: string,
+): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, B> {
+  return (stream) => FilterMapStream.make(stream, f, __trace)
+}
+
+export class FilterMapStream<R, E, A, B> implements Stream<R, E, B> {
+  constructor(
+    readonly stream: Stream<R, E, A>,
+    readonly f: (a: A) => Maybe.Maybe<B>,
+    readonly __trace?: string,
+  ) {}
+
+  fork<E2>(sink: Sink<E, B, E2>, scheduler: Scheduler, context: FiberContext<Live>) {
+    return this.stream.fork(
+      addTrace(
+        {
+          ...sink,
+          event: (a) =>
+            pipe(
+              a,
+              this.f,
+              Maybe.match(() => unit, sink.event),
+            ),
+        },
+        this.__trace,
+      ),
+      scheduler,
+      context,
+    )
+  }
+
+  static make<R, E, A, B>(
+    stream: Stream<R, E, A>,
+    f: (a: A) => Maybe.Maybe<B>,
+    __trace?: string,
+  ): Stream<R, E, B> {
+    if (stream instanceof MapStream) {
+      return FilterMapStream.make(stream.stream, flow(stream.f, f), __trace)
+    }
+
+    if (stream instanceof FilterMapStream) {
+      return FilterMapStream.make(stream.stream, flow(stream.f, Maybe.flatMap(f)), __trace)
+    }
+
+    return new FilterMapStream(stream, f, __trace)
+  }
+}

package/src/Stream/delay.ts

@@ -0,0 +1,43 @@
+import { Stream } from './Stream.js'
+
+import { Env } from '@/Env/Env.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import { access, fromLazy } from '@/Fx/index.js'
+import { delayed } from '@/Schedule/Schedule.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Sink } from '@/Sink/Sink.js'
+import { Delay } from '@/Time/index.js'
+
+export function delay(delay: Delay) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A> =>
+    Stream((sink, scheduler, context) =>
+      access((env: Env<R>) =>
+        stream.fork(new DelaySink(sink, scheduler, context, env, delay), scheduler, context),
+      ),
+    )
+}
+
+class DelaySink<E, A, E2> implements Sink<E, A, E2> {
+  constructor(
+    readonly sink: Sink<E, A, E2>,
+    readonly scheduler: Scheduler,
+    readonly context: FiberContext<FiberId.Live>,
+    readonly env: Env<any>,
+    readonly delay: Delay,
+  ) {}
+
+  event(value: A) {
+    return fromLazy(() =>
+      this.scheduler.schedule(
+        this.sink.event(value),
+        this.env,
+        delayed(this.delay),
+        this.context.fork(),
+      ),
+    )
+  }
+
+  error = this.sink.error
+  end = this.sink.end
+}