@fncts/io 0.0.1 → 0.0.4

package/_src/Stream/internal/DebounceState.ts

@@ -23,7 +23,7 @@ export const CurrentTag = Symbol();
 export type CurrentTag = typeof CurrentTag;
 export class Current<E, A> {
   readonly _tag = DebounceStateTag.Current;
-  constructor(readonly fiber: Fiber<E, HandoffSignal<void, E, A>>) {}
+  constructor(readonly fiber: Fiber<E, HandoffSignal<E, A>>) {}
 }
 
 /**
@@ -53,7 +53,7 @@ export function previous<A>(fiber: Fiber<never, Conc<A>>): DebounceState<never,
 /**
  * @tsplus static fncts.io.Stream.DebounceStateOps Current
  */
-export function current<E, A>(fiber: Fiber<E, HandoffSignal<void, E, A>>): DebounceState<E, A> {
+export function current<E, A>(fiber: Fiber<E, HandoffSignal<E, A>>): DebounceState<E, A> {
   return new Current(fiber);
 }
 

package/_src/Stream/internal/Handoff.ts

@@ -112,17 +112,17 @@ export class Halt<E> {
 
 export const EndTypeId = Symbol("fncts.io.Stream.HandoffSignal.End");
 export type EndTypeId = typeof EndTypeId;
-export class End<C> {
+export class End {
   readonly _typeId: typeof HandoffSignalTypeId = HandoffSignalTypeId;
   readonly _tag: typeof EndTypeId              = EndTypeId;
 
-  constructor(readonly reason: SinkEndReason<C>) {}
+  constructor(readonly reason: SinkEndReason) {}
 }
 
 /**
  * @tsplus type fncts.io.Stream.HandoffSignal
  */
-export type HandoffSignal<C, E, A> = Emit<A> | Halt<E> | End<C>;
+export type HandoffSignal<E, A> = Emit<A> | Halt<E> | End;
 
 /**
  * @tsplus type fncts.io.Stream.HandoffSignalOps
@@ -134,33 +134,33 @@ export const HandoffSignal: HandoffSignalOps = {};
 /**
  * @tsplus static fncts.io.Stream.HandoffSignalOps Emit
  */
-export function emit<A>(els: Conc<A>): HandoffSignal<never, never, A> {
+export function emit<A>(els: Conc<A>): HandoffSignal<never, A> {
   return new Emit(els);
 }
 
 /**
  * @tsplus static fncts.io.Stream.HandoffSignalOps Halt
  */
-export function halt<E>(error: Cause<E>): HandoffSignal<never, E, never> {
+export function halt<E>(error: Cause<E>): HandoffSignal<E, never> {
   return new Halt(error);
 }
 
 /**
  * @tsplus static fncts.io.Stream.HandoffSignalOps End
  */
-export function end<C>(reason: SinkEndReason<C>): HandoffSignal<C, never, never> {
+export function end<C>(reason: SinkEndReason): HandoffSignal<never, never> {
   return new End(reason);
 }
 
 /**
  * @tsplus fluent fncts.io.Stream.HandoffSignal match
  */
-export function matchSignal_<C, E, A, B, D, F>(
-  signal: HandoffSignal<C, E, A>,
+export function matchSignal_<E, A, B, D, F>(
+  signal: HandoffSignal<E, A>,
   cases: {
     Emit: (_: Emit<A>) => B;
     Halt: (_: Halt<E>) => D;
-    End: (_: End<C>) => F;
+    End: (_: End) => F;
   },
 ): B | D | F {
   switch (signal._tag) {

package/_src/Stream/internal/SinkEndReason.ts

@@ -7,21 +7,9 @@ export const enum SinkEndReasonTag {
 
 export const SinkEndReasonTypeId = Symbol.for("fncts.io.Stream.SinkEndReason");
 
-export class SinkEnd {
-  readonly _typeId: typeof SinkEndReasonTypeId = SinkEndReasonTypeId;
-  readonly _tag = SinkEndReasonTag.SinkEnd;
-}
-
-export class ScheduleTimeout {
-  readonly _typeId: typeof SinkEndReasonTypeId = SinkEndReasonTypeId;
-  readonly _tag = SinkEndReasonTag.ScheduleTimeout;
-}
-
-export class ScheduleEnd<C> {
+export class ScheduleEnd {
   readonly _typeId: typeof SinkEndReasonTypeId = SinkEndReasonTypeId;
   readonly _tag = SinkEndReasonTag.ScheduleEnd;
-
-  constructor(readonly c: C) {}
 }
 
 export class UpstreamEnd {
@@ -32,25 +20,19 @@ export class UpstreamEnd {
 /**
  * @tsplus type fncts.io.Stream.SinkEndReason
  */
-export type SinkEndReason<C> = SinkEnd | ScheduleTimeout | ScheduleEnd<C> | UpstreamEnd;
+export type SinkEndReason = ScheduleEnd | UpstreamEnd;
 
 /**
  * @tsplus fluent fncts.io.Stream.SinkEndReason match
  */
-export function matchSinkEndReason_<A, B, C, D, E>(
-  self: SinkEndReason<A>,
+export function matchSinkEndReason_<A, B>(
+  self: SinkEndReason,
   cases: {
-    SinkEnd: (_: SinkEnd) => B;
-    ScheduleTimeout: (_: ScheduleTimeout) => C;
-    ScheduleEnd: (_: ScheduleEnd<A>) => D;
-    UpstreamEnd: (_: UpstreamEnd) => E;
+    ScheduleEnd: (_: ScheduleEnd) => A;
+    UpstreamEnd: (_: UpstreamEnd) => B;
   },
-): B | C | D | E {
+): A | B {
   switch (self._tag) {
-    case SinkEndReasonTag.SinkEnd:
-      return cases.SinkEnd(self);
-    case SinkEndReasonTag.ScheduleTimeout:
-      return cases.ScheduleTimeout(self);
     case SinkEndReasonTag.ScheduleEnd:
       return cases.ScheduleEnd(self);
     case SinkEndReasonTag.UpstreamEnd:

package/_src/TFuture/definition.ts

@@ -1,7 +1,7 @@
 import type { UTRef } from "../TRef.js";
 
 interface TFutureN extends HKT {
-  readonly type: TFuture<this["E"], this["A"]>;
+  readonly [HKT.T]: TFuture<HKT._E<this>, HKT._A<this>>;
 }
 
 /**
@@ -20,4 +20,4 @@ export interface TFuture<E, A>
  */
 export interface TFutureOps extends NewtypeIso<TFutureN> {}
 
-export const TFuture: TFutureOps = Newtype<TFutureN>();
+export const TFuture: TFutureOps = Newtype<TFutureN>();

package/_src/TSemaphore/definition.ts

@@ -1,5 +1,5 @@
 interface TSemaphoreN extends HKT {
-  readonly type: TSemaphore;
+  readonly [HKT.T]: TSemaphore;
 }
 
 /**

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "dependencies": {
-    "@fncts/base": "0.0.1",
-    "@fncts/typelevel": "0.0.1"
+    "@fncts/base": "0.0.4",
+    "@fncts/typelevel": "0.0.4"
   },
   "exports": {
     "./*": {
-      "import": "./_mjs/*",
-      "require": "./_cjs/*"
+      "import": "./_mjs/*.mjs",
+      "require": "./_cjs/*.cjs"
     }
   },
   "publishConfig": {

package/runTests.d.ts

@@ -0,0 +1 @@
+export {};

package/Schedule/Interval.d.ts

@@ -1,71 +0,0 @@
-import { Maybe } from "@fncts/base/data/Maybe";
-/**
- * @tsplus type fncts.io.Schedule.Interval
- * @tsplus companion fncts.io.Schedule.IntervalOps
- */
-export declare class Interval {
-    readonly startMilliseconds: number;
-    readonly endMilliseconds: number;
-    constructor(startMilliseconds: number, endMilliseconds: number);
-}
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps after
- * @tsplus location "@fncts/io/Schedule/Interval"
- */
-export declare function after(start: number): Interval;
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps before
- * @tsplus location "@fncts/io/Schedule/Interval"
- */
-export declare function before(end: number): Interval;
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps empty
- * @tsplus location "@fncts/io/Schedule/Interval"
- */
-export declare const empty: Interval;
-/**
- * @tsplus getter fncts.io.Schedule.Interval isEmpty
- * @tsplus location "@fncts/io/Schedule/Interval"
- */
-export declare function isEmpty(self: Interval): boolean;
-/**
- * @tsplus fluent fncts.io.Schedule.Interval intersect
- * @tsplus location "@fncts/io/Schedule/Interval"
- */
-export declare function intersect_(self: Interval, that: Interval): Interval;
-/**
- * @tsplus fluent fncts.io.Schedule.Interval lt
- * @tsplus operator fncts.io.Schedule.Interval <
- * @tsplus location "@fncts/io/Schedule/Interval"
- */
-export declare function lt_(self: Interval, that: Interval): boolean;
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps __call
- * @tsplus location "@fncts/io/Schedule/Interval"
- */
-export declare function makeInterval(start: number, end: number): Interval;
-/**
- * @tsplus fluent fncts.io.Schedule.Interval max
- * @tsplus location "@fncts/io/Schedule/Interval"
- */
-export declare function max_(self: Interval, that: Interval): Interval;
-/**
- * @tsplus fluent fncts.io.Schedule.Interval min
- * @tsplus location "@fncts/io/Schedule/Interval"
- */
-export declare function min_(self: Interval, that: Interval): Interval;
-/**
- * @tsplus getter fncts.io.Schedule.Interval isNonEmpty
- * @tsplus location "@fncts/io/Schedule/Interval"
- */
-export declare function isNonEmpty(self: Interval): boolean;
-/**
- * @tsplus getter fncts.io.Schedule.Interval size
- * @tsplus location "@fncts/io/Schedule/Interval"
- */
-export declare function size(self: Interval): number;
-/**
- * @tsplus fluent fncts.io.Schedule.Interval union
- * @tsplus location "@fncts/io/Schedule/Interval"
- */
-export declare function union_(self: Interval, that: Interval): Maybe<Interval>;

package/_cjs/Schedule/Interval.cjs

@@ -1,154 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Interval = void 0;
-exports.after = after;
-exports.before = before;
-exports.empty = void 0;
-exports.intersect_ = intersect_;
-exports.isEmpty = void 0;
-exports.isNonEmpty = isNonEmpty;
-exports.lt_ = lt_;
-exports.makeInterval = void 0;
-exports.max_ = max_;
-exports.min_ = void 0;
-exports.size = size;
-exports.union_ = union_;
-
-var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-const isEmpty = isEmpty_1;
-exports.isEmpty = isEmpty;
-const makeInterval = makeInterval_1;
-exports.makeInterval = makeInterval;
-const min_ = min_1;
-/**
- * @tsplus type fncts.io.Schedule.Interval
- * @tsplus companion fncts.io.Schedule.IntervalOps
- */
-
-exports.min_ = min_;
-
-class Interval {
-  constructor(startMilliseconds, endMilliseconds) {
-    this.startMilliseconds = startMilliseconds;
-    this.endMilliseconds = endMilliseconds;
-  }
-
-}
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps after
- */
-
-
-exports.Interval = Interval;
-
-function after(start) {
-  return makeInterval_1(start, Number.MAX_SAFE_INTEGER);
-}
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps before
- */
-
-
-function before(end) {
-  return makeInterval_1(Number.MIN_SAFE_INTEGER, end);
-}
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps empty
- */
-
-
-const empty_1 = /*#__PURE__*/new Interval(Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
-const empty = empty_1;
-/**
- * @tsplus getter fncts.io.Schedule.Interval isEmpty
- */
-
-exports.empty = empty;
-
-function isEmpty_1(self) {
-  return self.startMilliseconds >= self.endMilliseconds;
-}
-/**
- * @tsplus fluent fncts.io.Schedule.Interval intersect
- */
-
-
-function intersect_(self, that) {
-  const start = Math.max(self.startMilliseconds, that.startMilliseconds);
-  const end = Math.min(self.endMilliseconds, that.endMilliseconds);
-  return makeInterval_1(start, end);
-}
-/**
- * @tsplus fluent fncts.io.Schedule.Interval lt
- * @tsplus operator fncts.io.Schedule.Interval <
- */
-
-
-function lt_(self, that) {
-  return min_1(self, that) === self;
-}
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps __call
- */
-
-
-function makeInterval_1(start, end) {
-  if (start <= end) return makeInterval_1(start, end);else return empty_1;
-}
-/**
- * @tsplus fluent fncts.io.Schedule.Interval max
- */
-
-
-function max_(self, that) {
-  const m = min_1(self, that);
-  if (m === self) return that;else return self;
-}
-/**
- * @tsplus fluent fncts.io.Schedule.Interval min
- */
-
-
-function min_1(self, that) {
-  if (self.endMilliseconds <= that.startMilliseconds) return self;
-  if (that.endMilliseconds <= self.startMilliseconds) return that;
-  if (self.startMilliseconds < that.startMilliseconds) return self;
-  if (that.startMilliseconds < self.startMilliseconds) return that;
-  if (self.endMilliseconds <= that.endMilliseconds) return self;
-  return that;
-}
-/**
- * @tsplus getter fncts.io.Schedule.Interval isNonEmpty
- */
-
-
-function isNonEmpty(self) {
-  return !isEmpty_1(self);
-}
-/**
- * @tsplus getter fncts.io.Schedule.Interval size
- */
-
-
-function size(self) {
-  return self.endMilliseconds - self.startMilliseconds;
-}
-/**
- * @tsplus fluent fncts.io.Schedule.Interval union
- */
-
-
-function union_(self, that) {
-  const istart = Math.max(self.startMilliseconds, that.startMilliseconds);
-  const iend = Math.min(self.endMilliseconds, that.endMilliseconds);
-  if (istart <= iend) return tsplus_module_1.nothing();else return tsplus_module_1.just(makeInterval_1(istart, iend));
-}
-//# sourceMappingURL=Interval.cjs.map

package/_cjs/Schedule/Interval.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Interval.cjs","mappings":"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","names":["isEmpty","makeInterval","min_","Interval","constructor","startMilliseconds","endMilliseconds","after","start","makeInterval_1","Number","MAX_SAFE_INTEGER","before","end","MIN_SAFE_INTEGER","empty_1","empty","self","intersect_","that","Math","max","min","lt_","min_1","max_","m","isNonEmpty","size","union_","istart","iend","tsplus_module_1"],"sourceRoot":"","sources":["../../_src/Schedule/Interval.ts"],"sourcesContent":[null]}

package/_mjs/Schedule/Interval.mjs

@@ -1,114 +0,0 @@
-import * as tsplus_module_1 from "@fncts/base/data/Maybe/constructors";
-export const isEmpty = isEmpty_1;
-export const makeInterval = makeInterval_1;
-export const min_ = min_1;
-/**
- * @tsplus type fncts.io.Schedule.Interval
- * @tsplus companion fncts.io.Schedule.IntervalOps
- */
-
-export class Interval {
-  constructor(startMilliseconds, endMilliseconds) {
-    this.startMilliseconds = startMilliseconds;
-    this.endMilliseconds = endMilliseconds;
-  }
-
-}
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps after
- */
-
-export function after(start) {
-  return makeInterval_1(start, Number.MAX_SAFE_INTEGER);
-}
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps before
- */
-
-export function before(end) {
-  return makeInterval_1(Number.MIN_SAFE_INTEGER, end);
-}
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps empty
- */
-
-const empty_1 = /*#__PURE__*/new Interval(Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
-export const empty = empty_1;
-/**
- * @tsplus getter fncts.io.Schedule.Interval isEmpty
- */
-
-function isEmpty_1(self) {
-  return self.startMilliseconds >= self.endMilliseconds;
-}
-/**
- * @tsplus fluent fncts.io.Schedule.Interval intersect
- */
-
-
-export function intersect_(self, that) {
-  const start = Math.max(self.startMilliseconds, that.startMilliseconds);
-  const end = Math.min(self.endMilliseconds, that.endMilliseconds);
-  return makeInterval_1(start, end);
-}
-/**
- * @tsplus fluent fncts.io.Schedule.Interval lt
- * @tsplus operator fncts.io.Schedule.Interval <
- */
-
-export function lt_(self, that) {
-  return min_1(self, that) === self;
-}
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps __call
- */
-
-function makeInterval_1(start, end) {
-  if (start <= end) return makeInterval_1(start, end);else return empty_1;
-}
-/**
- * @tsplus fluent fncts.io.Schedule.Interval max
- */
-
-
-export function max_(self, that) {
-  const m = min_1(self, that);
-  if (m === self) return that;else return self;
-}
-/**
- * @tsplus fluent fncts.io.Schedule.Interval min
- */
-
-function min_1(self, that) {
-  if (self.endMilliseconds <= that.startMilliseconds) return self;
-  if (that.endMilliseconds <= self.startMilliseconds) return that;
-  if (self.startMilliseconds < that.startMilliseconds) return self;
-  if (that.startMilliseconds < self.startMilliseconds) return that;
-  if (self.endMilliseconds <= that.endMilliseconds) return self;
-  return that;
-}
-/**
- * @tsplus getter fncts.io.Schedule.Interval isNonEmpty
- */
-
-
-export function isNonEmpty(self) {
-  return !isEmpty_1(self);
-}
-/**
- * @tsplus getter fncts.io.Schedule.Interval size
- */
-
-export function size(self) {
-  return self.endMilliseconds - self.startMilliseconds;
-}
-/**
- * @tsplus fluent fncts.io.Schedule.Interval union
- */
-
-export function union_(self, that) {
-  const istart = Math.max(self.startMilliseconds, that.startMilliseconds);
-  const iend = Math.min(self.endMilliseconds, that.endMilliseconds);
-  if (istart <= iend) return tsplus_module_1.nothing();else return tsplus_module_1.just(makeInterval_1(istart, iend));
-}
-//# sourceMappingURL=Interval.mjs.map

package/_mjs/Schedule/Interval.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Interval.mjs","mappings":"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","names":["isEmpty","makeInterval","min_","Interval","constructor","startMilliseconds","endMilliseconds","after","start","makeInterval_1","Number","MAX_SAFE_INTEGER","before","end","MIN_SAFE_INTEGER","empty_1","empty","self","intersect_","that","Math","max","min","lt_","min_1","max_","m","isNonEmpty","size","union_","istart","iend","tsplus_module_1"],"sourceRoot":"","sources":["../../_src/Schedule/Interval.ts"],"sourcesContent":[null]}

package/_src/Schedule/Interval.ts

@@ -1,103 +0,0 @@
-/**
- * @tsplus type fncts.io.Schedule.Interval
- * @tsplus companion fncts.io.Schedule.IntervalOps
- */
-export class Interval {
-  constructor(readonly startMilliseconds: number, readonly endMilliseconds: number) {}
-}
-
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps after
- */
-export function after(start: number): Interval {
-  return Interval(start, Number.MAX_SAFE_INTEGER);
-}
-
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps before
- */
-export function before(end: number): Interval {
-  return Interval(Number.MIN_SAFE_INTEGER, end);
-}
-
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps empty
- */
-export const empty: Interval = new Interval(Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
-
-/**
- * @tsplus getter fncts.io.Schedule.Interval isEmpty
- */
-export function isEmpty(self: Interval): boolean {
-  return self.startMilliseconds >= self.endMilliseconds;
-}
-
-/**
- * @tsplus fluent fncts.io.Schedule.Interval intersect
- */
-export function intersect_(self: Interval, that: Interval): Interval {
-  const start = Math.max(self.startMilliseconds, that.startMilliseconds);
-  const end   = Math.min(self.endMilliseconds, that.endMilliseconds);
-  return Interval(start, end);
-}
-
-/**
- * @tsplus fluent fncts.io.Schedule.Interval lt
- * @tsplus operator fncts.io.Schedule.Interval <
- */
-export function lt_(self: Interval, that: Interval): boolean {
-  return self.min(that) === self;
-}
-
-/**
- * @tsplus static fncts.io.Schedule.IntervalOps __call
- */
-export function makeInterval(start: number, end: number): Interval {
-  if (start <= end) return Interval(start, end);
-  else return Interval.empty;
-}
-
-/**
- * @tsplus fluent fncts.io.Schedule.Interval max
- */
-export function max_(self: Interval, that: Interval): Interval {
-  const m = self.min(that);
-  if (m === self) return that;
-  else return self;
-}
-
-/**
- * @tsplus fluent fncts.io.Schedule.Interval min
- */
-export function min_(self: Interval, that: Interval): Interval {
-  if (self.endMilliseconds <= that.startMilliseconds) return self;
-  if (that.endMilliseconds <= self.startMilliseconds) return that;
-  if (self.startMilliseconds < that.startMilliseconds) return self;
-  if (that.startMilliseconds < self.startMilliseconds) return that;
-  if (self.endMilliseconds <= that.endMilliseconds) return self;
-  return that;
-}
-
-/**
- * @tsplus getter fncts.io.Schedule.Interval isNonEmpty
- */
-export function isNonEmpty(self: Interval): boolean {
-  return !self.isEmpty;
-}
-
-/**
- * @tsplus getter fncts.io.Schedule.Interval size
- */
-export function size(self: Interval): number {
-  return self.endMilliseconds - self.startMilliseconds;
-}
-
-/**
- * @tsplus fluent fncts.io.Schedule.Interval union
- */
-export function union_(self: Interval, that: Interval): Maybe<Interval> {
-  const istart = Math.max(self.startMilliseconds, that.startMilliseconds);
-  const iend   = Math.min(self.endMilliseconds, that.endMilliseconds);
-  if (istart <= iend) return Nothing();
-  else return Just(Interval(istart, iend));
-}