@fncts/base 0.0.13 → 0.0.14

package/_src/control/Z/api.ts

@@ -60,7 +60,7 @@ export function bimap_<W, S1, S2, R, E, A, G, B>(
 export function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(
   fa: Z<W, S1, S2, R, E, A>,
   onFailure: (e: E) => Z<W, S1, S3, R1, E1, B>,
-): Z<W, S1, S3, R & R1, E1, A | B> {
+): Z<W, S1, S3, R | R1, E1, A | B> {
   return fa.matchZ(onFailure, Z.succeedNow);
 }
 
@@ -70,7 +70,7 @@ export function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(
 export function catchJust_<W, S1, S2, R, E, A, S3, R1, E1, B>(
   fa: Z<W, S1, S2, R, E, A>,
   f: (e: E) => Maybe<Z<W, S1, S3, R1, E1, B>>,
-): Z<W, S1, S2 | S3, R & R1, E | E1, A | B> {
+): Z<W, S1, S2 | S3, R | R1, E | E1, A | B> {
   return fa.catchAll((e) => f(e).getOrElse(fa));
 }
 
@@ -184,31 +184,28 @@ export function erase<W, S1, S2, R, E, A>(wa: Z<W, S1, S2, R, E, A>): Z<never, S
 /**
  * @tsplus static fncts.control.ZOps fail
  */
-export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never> {
+export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never> {
   return Z.failCause(Cause.fail(e()));
 }
 
 /**
  * @tsplus static fncts.control.ZOps failNow
  */
-export function failNow<E>(e: E, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never> {
+export function failNow<E>(e: E, __tsplusTrace?: string): Z<never, unknown, never, never, E, never> {
   return Z.failCauseNow(Cause.fail(e));
 }
 
 /**
  * @tsplus static fncts.control.ZOps failCause
  */
-export function failCause<E>(
-  cause: Lazy<Cause<E>>,
-  __tsplusTrace?: string,
-): Z<never, unknown, never, unknown, E, never> {
+export function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never> {
   return Z.defer(Z.failCauseNow(cause()));
 }
 
 /**
  * @tsplus static fncts.control.ZOps failCauseNow
  */
-export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never> {
+export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never> {
   return new Fail(cause);
 }
 
@@ -226,14 +223,14 @@ export function flatten<W, S1, S2, R, E, A, W1, S3, R1, E1>(
  *
  * @tsplus static fncts.control.ZOps get
  */
-export function get<S>(): Z<never, S, S, unknown, never, S> {
+export function get<S>(): Z<never, S, S, never, never, S> {
   return Z.modify((s) => [s, s]);
 }
 
 /**
  * @tsplus static fncts.control.ZOps gets
  */
-export function gets<S, A>(f: (s: S) => A): Z<never, S, S, unknown, never, A> {
+export function gets<S, A>(f: (s: S) => A): Z<never, S, S, never, never, A> {
   return Z.modify((s) => [f(s), s]);
 }
 
@@ -247,14 +244,14 @@ export function getsZ<S, W, R, E, A>(f: (s: S) => Z<W, S, S, R, E, A>): Z<W, S,
 /**
  * @tsplus static fncts.control.ZOps halt
  */
-export function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Z<never, unknown, never, unknown, never, never> {
+export function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Z<never, unknown, never, never, never, never> {
   return Z.failCause(Cause.halt(defect()));
 }
 
 /**
  * @tsplus static fncts.control.ZOps haltNow
  */
-export function haltNow(defect: unknown, __tsplusTrace?: string): Z<never, unknown, never, unknown, never, never> {
+export function haltNow(defect: unknown, __tsplusTrace?: string): Z<never, unknown, never, never, never, never> {
   return Z.failCauseNow(Cause.halt(defect));
 }
 
@@ -341,7 +338,7 @@ export function matchZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E
   fa: Z<W, S1, S2, R, E, A>,
   onFailure: (e: E) => Z<W1, S5, S3, R1, E1, B>,
   onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>,
-): Z<W | W1 | W2, S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C> {
+): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C> {
   return fa.matchCauseZ((cause) => cause.failureOrCause.match(onFailure, Z.failCauseNow), onSuccess);
 }
 
@@ -352,7 +349,7 @@ export function matchCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S4,
   fa: Z<W, S1, S2, R, E, A>,
   onFailure: (e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>,
   onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>,
-): Z<W | W1 | W2, S0 & S1, S3 | S4, R & R1 & R2, E1 | E2, B | C> {
+): Z<W | W1 | W2, S0 & S1, S3 | S4, R | R1 | R2, E1 | E2, B | C> {
   return matchLogCauseZ_(
     fa,
     (ws, e) => onFailure(e).mapLog((w1s) => ws.concat(w1s)),
@@ -367,7 +364,7 @@ export function matchLogZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2
   fa: Z<W, S1, S2, R, E, A>,
   onFailure: (ws: Conc<W>, e: E) => Z<W1, S5, S3, R1, E1, B>,
   onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>,
-): Z<W | W1 | W2, S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C> {
+): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C> {
   return matchLogCauseZ_(
     fa,
     (ws, cause) => cause.failureOrCause.match((e) => onFailure(ws, e), Z.failCauseNow),
@@ -398,7 +395,7 @@ export function matchLogCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S
  *
  * @tsplus static fncts.control.ZOps modify
  */
-export function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1, S2, unknown, never, A> {
+export function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1, S2, never, never, A> {
   return new Modify(f);
 }
 
@@ -407,7 +404,7 @@ export function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1,
  *
  * @tsplus static fncts.control.ZOps modifyEither
  */
-export function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, unknown, E, A> {
+export function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, never, E, A> {
   return Z.get<S1>()
     .map(f)
     .flatMap((r) => r.match(Z.failNow, ([a, s2]) => Z.succeedNow(a).mapState(() => s2)));
@@ -419,7 +416,7 @@ export function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A,
 export function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(
   fa: Z<W, S1, S2, R, E, A>,
   fb: Lazy<Z<W1, S1, S3, R1, E1, A1>>,
-): Z<W | W1, S1, S2 | S3, R & R1, E | E1, A | A1> {
+): Z<W | W1, S1, S2 | S3, R | R1, E | E1, A | A1> {
   return fa.matchZ(() => fb(), Z.succeedNow);
 }
 
@@ -432,7 +429,7 @@ export function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(
 export function orElseEither_<W, S1, S2, R, E, A, S3, S4, R1, E1, A1>(
   fa: Z<W, S1, S2, R, E, A>,
   that: Lazy<Z<W, S3, S4, R1, E1, A1>>,
-): Z<W, S1 & S3, S2 | S4, R & R1, E1, Either<A, A1>> {
+): Z<W, S1 & S3, S2 | S4, R | R1, E1, Either<A, A1>> {
   return fa.matchZ(
     () => that().map(Either.right),
     (a) => Z.succeedNow(Either.left(a)),
@@ -454,7 +451,7 @@ export function provideEnvironment_<W, S1, S2, R, E, A>(
  *
  * @tsplus static fncts.control.ZOps put
  */
-export function put<S>(s: S): Z<never, unknown, S, unknown, never, void> {
+export function put<S>(s: S): Z<never, unknown, S, never, never, void> {
   return Z.modify(() => [undefined, s]);
 }
 
@@ -487,7 +484,7 @@ export function repeatUntil_<W, S1, S2 extends S1, R, E, A>(
 export function succeed<A, W = never, S1 = unknown, S2 = never>(
   effect: Lazy<A>,
   __tsplusTrace?: string,
-): Z<W, S1, S2, unknown, never, A> {
+): Z<W, S1, S2, never, never, A> {
   return new Succeed(effect);
 }
 
@@ -497,7 +494,7 @@ export function succeed<A, W = never, S1 = unknown, S2 = never>(
 export function succeedNow<A, W = never, S1 = unknown, S2 = never>(
   a: A,
   __tsplusTrace?: string,
-): Z<W, S1, S2, unknown, never, A> {
+): Z<W, S1, S2, never, never, A> {
   return new SucceedNow(a);
 }
 
@@ -514,14 +511,14 @@ export function tap_<W, S1, S2, R, E, A, W1, S3, R1, E1, B>(
 /**
  * @tsplus static fncts.control.ZOps tell
  */
-export function tell<W>(w: W): Z<W, unknown, never, unknown, never, void> {
+export function tell<W>(w: W): Z<W, unknown, never, never, never, void> {
   return Z.tellAll(Conc.single(w));
 }
 
 /**
  * @tsplus static fncts.control.ZOps tellAll
  */
-export function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, unknown, never, void> {
+export function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, never, never, void> {
   return new Tell(ws);
 }
 
@@ -540,14 +537,14 @@ export function transform_<W, S1, S2, R, E, A, S3, B>(
 /**
  * @tsplus static fncts.control.ZOps unit
  */
-export const unit: Z<never, unknown, never, unknown, never, void> = Z.succeedNow(undefined);
+export const unit: Z<never, unknown, never, never, never, void> = Z.succeedNow(undefined);
 
 /**
  * Constructs a computation from the specified update function.
  *
  * @tsplus static fncts.control.ZOps update
  */
-export function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, unknown, never, void> {
+export function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, never, never, void> {
   return Z.modify((s) => [undefined, f(s)]);
 }
 

package/_src/control/Z/definition.ts

@@ -32,7 +32,7 @@ export abstract class Z<W, S1, S2, R, E, A> {
   readonly _W!: () => W;
   readonly _S1!: (_: S1) => void;
   readonly _S2!: () => S2;
-  readonly _R!: (_: R) => void;
+  readonly _R!: () => R;
   readonly _E!: () => E;
   readonly _A!: () => A;
 }
@@ -75,14 +75,14 @@ export const enum ZTag {
   MapLog = "MapLog",
 }
 
-export class SucceedNow<A> extends Z<never, unknown, never, unknown, never, A> {
+export class SucceedNow<A> extends Z<never, unknown, never, never, never, A> {
   readonly _tag = ZTag.SucceedNow;
   constructor(readonly value: A) {
     super();
   }
 }
 
-export class Succeed<A> extends Z<never, unknown, never, unknown, never, A> {
+export class Succeed<A> extends Z<never, unknown, never, never, never, A> {
   readonly _tag = ZTag.Succeed;
   constructor(readonly effect: () => A) {
     super();
@@ -96,14 +96,14 @@ export class Defer<W, S1, S2, R, E, A> extends Z<W, S1, S2, R, E, A> {
   }
 }
 
-export class Fail<E> extends Z<never, unknown, never, unknown, E, never> {
+export class Fail<E> extends Z<never, unknown, never, never, E, never> {
   readonly _tag = ZTag.Fail;
   constructor(readonly cause: Cause<E>) {
     super();
   }
 }
 
-export class Modify<S1, S2, A> extends Z<never, S1, S2, unknown, never, A> {
+export class Modify<S1, S2, A> extends Z<never, S1, S2, never, never, A> {
   readonly _tag = ZTag.Modify;
   constructor(readonly run: (s1: S1) => readonly [A, S2]) {
     super();
@@ -149,7 +149,7 @@ export class Provide<W, S1, S2, R, E, A> extends Z<W, S1, S2, never, E, A> {
   }
 }
 
-export class Tell<W> extends Z<W, unknown, never, unknown, never, void> {
+export class Tell<W> extends Z<W, unknown, never, never, never, void> {
   readonly _tag = ZTag.Tell;
   constructor(readonly log: Conc<W>) {
     super();
@@ -179,7 +179,6 @@ export type Concrete =
 /**
  * @tsplus static fncts.control.ZOps concrete
  */
-// @ts-expect-error
 export function concrete(_: Z<any, any, any, any, any, any>): asserts _ is Concrete {
   //
 }

package/_src/control/Z/runtime.ts

@@ -246,7 +246,7 @@ export function unsafeRunReader_<W, R, A>(ma: Z<W, unknown, never, R, never, A>,
  *
  * @tsplus fluent fncts.control.Z unsafeRunState
  */
-export function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): S2 {
+export function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): S2 {
   return ma.unsafeRun(s)[0];
 }
 
@@ -256,7 +256,7 @@ export function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A
  *
  * @tsplus fluent fncts.control.Z unsafeRunStateResult
  */
-export function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): A {
+export function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): A {
   return ma.unsafeRunAll(s)[1].match(
     (cause) => {
       // throw cause.squash
@@ -271,7 +271,7 @@ export function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, ne
  *
  * @tsplus getter fncts.control.Z unsafeRunExit
  */
-export function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, unknown, E, A>): Exit<E, A> {
+export function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, never, E, A>): Exit<E, A> {
   return ma.unsafeRunAll({} as never)[1].map(([_, a]) => a);
 }
 
@@ -279,7 +279,7 @@ export function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, unknown, E, A
  *
  * @tsplus getter fncts.control.Z unsafeRunWriter
  */
-export function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, unknown, never, A>): readonly [Conc<W>, A] {
+export function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, never, never, A>): readonly [Conc<W>, A] {
   const [w, exit] = ma.unsafeRunAll({});
   return exit.match(
     () => {

package/_src/control.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: type-barrel, include: ./control/*.ts }
+export type {} from "./control/Eval.js";
+export type {} from "./control/LazyValue.js";
+export type {} from "./control/Z.js";
+// codegen:end

package/_src/data/DecodeError/definition.ts

@@ -225,3 +225,11 @@ export class UnionError extends DecodeError {
       .map((errors) => RoseTree(`${this.errors.length} error(s) found while decoding ${this.label}`, errors)),
   );
 }
+
+export class EmptyError extends DecodeError {
+  readonly _tag = "EmptyError";
+  constructor(readonly actual: unknown) {
+    super();
+  }
+  render = Eval(RoseTree(cannotDecode(this.actual, "a collection containing at least one element")));
+}

package/_src/data/DecodeError.ts

@@ -1,3 +1,4 @@
 // codegen:start { preset: barrel, include: ./DecodeError/*.ts }
 export * from "./DecodeError/definition.js";
+export * from "./DecodeError/instances.js";
 // codegen:end

package/_src/data/Either/definition.ts

@@ -3,7 +3,7 @@ export const enum EitherTag {
   Right = "Right",
 }
 
-export const EitherTypeId = Symbol.for("fncts.base.data.Either");
+export const EitherTypeId = Symbol.for("fncts.data.Either");
 export type EitherTypeId = typeof EitherTypeId;
 
 export interface EitherF extends HKT {

package/_src/data/Maybe/definition.ts

@@ -23,7 +23,7 @@ const _nothingHash = Hashable.string("fncts.Nothing");
  * @tsplus companion fncts.MaybeOps
  */
 export class Maybe<A> {
-  readonly _A!: () => A;
+  declare _A: () => A;
   readonly _typeId: MaybeTypdId = MaybeTypeId;
 }
 
@@ -61,7 +61,7 @@ export class Nothing extends Maybe<never> {
 /**
  * @tsplus unify fncts.Maybe
  */
-export function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [Maybe<infer A>] ? A : never> {
+export function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [{ _A: () => infer A }] ? A : never> {
   return self;
 }
 

package/_src/data/These/definition.ts

@@ -4,7 +4,7 @@ export const enum TheseTag {
   Both = "Both",
 }
 
-export const TheseTypeId = Symbol.for("fncts.base.data.These");
+export const TheseTypeId = Symbol.for("fncts.data.These");
 export type TheseTypeId = typeof TheseTypeId;
 
 /**

package/_src/data/string/api.ts

@@ -175,7 +175,7 @@ export const under = Pipeable(under_);
 /**
  * Join newline-separated strings together.
  *
- * @tsplus getter fncts.base.ImmutableArray unlines
+ * @tsplus getter fncts.ImmutableArray unlines
  */
 export function unlines(as: ReadonlyArray<string>): string {
   return as.join("\n");

package/_src/data.ts

@@ -0,0 +1,35 @@
+// codegen:start { preset: type-barrel, include: ./data/*.ts }
+export type {} from "./data/bigint.js";
+export type {} from "./data/boolean.js";
+export type {} from "./data/Branded.js";
+export type {} from "./data/Byte.js";
+export type {} from "./data/CaseClass.js";
+export type {} from "./data/Cause.js";
+export type {} from "./data/Const.js";
+export type {} from "./data/DecodeError.js";
+export type {} from "./data/Decoder.js";
+export type {} from "./data/Duration.js";
+export type {} from "./data/Either.js";
+export type {} from "./data/Environment.js";
+export type {} from "./data/exceptions.js";
+export type {} from "./data/ExecutionStrategy.js";
+export type {} from "./data/Exit.js";
+export type {} from "./data/FiberId.js";
+export type {} from "./data/function.js";
+export type {} from "./data/Identity.js";
+export type {} from "./data/Interval.js";
+export type {} from "./data/Intervals.js";
+export type {} from "./data/Maybe.js";
+export type {} from "./data/Newtype.js";
+export type {} from "./data/number.js";
+export type {} from "./data/object.js";
+export type {} from "./data/Patch.js";
+export type {} from "./data/Predicate.js";
+export type {} from "./data/Refinement.js";
+export type {} from "./data/string.js";
+export type {} from "./data/Tag.js";
+export type {} from "./data/These.js";
+export type {} from "./data/Trace.js";
+export type {} from "./data/TraceElement.js";
+export type {} from "./data/Zipped.js";
+// codegen:end

package/_src/global.ts

@@ -0,0 +1,252 @@
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/base";
+
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/collection/compat/Array";
+/**
+ * @tsplus global
+ */
+import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus global
+ */
+import { Dictionary } from "@fncts/base/collection/immutable/Dictionary/definition";
+/**
+ * @tsplus global
+ */
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+/**
+ * @tsplus global
+ */
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+/**
+ * @tsplus global
+ */
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+/**
+ * @tsplus global
+ */
+import {
+  ImmutableNonEmptyArray,
+  NonEmptyArray,
+  ReadonlyNonEmptyArray,
+} from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+/**
+ * @tsplus global
+ */
+import { Cons, List, Nil } from "@fncts/base/collection/immutable/List/definition";
+/**
+ * @tsplus global
+ */
+import { Queue as ImmutableQueue } from "@fncts/base/collection/immutable/Queue/definition";
+/**
+ * @tsplus global
+ */
+import { RoseTree } from "@fncts/base/collection/immutable/RoseTree";
+/**
+ * @tsplus global
+ */
+import { SortedMap } from "@fncts/base/collection/immutable/SortedMap/definition";
+/**
+ * @tsplus global
+ */
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+/**
+ * @tsplus global
+ */
+import { Iterable } from "@fncts/base/collection/Iterable/definition";
+/**
+ * @tsplus global
+ */
+import { HashMap as MutableHashMap } from "@fncts/base/collection/mutable/HashMap";
+/**
+ * @tsplus global
+ */
+import { HashSet as MutableHashSet } from "@fncts/base/collection/mutable/HashSet";
+/**
+ * @tsplus global
+ */
+import { ListBuffer } from "@fncts/base/collection/mutable/ListBuffer";
+/**
+ * @tsplus global
+ */
+import { Eval } from "@fncts/base/control/Eval/definition";
+/**
+ * @tsplus global
+ */
+import { LazyValue } from "@fncts/base/control/LazyValue";
+/**
+ * @tsplus global
+ */
+import { Z } from "@fncts/base/control/Z/definition";
+/**
+ * @tsplus global
+ */
+import { Byte } from "@fncts/base/data/Byte";
+/**
+ * @tsplus global
+ */
+import { CaseClass } from "@fncts/base/data/CaseClass";
+/**
+ * @tsplus global
+ */
+import { Cause } from "@fncts/base/data/Cause/definition";
+/**
+ * @tsplus global
+ */
+import { Const } from "@fncts/base/data/Const/definition";
+/**
+ * @tsplus global
+ */
+import { Datum } from "@fncts/base/data/Datum/definition";
+/**
+ * @tsplus global
+ */
+import { DatumEither } from "@fncts/base/data/DatumEither/definition";
+/**
+ * @tsplus global
+ */
+import { Decoder } from "@fncts/base/data/Decoder";
+/**
+ * @tsplus global
+ */
+import { Duration } from "@fncts/base/data/Duration/definition";
+/**
+ * @tsplus global
+ */
+import { Either } from "@fncts/base/data/Either/definition";
+/**
+ * @tsplus global
+ */
+import { Environment } from "@fncts/base/data/Environment/definition";
+/**
+ * @tsplus global
+ */
+import {
+  ArrayIndexOutOfBoundsError,
+  IllegalArgumentError,
+  IllegalStateError,
+  IndexOutOfBoundsError,
+  InterruptedException,
+  InvalidCapacityError,
+  isInterruptedException,
+  isInvalidCapacityError,
+  NoSuchElementError,
+} from "@fncts/base/data/exceptions";
+/**
+ * @tsplus global
+ */
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+/**
+ * @tsplus global
+ */
+import { Exit } from "@fncts/base/data/Exit/definition";
+/**
+ * @tsplus global
+ */
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+/**
+ * @tsplus global
+ */
+import { unsafeCoerce } from "@fncts/base/data/function/api";
+/**
+ * @tsplus global
+ */
+import { Lazy } from "@fncts/base/data/function/definition";
+/**
+ * @tsplus global
+ */
+import { Identity } from "@fncts/base/data/Identity/definition";
+/**
+ * @tsplus global
+ */
+import { Interval } from "@fncts/base/data/Interval";
+/**
+ * @tsplus global
+ */
+import { Intervals } from "@fncts/base/data/Intervals";
+/**
+ * @tsplus global
+ */
+import { Just, Maybe, MaybeTag, Nothing } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus global
+ */
+import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/data/number/definition";
+import {} from "@fncts/base/data/object/definition";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/data/object/definition";
+/**
+ * @tsplus global
+ */
+import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
+/**
+ * @tsplus global
+ */
+import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/data/string/definition";
+/**
+ * @tsplus global
+ */
+import { Struct } from "@fncts/base/data/Struct/definition";
+/**
+ * @tsplus global
+ */
+import { Tag } from "@fncts/base/data/Tag/definition";
+/**
+ * @tsplus global
+ */
+import { These } from "@fncts/base/data/These";
+/**
+ * @tsplus global
+ */
+import { Trace } from "@fncts/base/data/Trace/definition";
+/**
+ * @tsplus global
+ */
+import { TraceElement } from "@fncts/base/data/TraceElement/definition";
+/**
+ * @tsplus global
+ */
+import { Zipped } from "@fncts/base/data/Zipped";
+/**
+ * @tsplus global
+ */
+import { Stack } from "@fncts/base/internal/Stack";
+/**
+ * @tsplus global
+ */
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+/**
+ * @tsplus global
+ */
+import { Guard } from "@fncts/base/typeclass/Guard";
+/**
+ * @tsplus global
+ */
+import { Has } from "@fncts/base/typeclass/Has";
+/**
+ * @tsplus global
+ */
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+/**
+ * @tsplus global
+ */
+import { hasTypeId, isByte, isObject } from "@fncts/base/util/predicates";
+/**
+ * @tsplus global
+ */
+import { HKT } from "@fncts/typelevel/HKT";

package/_src/index.ts

@@ -0,0 +1,8 @@
+export type {} from "./collection.js";
+export type {} from "./control.js";
+export type {} from "./data.js";
+export type {} from "./json.js";
+export type {} from "./optics.js";
+export type {} from "./typeclass.js";
+export type {} from "./types.js";
+export type {} from "./util.js";