@fncts/base 0.0.20 → 0.0.21

package/_src/data/Maybe/api.ts

@@ -5,57 +5,68 @@ import { identity } from "../function.js";
 import { MaybeTag } from "./definition.js";
 
 /**
- * @tsplus fluent fncts.Maybe ap
+ * @tsplus pipeable fncts.Maybe ap
  */
-export function ap_<A, B>(self: Maybe<(a: A) => B>, fa: Maybe<A>): Maybe<B> {
-  self.concrete();
-  fa.concrete();
-  return self._tag === MaybeTag.Just && fa._tag === MaybeTag.Just ? Just(self.value(fa.value)) : Nothing();
+export function ap<A>(fa: Maybe<A>) {
+  return <B>(self: Maybe<(a: A) => B>): Maybe<B> => {
+    self.concrete();
+    fa.concrete();
+    return self._tag === MaybeTag.Just && fa._tag === MaybeTag.Just ? Just(self.value(fa.value)) : Nothing();
+  };
 }
 
 /**
  * Applies `f` to the value contained in `Maybe` if it is `Just` and returns the result,
  * otherwise returns `Nothing`.
  *
- * @tsplus fluent fncts.Maybe flatMap
+ * @tsplus pipeable fncts.Maybe flatMap
  */
-export function flatMap_<A, B>(self: Maybe<A>, f: (a: A) => Maybe<B>): Maybe<B> {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? f(self.value) : (self as Nothing);
+export function flatMap<A, B>(f: (a: A) => Maybe<B>) {
+  return (self: Maybe<A>): Maybe<B> => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? f(self.value) : (self as Nothing);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe elem
+ * @tsplus pipeable fncts.Maybe elem
  */
-export function elem_<A>(self: Maybe<A>, elem: A, E: Eq<A>): boolean {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? E.equals(self.value, elem) : false;
+export function elem<A>(elem: A, /** @tsplus auto */ E: Eq<A>) {
+  return (self: Maybe<A>): boolean => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? E.equals(self.value, elem) : false;
+  };
 }
 
 /**
- * @constrained
- * @tsplus fluent fncts.Maybe exists
+ * @tsplus pipeable fncts.Maybe exists
  */
-export function exists_<A>(self: Maybe<A>, p: Predicate<A>): boolean {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? p(self.value) : false;
+export function exists<A>(p: Predicate<A>) {
+  return (self: Maybe<A>): boolean => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? p(self.value) : false;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe filter
+ * @tsplus pipeable 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> {
-  self.concrete();
-  return self._tag === MaybeTag.Just && p(self.value) ? self : Nothing();
+export function filter<A>(p: Predicate<A>): <B>(self: Maybe<A>) => Maybe<A>;
+export function filter<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => Maybe<B>;
+export function filter<A>(p: Predicate<A>) {
+  return <B>(self: Maybe<A>): Maybe<A> => {
+    self.concrete();
+    return self._tag === MaybeTag.Just && p(self.value) ? self : Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe filter
+ * @tsplus pipeable fncts.Maybe filter
  */
-export function filterMap_<A, B>(self: Maybe<A>, f: (a: A) => Maybe<B>): Maybe<B> {
-  return self.flatMap(f);
+export function filterMap<A, B>(f: (a: A) => Maybe<B>) {
+  return (self: Maybe<A>): Maybe<B> => {
+    return self.flatMap(f);
+  };
 }
 
 /**
@@ -66,89 +77,107 @@ export function flatten<A>(self: Maybe<Maybe<A>>): Maybe<A> {
 }
 
 /**
- * @tsplus fluent fncts.Maybe partition
+ * @tsplus pipeable 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>] {
-  self.concrete();
-  return self._tag === MaybeTag.Just && p(self.value) ? [Nothing(), self] : [self, Nothing()];
+export function partition<A>(p: Predicate<A>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<A>];
+export function partition<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<B>];
+export function partition<A>(p: Predicate<A>) {
+  return (self: Maybe<A>): readonly [Maybe<A>, Maybe<A>] => {
+    self.concrete();
+    return self._tag === MaybeTag.Just && p(self.value) ? [Nothing(), self] : [self, Nothing()];
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe partitionMap
+ * @tsplus pipeable fncts.Maybe partitionMap
  */
-export function partitionMap_<A, B, C>(self: Maybe<A>, f: (a: A) => Either<B, C>): readonly [Maybe<B>, Maybe<C>] {
-  self.concrete();
-  if (self._tag === MaybeTag.Just) {
-    return f(self.value).match(
-      (b) => [Just(b), Nothing()],
-      (c) => [Nothing(), Just(c)],
-    );
-  } else {
-    return [Nothing(), Nothing()];
-  }
+export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
+  return (self: Maybe<A>): readonly [Maybe<B>, Maybe<C>] => {
+    self.concrete();
+    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
+ * @tsplus pipeable fncts.Maybe foldLeft
  */
-export function foldLeft_<A, B>(self: Maybe<A>, b: B, f: (b: B, a: A) => B): B {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? f(b, self.value) : b;
+export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
+  return (self: Maybe<A>): B => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? f(b, self.value) : b;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe foldRight
+ * @tsplus pipeable fncts.Maybe foldRight
  */
-export function foldRight_<A, B>(self: Maybe<A>, b: B, f: (a: A, b: B) => B): B {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? f(self.value, b) : b;
+export function foldRight<A, B>(b: B, f: (a: A, b: B) => B) {
+  return (self: Maybe<A>): B => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? f(self.value, b) : b;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe foldMap
+ * @tsplus pipeable fncts.Maybe foldMap
  */
-export function foldMap_<A, M>(self: Maybe<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? f(self.value) : M.nat;
+export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>) {
+  return (self: Maybe<A>): M => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? f(self.value) : M.nat;
+  };
 }
 
 /**
  * Extracts the value from `Maybe` if it exists, or returns the result of `orElse`.
  *
- * @tsplus fluent fncts.Maybe getOrElse
+ * @tsplus pipeable fncts.Maybe getOrElse
  */
-export function getOrElse_<A, B>(self: Maybe<A>, orElse: Lazy<B>): A | B {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? self.value : orElse();
+export function getOrElse<B>(orElse: Lazy<B>) {
+  return <A>(self: Maybe<A>): A | B => {
+    self.concrete();
+    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
+ * @tsplus pipeable fncts.Maybe map
  */
-export function map_<A, B>(self: Maybe<A>, f: (a: A) => B): Maybe<B> {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? Just(f(self.value)) : (self as Nothing);
+export function map<A, B>(f: (a: A) => B) {
+  return (self: Maybe<A>): Maybe<B> => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? Just(f(self.value)) : (self as Nothing);
+  };
 }
 
 /**
  * `chain` + `fromNullable`
  *
- * @tsplus fluent fncts.Maybe mapNullable
+ * @tsplus pipeable 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));
+export function mapNullable<A, B>(f: (a: A) => Nullable<B>) {
+  return (self: Maybe<A>): Maybe<NonNullable<B>> => {
+    return self.flatMap(Maybe.fromNullableK(f));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe orElse
+ * @tsplus pipeable fncts.Maybe orElse
  */
-export function orElse_<A, B>(self: Maybe<A>, fb: Lazy<Maybe<B>>): Maybe<A | B> {
-  self.concrete();
-  return self._tag === MaybeTag.Nothing ? fb() : self;
+export function orElse<B>(fb: Lazy<Maybe<B>>) {
+  return <A>(self: Maybe<A>): Maybe<A | B> => {
+    self.concrete();
+    return self._tag === MaybeTag.Nothing ? fb() : self;
+  };
 }
 
 /**
@@ -161,17 +190,21 @@ export function toUndefined<A>(self: Maybe<A>): A | undefined {
 }
 
 /**
- * @tsplus fluent fncts.Maybe zipWith
+ * @tsplus pipeable fncts.Maybe zipWith
  */
-export function zipWith_<A, B, C>(self: Maybe<A>, fb: Maybe<B>, f: (a: A, b: B) => C): Maybe<C> {
-  self.concrete();
-  fb.concrete();
-  return self._tag === MaybeTag.Just && fb._tag === MaybeTag.Just ? Just(f(self.value, fb.value)) : Nothing();
+export function zipWith<A, B, C>(fb: Maybe<B>, f: (a: A, b: B) => C) {
+  return (self: Maybe<A>): Maybe<C> => {
+    self.concrete();
+    fb.concrete();
+    return self._tag === MaybeTag.Just && fb._tag === MaybeTag.Just ? Just(f(self.value, fb.value)) : Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe zip
+ * @tsplus pipeable fncts.Maybe zip
  */
-export function zip_<A, B>(self: Maybe<A>, that: Maybe<B>): Maybe<Zipped.Make<A, B>> {
-  return self.zipWith(that, (a, b) => Zipped(a, b));
+export function zip<B>(that: Maybe<B>) {
+  return <A>(self: Maybe<A>): Maybe<Zipped.Make<A, B>> => {
+    return self.zipWith(that, (a, b) => Zipped(a, b));
+  };
 }

package/_src/data/Maybe/constructors.ts

@@ -35,9 +35,9 @@ export function fromNullableK<P extends ReadonlyArray<unknown>, A>(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> {
+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();
 }
 

package/_src/data/Maybe/definition.ts

@@ -61,7 +61,17 @@ export class Nothing extends Maybe<never> {
 /**
  * @tsplus unify fncts.Maybe
  */
-export function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [{ _A: () => 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/Maybe/destructors.ts

@@ -4,9 +4,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
+ * @tsplus pipeable fncts.Maybe match
  */
-export function match_<A, B, C>(self: Maybe<A>, nothing: () => B, just: (a: A) => C): B | C {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? just(self.value) : nothing();
+export function match<A, B, C>(nothing: () => B, just: (a: A) => C) {
+  return (self: Maybe<A>): B | C => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? just(self.value) : nothing();
+  };
 }

package/_src/data/Maybe/instances.ts

@@ -3,23 +3,12 @@ import type { MaybeF } from "@fncts/base/data/Maybe/definition";
 
 import { MaybeJson } from "@fncts/base/json/MaybeJson";
 
-import {
-  filter_,
-  filterMap_,
-  flatMap_,
-  foldLeft_,
-  foldRight_,
-  map_,
-  partition_,
-  partitionMap_,
-  zip_,
-  zipWith_,
-} from "./api.js";
+import { filter, filterMap, flatMap, foldLeft, foldRight, map, partition, partitionMap, zip, zipWith } from "./api.js";
 import { just } from "./constructors.js";
 
-export const Functor = HKT.instance<P.Functor<MaybeF>>({ map: map_ });
+export const Functor = HKT.instance<P.Functor<MaybeF>>({ map });
 
-export const Apply = HKT.instance<P.Apply<MaybeF>>({ ...Functor, zip: zip_, zipWith: zipWith_ });
+export const Apply = HKT.instance<P.Apply<MaybeF>>({ ...Functor, zip, zipWith });
 
 export const Applicative = HKT.instance<P.Applicative<MaybeF>>({
   ...Apply,
@@ -28,20 +17,20 @@ export const Applicative = HKT.instance<P.Applicative<MaybeF>>({
 
 export const Monad = HKT.instance<P.Monad<MaybeF>>({
   ...Applicative,
-  flatMap: flatMap_,
+  flatMap,
 });
 
 export const Foldable = HKT.instance<P.Foldable<MaybeF>>({
-  foldLeft: foldLeft_,
-  foldRight: foldRight_,
+  foldLeft,
+  foldRight,
 });
 
 export const Filterable = HKT.instance<P.Filterable<MaybeF>>({
   ...Functor,
-  filter: filter_,
-  filterMap: filterMap_,
-  partition: partition_,
-  partitionMap: partitionMap_,
+  filter,
+  filterMap,
+  partition,
+  partitionMap,
 });
 
 /**

package/_src/data/Predicate/api.ts

@@ -1,15 +1,19 @@
 /**
- * @tsplus operator fncts.Predicate &&
+ * @tsplus pipeable-operator fncts.Predicate &&
  */
-export function and<A>(self: Predicate<A>, that: Predicate<A>): Predicate<A> {
-  return (a) => self(a) && that(a);
+export function and<A>(that: Predicate<A>) {
+  return (self: Predicate<A>): Predicate<A> =>
+    (a) =>
+      self(a) && that(a);
 }
 
 /**
- * @tsplus fluent fncts.Predicate contramap
+ * @tsplus pipeable fncts.Predicate contramap
  */
-export function contramap<A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B> {
-  return (b) => self(f(b));
+export function contramap<A, B>(f: (b: B) => A) {
+  return (self: Predicate<A>): Predicate<B> => {
+    return (b) => self(f(b));
+  };
 }
 
 /**
@@ -22,6 +26,8 @@ export function invert<A>(self: Predicate<A>): Predicate<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);
+export function or<A extends B, B>(that: Predicate<B>) {
+  return (self: Predicate<A>): Predicate<A> =>
+    (a) =>
+      self(a) || that(a);
 }

package/_src/data/Refinement/api.ts

@@ -1,26 +1,32 @@
 /**
- * @tsplus fluent fncts.Refinement and
- * @tsplus operator fncts.Refinement &&
+ * @tsplus pipeable fncts.Refinement and
+ * @tsplus pipeable-operator fncts.Refinement &&
  */
-export function and<A, B extends A, C extends B>(self: Refinement<A, B>, that: Refinement<B, C>): Refinement<A, C>;
-export function and<A, B extends A>(self: Refinement<A, B>, that: Predicate<B>): Refinement<A, B>;
-export function and<A, B extends A>(self: Refinement<A, B>, that: Predicate<B>): Refinement<A, B> {
-  return (a): a is B => self(a) && that(a);
+export function and<A, B extends A, C extends B>(that: Refinement<B, C>): (self: Refinement<A, B>) => Refinement<A, C>;
+export function and<A, B extends A>(that: Predicate<B>): (self: Refinement<A, B>) => Refinement<A, B>;
+export function and<A, B extends A>(that: Predicate<B>) {
+  return (self: Refinement<A, B>): Refinement<A, B> => {
+    return (a): a is B => self(a) && that(a);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Refinement contramap
+ * @tsplus pipeable fncts.Refinement contramap
  */
-export function contramap<A extends C, B extends A, C>(self: Refinement<A, B>, f: (c: C) => A): Refinement<C, B> {
-  return (c): c is B => self(f(c));
+export function contramap<A extends C, C>(f: (c: C) => A) {
+  return <B extends A>(self: Refinement<A, B>): Refinement<C, B> => {
+    return (c): c is B => self(f(c));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Refinement or
- * @tsplus operator fncts.Refinement ||
+ * @tsplus pipeable fncts.Refinement or
+ * @tsplus pipeable-operator fncts.Refinement ||
  */
-export function or<A, B extends A, C extends A>(self: Refinement<A, B>, that: Refinement<A, C>): Refinement<A, B | C> {
-  return (a): a is B | C => self(a) || that(a);
+export function or<A, C extends A>(that: Refinement<A, C>) {
+  return <B extends A>(self: Refinement<A, B>): Refinement<A, B | C> => {
+    return (a): a is B | C => self(a) || that(a);
+  };
 }
 
 /**

package/_src/data/Struct/api.ts

@@ -27,82 +27,102 @@ export function makeStruct<A>(a: A): Struct<A> {
 }
 
 /**
- * @tsplus fluent fncts.Struct set
+ * @tsplus pipeable fncts.Struct set
  */
-export function set_<A, N extends string, B>(
-  self: Struct<A>,
-  key: EnsureLiteral<N>,
-  value: B,
-): Struct<{ [P in Exclude<keyof A, N> | N]: P extends Exclude<keyof A, N> ? A[P] : B }> {
-  return Struct.get({ ...self.getStruct, [key]: value }) as Struct<any>;
+export function set<N extends string, B>(key: EnsureLiteral<N>, value: B) {
+  return <A>(
+    self: Struct<A>,
+  ): Struct<{
+    [P in Exclude<keyof A, N> | N]: P extends Exclude<keyof A, N> ? A[P] : B;
+  }> => {
+    return Struct.get({ ...self.getStruct, [key]: value }) as Struct<any>;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Struct hmap
+ * @tsplus pipeable fncts.Struct hmap
  */
-export function hmap_<A extends {}, F extends { [N in keyof A]: (a: A[N]) => any }>(
-  self: Struct<A>,
-  fs: F,
-): Struct<{ readonly [K in keyof F]: ReturnType<F[K]> }> {
-  const keys = self.keys;
-  const out  = {} as any;
-  for (const key of keys) {
-    out[key] = fs[key](unsafeCoerce(self.getStruct[key]));
-  }
-  return out;
+export function hmap<
+  A extends {},
+  F extends {
+    [N in keyof A]: (a: A[N]) => any;
+  },
+>(fs: F) {
+  return (
+    self: Struct<A>,
+  ): Struct<{
+    readonly [K in keyof F]: ReturnType<F[K]>;
+  }> => {
+    const keys = self.keys;
+    const out  = {} as any;
+    for (const key of keys) {
+      out[key] = fs[key](unsafeCoerce(self.getStruct[key]));
+    }
+    return out;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Struct modify
+ * @tsplus pipeable fncts.Struct modify
  */
-export function modify_<A, N extends keyof A, B>(
-  self: Struct<A>,
-  key: N,
-  f: (a: A[N]) => B,
-): Struct<{ readonly [P in Exclude<keyof A, N> | N]: P extends Exclude<keyof A, N> ? A[P] : B }> {
-  return Struct.get({ ...self.getStruct, [key]: f(self.getStruct[key]) }) as Struct<any>;
+export function modify<A, N extends keyof A, B>(key: N, f: (a: A[N]) => B) {
+  return (
+    self: Struct<A>,
+  ): Struct<{
+    readonly [P in Exclude<keyof A, N> | N]: P extends Exclude<keyof A, N> ? A[P] : B;
+  }> => {
+    return Struct.get({ ...self.getStruct, [key]: f(self.getStruct[key]) }) as Struct<any>;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Struct pick
+ * @tsplus pipeable fncts.Struct pick
  */
-export function pick_<A, N extends ReadonlyArray<keyof A>>(
-  self: Struct<A>,
-  keys: [...N],
-): Struct<{ readonly [P in N[number]]: A[P] }> {
-  const out = {} as Pick<A, N[number]>;
-  for (const key of keys) {
-    out[key] = self.getStruct[key];
-  }
-  return Struct.get(out);
+export function pick<A, N extends ReadonlyArray<keyof A>>(keys: [...N]) {
+  return (
+    self: Struct<A>,
+  ): Struct<{
+    readonly [P in N[number]]: A[P];
+  }> => {
+    const out = {} as Pick<A, N[number]>;
+    for (const key of keys) {
+      out[key] = self.getStruct[key];
+    }
+    return Struct.get(out);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Struct omit
+ * @tsplus pipeable fncts.Struct omit
  */
-export function omit_<A extends {}, N extends ReadonlyArray<keyof A>>(
-  self: Struct<A>,
-  keys: [...N],
-): Struct<{ readonly [P in Exclude<keyof A, N[number]>]: A[P] }> {
-  const newKeys = keys.asImmutableArray.difference(self.keys.asImmutableArray, Eq({ equals: (x, y) => x === y }));
-  const out     = {} as any;
-  for (const key of newKeys) {
-    out[key] = self.getStruct[key];
-  }
-  return Struct.get(out);
+export function omit<A extends {}, N extends ReadonlyArray<keyof A>>(keys: [...N]) {
+  return (
+    self: Struct<A>,
+  ): Struct<{
+    readonly [P in Exclude<keyof A, N[number]>]: A[P];
+  }> => {
+    const newKeys = keys.asImmutableArray.difference(self.keys.asImmutableArray, Eq({ equals: (x, y) => x === y }));
+    const out     = {} as any;
+    for (const key of newKeys) {
+      out[key] = self.getStruct[key];
+    }
+    return Struct.get(out);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Struct map
+ * @tsplus pipeable fncts.Struct map
  */
-export function map_<A, B>(self: Struct<A>, f: (a: A[keyof A]) => B): Struct<Record<keyof A, B>> {
-  const out  = {} as Record<keyof A, B>;
-  const keys = Object.keys(self);
-  for (let i = 0; i < keys.length; i++) {
-    const k = keys[i]! as keyof A;
-    out[k]  = f(self.getStruct[k]);
-  }
-  return Struct.get(out);
+export function map<A, B>(f: (a: A[keyof A]) => B) {
+  return (self: Struct<A>): Struct<Record<keyof A, B>> => {
+    const out  = {} as Record<keyof A, B>;
+    const keys = Object.keys(self);
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i]! as keyof A;
+      out[k]  = f(self.getStruct[k]);
+    }
+    return Struct.get(out);
+  };
 }
 
 /**

package/_src/data/Tag/constructors.ts

@@ -2,8 +2,7 @@ import { v4 } from "uuid";
 
 /**
  * @tsplus static fncts.TagOps __call
- * @fncts tag
  */
-export function makeTag<T>(id: string = v4()): Tag<T> {
+export function makeTag<T>(/** @fncts id */ id: string = v4()): Tag<T> {
   return new Tag(id);
 }

package/_src/data/Tag/definition.ts

@@ -14,7 +14,6 @@ const _tagHash = Hashable.string("fncts.Tag");
 export class Tag<in out T> implements Hashable, Equatable {
   declare _T: (_: T) => T;
   readonly _typeId: TagTypeId = TagTypeId;
-  private static counter      = new AtomicNumber(0);
 
   constructor(readonly id: string) {}