@fncts/base 0.0.1

package/_src/data/Maybe/api.ts

@@ -0,0 +1,187 @@
+import type { MaybeF } from "./instances.js";
+import type { Eq, Monoid } from "@fncts/base/typeclass";
+import type { Nullable } from "@fncts/base/types";
+
+import { Apply } from "@fncts/base/typeclass";
+
+import { identity } from "../function.js";
+import { MaybeTag } from "./definition.js";
+
+/**
+ * @tsplus fluent fncts.Maybe ap
+ */
+export function ap_<A, B>(self: Maybe<(a: A) => B>, fa: Maybe<A>): Maybe<B> {
+  return self._tag === MaybeTag.Just && fa._tag === MaybeTag.Just ? Just(self.value(fa.value)) : Nothing();
+}
+
+/**
+ * @tsplus static fncts.MaybeOps sequenceS
+ */
+export const sequenceS = Apply.sequenceSF<MaybeF>({ map_, ap_, zipWith_ });
+
+/**
+ * Applies `f` to the value contained in `Maybe` if it is `Just` and returns the result,
+ * otherwise returns `Nothing`.
+ *
+ * @tsplus fluent fncts.Maybe flatMap
+ */
+export function flatMap_<A, B>(self: Maybe<A>, f: (a: A) => Maybe<B>): Maybe<B> {
+  return self._tag === MaybeTag.Just ? f(self.value) : (self as Nothing);
+}
+
+/**
+ * @constrained
+ */
+export function elem_<A>(E: Eq<A>) {
+  return (self: Maybe<A>, elem: A): boolean => (self._tag === MaybeTag.Just ? E.equals_(self.value, elem) : false);
+}
+
+/**
+ * @tsplus fluent fncts.Maybe elem
+ */
+export function elemSelf<A>(self: Maybe<A>) {
+  return (E: Eq<A>) =>
+    (elem: A): boolean =>
+      elem_(E)(self, elem);
+}
+
+/**
+ * @constrained
+ * @tsplus fluent fncts.Maybe exists
+ */
+export function exists_<A>(self: Maybe<A>, p: Predicate<A>): boolean {
+  return self._tag === MaybeTag.Just ? p(self.value) : false;
+}
+
+/**
+ * @tsplus fluent fncts.Maybe filter
+ */
+export function filter_<A, B>(self: Maybe<A>, p: Predicate<A>): Maybe<A>;
+export function filter_<A, B extends A>(self: Maybe<A>, p: Refinement<A, B>): Maybe<B>;
+export function filter_<A, B>(self: Maybe<A>, p: Predicate<A>): Maybe<A> {
+  return self._tag === MaybeTag.Just && p(self.value) ? self : Nothing();
+}
+
+/**
+ * @tsplus fluent fncts.Maybe filter
+ */
+export function filterMap_<A, B>(self: Maybe<A>, f: (a: A) => Maybe<B>): Maybe<B> {
+  return self.flatMap(f);
+}
+
+/**
+ * @tsplus getter fncts.Maybe flatten
+ */
+export function flatten<A>(self: Maybe<Maybe<A>>): Maybe<A> {
+  return self.flatMap(identity);
+}
+
+/**
+ * @tsplus fluent fncts.Maybe partition
+ */
+export function partition_<A>(self: Maybe<A>, p: Predicate<A>): readonly [Maybe<A>, Maybe<A>];
+export function partition_<A, B extends A>(self: Maybe<A>, p: Refinement<A, B>): readonly [Maybe<A>, Maybe<B>];
+export function partition_<A>(self: Maybe<A>, p: Predicate<A>): readonly [Maybe<A>, Maybe<A>] {
+  return self._tag === MaybeTag.Just && p(self.value) ? [Nothing(), self] : [self, Nothing()];
+}
+
+/**
+ * @tsplus fluent fncts.Maybe partitionMap
+ */
+export function partitionMap_<A, B, C>(self: Maybe<A>, f: (a: A) => Either<B, C>): readonly [Maybe<B>, Maybe<C>] {
+  if (self._tag === MaybeTag.Just) {
+    return f(self.value).match(
+      (b) => [Just(b), Nothing()],
+      (c) => [Nothing(), Just(c)],
+    );
+  } else {
+    return [Nothing(), Nothing()];
+  }
+}
+
+/**
+ * @tsplus fluent fncts.Maybe foldLeft
+ */
+export function foldLeft_<A, B>(self: Maybe<A>, b: B, f: (b: B, a: A) => B): B {
+  return self._tag === MaybeTag.Just ? f(b, self.value) : b;
+}
+
+/**
+ * @tsplus fluent fncts.Maybe foldRight
+ */
+export function foldRight_<A, B>(self: Maybe<A>, b: B, f: (a: A, b: B) => B): B {
+  return self._tag === MaybeTag.Just ? f(self.value, b) : b;
+}
+
+/**
+ * @constrained
+ */
+export function foldMap_<M>(M: Monoid<M>) {
+  return <A>(self: Maybe<A>, f: (a: A) => M): M => (self._tag === MaybeTag.Just ? f(self.value) : M.nat);
+}
+
+/**
+ * @tsplus getter fncts.Maybe foldMap
+ */
+export function foldMapSelf<A>(self: Maybe<A>) {
+  return <M>(M: Monoid<M>) =>
+    (f: (a: A) => M): M =>
+      foldMap_(M)(self, f);
+}
+
+/**
+ * Extracts the value from `Maybe` if it exists, or returns the result of `orElse`.
+ *
+ * @tsplus fluent fncts.Maybe getOrElse
+ */
+export function getOrElse_<A, B>(self: Maybe<A>, orElse: Lazy<B>): A | B {
+  return self._tag === MaybeTag.Just ? self.value : orElse();
+}
+
+/**
+ * Applies `f` to the value contained in `Maybe` if it is `Just`, otherwise returns `Nothing`.
+ *
+ * @tsplus fluent fncts.Maybe map
+ */
+export function map_<A, B>(self: Maybe<A>, f: (a: A) => B): Maybe<B> {
+  return self._tag === MaybeTag.Just ? Just(f(self.value)) : (self as Nothing);
+}
+
+/**
+ * `chain` + `fromNullable`
+ *
+ * @tsplus fluent fncts.Maybe mapNullable
+ */
+export function mapNullable_<A, B>(self: Maybe<A>, f: (a: A) => Nullable<B>): Maybe<NonNullable<B>> {
+  return self.flatMap(Maybe.fromNullableK(f));
+}
+
+/**
+ * @tsplus fluent fncts.Maybe orElse
+ */
+export function orElse_<A, B>(self: Maybe<A>, fb: Lazy<Maybe<B>>): Maybe<A | B> {
+  return self._tag === MaybeTag.Nothing ? fb() : self;
+}
+
+/**
+ * Extracts the value from `Maybe` if it is `Just`, otherwise returns `undefined`
+ *
+ * @tsplus getter fncts.Maybe value
+ */
+export function toUndefined<A>(self: Maybe<A>): A | undefined {
+  return self.match(() => undefined, identity);
+}
+
+/**
+ * @tsplus fluent fncts.Maybe zipWith
+ */
+export function zipWith_<A, B, C>(self: Maybe<A>, fb: Maybe<B>, f: (a: A, b: B) => C): Maybe<C> {
+  return self._tag === MaybeTag.Just && fb._tag === MaybeTag.Just ? Just(f(self.value, fb.value)) : Nothing();
+}
+
+/**
+ * @tsplus fluent fncts.Maybe zip
+ */
+export function zip_<A, B>(self: Maybe<A>, that: Maybe<B>): Maybe<readonly [A, B]> {
+  return self.zipWith(that, (a, b) => [a, b]);
+}

package/_src/data/Maybe/constructors.ts

@@ -0,0 +1,84 @@
+import type { Nullable } from "@fncts/base/types";
+
+/**
+ * @tsplus static fncts.MaybeOps just
+ * @tsplus static fncts.JustOps __call
+ */
+export function just<A>(a: A): Maybe<A> {
+  return new Just(a);
+}
+
+const _Nothing = new Nothing();
+
+/**
+ * @tsplus static fncts.MaybeOps nothing
+ * @tsplus static fncts.NothingOps __call
+ */
+export function nothing<A = never>(): Maybe<A> {
+  return _Nothing;
+}
+
+/**
+ * @tsplus static fncts.MaybeOps fromNullable
+ */
+export function fromNullable<A>(a: Nullable<A>): Maybe<NonNullable<A>> {
+  return a == null ? Nothing() : Just(a as NonNullable<A>);
+}
+
+/**
+ * @tsplus static fncts.MaybeOps fromNullableK
+ */
+export function fromNullableK<P extends ReadonlyArray<unknown>, A>(f: (...params: P) => Nullable<A>) {
+  return (...params: P): Maybe<NonNullable<A>> => Maybe.fromNullable(f(...params));
+}
+
+/**
+ * @tsplus static fncts.MaybeOps fromPredicate
+ */
+export function fromPredicate_<A>(a: A, p: Predicate<A>): Maybe<A>;
+export function fromPredicate_<A, B extends A>(a: A, p: Refinement<A, B>): Maybe<A>;
+export function fromPredicate_<A>(a: A, p: Predicate<A>): Maybe<A> {
+  return p(a) ? Just(a) : Nothing();
+}
+
+/**
+ * @tsplus static fncts.MaybeOps tryCatch
+ */
+export function tryCatch<A>(thunk: () => A): Maybe<A> {
+  try {
+    return Just(thunk());
+  } catch {
+    return Nothing();
+  }
+}
+
+/**
+ * @tsplus static fncts.MaybeOps tryCatchK
+ */
+export function tryCatchK<P extends ReadonlyArray<unknown>, A>(f: (...params: P) => A) {
+  return (...params: P): Maybe<A> => tryCatch(() => f(...params));
+}
+
+class PartialException {
+  readonly _tag = "PartialException";
+}
+
+function raisePartial(): never {
+  throw new PartialException();
+}
+
+/**
+ * @tsplus static fncts.MaybeOps partial
+ */
+export function partial<P extends ReadonlyArray<unknown>, A>(f: (miss: () => never) => (...params: P) => A) {
+  return (...params: P): Maybe<A> => {
+    try {
+      return Just(f(raisePartial)(...params));
+    } catch (e) {
+      if (e instanceof PartialException) {
+        return Nothing();
+      }
+      throw e;
+    }
+  };
+}

package/_src/data/Maybe/definition.ts

@@ -0,0 +1,91 @@
+import { isObject } from "../../util/predicates.js";
+
+export const enum MaybeTag {
+  Just = "Just",
+  Nothing = "Nothing",
+}
+
+export const MaybeTypeId = Symbol.for("fncts.Maybe");
+export type MaybeTypdId = typeof MaybeTypeId;
+
+const _justHash    = Hashable.string("fncts.Just");
+const _nothingHash = Hashable.string("fncts.Nothing");
+
+/**
+ * @tsplus type fncts.Just
+ * @tsplus companion fncts.JustOps
+ */
+export class Just<A> {
+  readonly _typeId: MaybeTypdId = MaybeTypeId;
+  readonly _tag                 = MaybeTag.Just;
+  constructor(readonly value: A) {}
+  [Symbol.equals](that: unknown): boolean {
+    return isMaybe(that) && that.isJust() && Equatable.strictEquals(this.value, that.value);
+  }
+  get [Symbol.hash]() {
+    return Hashable.combine(_justHash, Hashable.unknown(this.value));
+  }
+}
+
+/**
+ * @tsplus type fncts.Nothing
+ * @tsplus companion fncts.NothingOps
+ */
+export class Nothing {
+  readonly _typeId: MaybeTypdId = MaybeTypeId;
+  readonly _tag                 = MaybeTag.Nothing;
+  [Symbol.equals](that: unknown): boolean {
+    return isMaybe(that) && that.isNothing();
+  }
+  get [Symbol.hash]() {
+    return _nothingHash;
+  }
+}
+
+/**
+ * @tsplus type fncts.Maybe
+ */
+export type Maybe<A> = Just<A> | Nothing;
+
+/**
+ * @tsplus type fncts.MaybeOps
+ */
+export interface MaybeOps {}
+
+export const Maybe: MaybeOps = {};
+
+/**
+ * @tsplus unify fncts.Maybe
+ */
+export function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [Maybe<infer A>] ? A : never> {
+  return self;
+}
+
+/**
+ * @tsplus static fncts.MaybeOps isMaybe
+ */
+export function isMaybe(u: unknown): u is Maybe<unknown> {
+  return (
+    isObject(u) &&
+    (MaybeTypeId in u ||
+      ("_tag" in u && typeof u["_tag"] === "string" && (u["_tag"] === "Nothing" || u["_tag"] === "Just")))
+  );
+}
+
+/**
+ * A type predicate determining if a `Maybe` is `Just`
+ *
+ * @tsplus fluent fncts.Maybe isJust
+ */
+export function isJust<A>(self: Maybe<A>): self is Just<A> {
+  return self._tag === MaybeTag.Just;
+}
+
+/**
+ * A type predicate determining if a `Maybe` is `Nothing`
+ *
+ * @tsplus fluent fncts.Maybe isNothing
+ */
+export function isNothing<A>(self: Maybe<A>): self is Nothing {
+  return self._tag === MaybeTag.Nothing;
+}

package/_src/data/Maybe/destructors.ts

@@ -0,0 +1,11 @@
+import { MaybeTag } from "./definition.js";
+
+/**
+ * Matches on each case of a `Maybe`, returning the result of `nothing` if the `Maybe`
+ * is `Nothing`, or returning the result of `just` if it is `Just`
+ *
+ * @tsplus fluent fncts.Maybe match
+ */
+export function match_<A, B, C>(self: Maybe<A>, nothing: () => B, just: (a: A) => C): B | C {
+  return self._tag === MaybeTag.Just ? just(self.value) : nothing();
+}

package/_src/data/Maybe/instances.ts

@@ -0,0 +1,53 @@
+import * as P from "../../typeclass.js";
+import {
+  ap_,
+  filter_,
+  filterMap_,
+  flatMap_,
+  foldLeft_,
+  foldRight_,
+  map_,
+  partition_,
+  partitionMap_,
+  zipWith_,
+} from "./api.js";
+import { just } from "./constructors.js";
+
+export interface MaybeF extends HKT {
+  readonly type: Maybe<this["A"]>;
+  readonly variance: {
+    readonly A: "-";
+  };
+}
+
+export const Functor: P.Functor<MaybeF> = P.Functor({ map_ });
+
+export const Apply: P.Apply<MaybeF> = P.Apply({ map_, ap_, zipWith_ });
+
+export const Applicative: P.Applicative<MaybeF> = P.Applicative({
+  map_,
+  ap_,
+  zipWith_,
+  pure: just,
+});
+
+export const Monad: P.Monad<MaybeF> = P.Monad({
+  map_,
+  ap_,
+  zipWith_,
+  pure: just,
+  flatMap_: flatMap_,
+});
+
+export const Foldable: P.Foldable<MaybeF> = P.Foldable({
+  foldLeft_,
+  foldRight_,
+});
+
+export const Filterable: P.Filterable<MaybeF> = P.Filterable({
+  map_,
+  filter_,
+  filterMap_,
+  partition_,
+  partitionMap_,
+});

package/_src/data/Maybe.ts

@@ -0,0 +1,7 @@
+// codegen:start {preset: barrel, include: Maybe/*.ts}
+export * from "./Maybe/api.js";
+export * from "./Maybe/constructors.js";
+export * from "./Maybe/definition.js";
+export * from "./Maybe/destructors.js";
+export * from "./Maybe/instances.js";
+// codegen:end

package/_src/data/Newtype.ts

@@ -0,0 +1,66 @@
+/**
+ * @tsplus type fncts.Newtype
+ */
+export interface Newtype<URI, A, C = HKT.None> {
+  readonly _URI: URI;
+  readonly _A: A;
+  readonly _C: C;
+}
+
+export declare namespace Newtype {
+  export type Iso<N extends NewtypeHKT, C = N["type"]["_C"]> = NewtypeIso<N, C>;
+}
+
+/**
+ * @tsplus type fncts.NewtypeOps
+ */
+export interface NewtypeOps {}
+
+export const Newtype: NewtypeOps = {};
+
+export interface NewtypeHKT extends HKT {
+  readonly type: Newtype<any, any>;
+}
+
+export interface NewtypeIso<N extends NewtypeHKT, C = N["type"]["_C"]> {
+  /**
+   * @tsplus macro identity
+   */
+  get: <
+    K extends HKT.GetExtends<C, "K", any>,
+    Q extends HKT.GetExtends<C, "Q", any>,
+    W extends HKT.GetExtends<C, "W", any>,
+    X extends HKT.GetExtends<C, "X", any>,
+    I extends HKT.GetExtends<C, "I", any>,
+    S extends HKT.GetExtends<C, "S", any>,
+    R extends HKT.GetExtends<C, "E", any>,
+    E extends HKT.GetExtends<C, "E", any>,
+    A extends HKT.GetExtends<C, "A", any>,
+  >(
+    _: HKT.Kind<N, N["type"]["_C"], K, Q, W, X, I, S, R, E, A>["_A"],
+  ) => HKT.Kind<N, HKT.None, K, Q, W, X, I, S, R, E, A>;
+  /**
+   * @tsplus macro identity
+   */
+  reverseGet: <
+    K extends HKT.GetExtends<C, "K", any>,
+    Q extends HKT.GetExtends<C, "Q", any>,
+    W extends HKT.GetExtends<C, "W", any>,
+    X extends HKT.GetExtends<C, "X", any>,
+    I extends HKT.GetExtends<C, "I", any>,
+    S extends HKT.GetExtends<C, "S", any>,
+    R extends HKT.GetExtends<C, "E", any>,
+    E extends HKT.GetExtends<C, "E", any>,
+    A extends HKT.GetExtends<C, "A", any>,
+  >(
+    _: HKT.Kind<N, HKT.None, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<N, HKT.None, K, Q, W, X, I, S, R, E, A>["_A"];
+}
+
+/**
+ * @tsplus static fncts.NewtypeOps __call
+ */
+export const newtype = <N extends NewtypeHKT>(): NewtypeIso<N> => ({
+  get: unsafeCoerce,
+  reverseGet: unsafeCoerce,
+});

package/_src/data/Patch/api.ts

@@ -0,0 +1,75 @@
+import { Cons } from "@fncts/base/collection/immutable/List";
+import { AddService, RemoveService, UpdateService } from "@fncts/base/data/Patch";
+import { Patch } from "@fncts/base/data/Patch/definition";
+import { Empty } from "@fncts/base/data/Patch/definition";
+import { Compose } from "@fncts/base/data/Patch/definition";
+import { concrete } from "@fncts/base/data/Patch/definition";
+
+/**
+ * @tsplus tailRec
+ */
+function applyLoop(environment: Environment<any>, patches: List<Patch<any, any>>): Environment<any> {
+  if (patches.isEmpty()) {
+    return environment;
+  }
+  const head = patches.head;
+  const tail = patches.tail;
+  concrete(head);
+  switch (head._tag) {
+    case "AddService":
+      return applyLoop(environment.add(head.service, head.tag), tail);
+    case "Compose":
+      return applyLoop(environment, Cons(head.first, Cons(head.second, tail)));
+    case "Empty":
+      return applyLoop(environment, tail);
+    case "RemoveService":
+      return applyLoop(environment, tail);
+    case "UpdateService":
+      return applyLoop(environment.update(head.update, head.tag), tail);
+  }
+}
+
+/**
+ * @tsplus fluent fncts.Environment.Patch __call
+ */
+export function apply<In, Out>(patch: Patch<In, Out>, environment: Environment<In>): Environment<Out> {
+  return applyLoop(environment, Cons(patch));
+}
+
+/**
+ * @tsplus fluent fncts.Environment.Patch compose
+ */
+export function compose<In, Out, Out2>(self: Patch<In, Out>, that: Patch<Out, Out2>): Patch<In, Out2> {
+  return new Compose(self, that);
+}
+
+const OrdEnvironmentMap = Number.Ord.contramap((_: readonly [Tag<unknown>, readonly [unknown, number]]) => _[1][1]);
+
+/**
+ * @tsplus static fncts.Environment.PatchOps diff
+ */
+export function diff<In, Out>(oldValue: Environment<In>, newValue: Environment<Out>): Patch<In, Out> {
+  const sorted                   = newValue.map.toArray.sort(OrdEnvironmentMap.compare_);
+  const [missingServices, patch] = sorted.foldLeft(
+    [oldValue.map.beginMutation, Patch.empty() as Patch<any, any>],
+    ([map, patch], [tag, [newService, newIndex]]) =>
+      map.get(tag).match(
+        () => [map.remove(tag), patch.compose(new AddService(newService, tag))],
+        ([oldService, oldIndex]) => {
+          if (oldService === newService && oldIndex === newIndex) {
+            return [map.remove(tag), patch];
+          } else {
+            return [map.remove(tag), patch.compose(new UpdateService((_: any) => newService, tag))];
+          }
+        },
+      ),
+  );
+  return missingServices.foldLeftWithIndex(patch, (tag, patch) => patch.compose(new RemoveService(tag)));
+}
+
+/**
+ * @tsplus static fncts.Environment.PatchOps empty
+ */
+export function empty<A>(): Patch<A, A> {
+  return new Empty();
+}

package/_src/data/Patch/definition.ts

@@ -0,0 +1,58 @@
+export const PatchTypeId = Symbol.for("fncts.Patch");
+export type PatchTypeId = typeof PatchTypeId;
+
+/**
+ * @tsplus type fncts.Environment.Patch
+ * @tsplus companion fncts.Environment.PatchOps
+ */
+export abstract class Patch<In, Out> {
+  readonly _typeId: PatchTypeId = PatchTypeId;
+  readonly _R!: (_: In) => void;
+  readonly _A!: () => Out;
+}
+
+export class AddService<Env, Service> extends Patch<Env, Env & Has<Service>> {
+  readonly _tag = "AddService";
+  constructor(readonly service: Service, readonly tag: Tag<Service>) {
+    super();
+  }
+}
+
+export class Compose<In, Out, Out2> extends Patch<In, Out2> {
+  readonly _tag = "Compose";
+  constructor(readonly first: Patch<In, Out>, readonly second: Patch<Out, Out2>) {
+    super();
+  }
+}
+
+export class Empty<Env> extends Patch<Env, Env> {
+  readonly _tag = "Empty";
+}
+
+export class RemoveService<Env, Service> extends Patch<Env & Has<Service>, Env> {
+  readonly _tag = "RemoveService";
+  constructor(readonly tag: Tag<Service>) {
+    super();
+  }
+}
+
+export class UpdateService<Env, Service> extends Patch<Env & Has<Service>, Env & Has<Service>> {
+  readonly _tag = "UpdateService";
+  constructor(readonly update: (_: Service) => Service, readonly tag: Tag<Service>) {
+    super();
+  }
+}
+
+export type Concrete =
+  | AddService<any, any>
+  | Compose<any, any, any>
+  | Empty<any>
+  | RemoveService<any, any>
+  | UpdateService<any, any>;
+
+/**
+ * @tsplus macro remove
+ */
+export function concrete(_: Patch<any, any>): asserts _ is Concrete {
+  //
+}

package/_src/data/Patch.ts

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

package/_src/data/Predicate/api.ts

@@ -0,0 +1,27 @@
+/**
+ * @tsplus operator fncts.Predicate &&
+ */
+export function and<A>(self: Predicate<A>, that: Predicate<A>): Predicate<A> {
+  return (a) => self(a) && that(a);
+}
+
+/**
+ * @tsplus fluent fncts.Predicate contramap
+ */
+export function contramap<A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B> {
+  return (b) => self(f(b));
+}
+
+/**
+ * @tsplus getter fncts.Predicate invert
+ */
+export function invert<A>(self: Predicate<A>): Predicate<A> {
+  return (a) => !self(a);
+}
+
+/**
+ * @tsplus operator fncts.Predicate ||
+ */
+export function or<A extends B, B>(self: Predicate<A>, that: Predicate<B>): Predicate<A> {
+  return (a) => self(a) || that(a);
+}

package/_src/data/Predicate/definition.ts

@@ -0,0 +1,10 @@
+/**
+ * @tsplus type fncts.Predicate
+ */
+export interface Predicate<A> {
+  (a: A): boolean;
+}
+
+export interface PredicateWithIndex<I, A> {
+  (i: I, a: A): boolean;
+}

package/_src/data/Predicate.ts

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