effect-app 2.50.2 → 2.51.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @effect-app/prelude
 
+## 2.51.0
+
+### Minor Changes
+
+- 54dd59a: cleanup NES
+
 ## 2.50.2
 
 ### Patch Changes

package/dist/NonEmptySet.d.ts

@@ -1,3 +1,35 @@
-export * from "./NonEmptySetBase.js";
-export * as $ from "./NonEmptySetAspects.js";
+import { type Equivalence, Option, type Order } from "effect";
+import { type Set } from "./Set.js";
+export interface NonEmptyBrand {
+    readonly NonEmpty: unique symbol;
+}
+export type NonEmptySet<A> = Set<A> & NonEmptyBrand;
+declare class Wrapper<A> {
+    wrapped(ord: Order.Order<A>, eq?: Equivalence.Equivalence<A>): {
+        insert: (a: A) => (set: NonEmptySet<A>) => NonEmptySet<A>;
+        insert_: (set: NonEmptySet<A>, a: A) => NonEmptySet<A>;
+        remove: (a: A) => (set: Set<A>) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
+        remove_: (set: Set<A>, a: A) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
+        reduce: <B>(b: B, f: (b: B, a: A) => B) => (fa: Set<A>) => B;
+        reduce_: <B>(fa: Set<A>, b: B, f: (b: B, a: A) => B) => B;
+        replace: (a: A) => (set: NonEmptySet<A>) => NonEmptySet<A>;
+        replace_: (set: NonEmptySet<A>, a: A) => NonEmptySet<A>;
+        toArray: (s: NonEmptySet<A>) => readonly [A, ...A[]];
+        fromArray: (as: readonly A[]) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
+        fromNonEmptyArray: (arr: readonly [A, ...A[]]) => NonEmptySet<A>;
+        from: (it: Iterable<A>) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
+        of: (a: A) => NonEmptySet<A>;
+        concat_: (set: NonEmptySet<A>, it: Iterable<A>) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
+        concat: (it: Iterable<A>) => (set: NonEmptySet<A>) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
+        map: <A_1>(f: (x: A_1) => A_1) => (set: NonEmptySet<A_1>) => NonEmptySet<A_1>;
+        map_: <A_1>(set: NonEmptySet<A_1>, f: (x: A_1) => A_1) => NonEmptySet<A_1>;
+        filterMap: (f: (a: A) => Option.Option<A>) => (fa: Set<A>) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
+        filterMap_: <A_1>(fa: Set<A_1>, f: (a: A_1) => Option.Option<A>) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
+    };
+}
+export interface NonEmptySetSchemaExtensions<A> extends ReturnType<Wrapper<A>["wrapped"]> {
+}
+export declare const make: <A>(ord: Order.Order<A>, eq?: Equivalence.Equivalence<A>) => NonEmptySetSchemaExtensions<A>;
+export declare function fromSet<A>(set: Set<A>): Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
+export * from "./Set.js";
 //# sourceMappingURL=NonEmptySet.d.ts.map

package/dist/NonEmptySet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NonEmptySet.d.ts","sourceRoot":"","sources":["../src/NonEmptySet.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AAEpC,OAAO,KAAK,CAAC,MAAM,yBAAyB,CAAA"}
+{"version":3,"file":"NonEmptySet.d.ts","sourceRoot":"","sources":["../src/NonEmptySet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,EAAE,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAA;AAG7D,OAAO,EAAqK,KAAK,GAAG,EAA8B,MAAM,UAAU,CAAA;AAElO,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,OAAO,MAAM,CAAA;CACjC;AAED,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,aAAa,CAAA;AA0DnD,cAAM,OAAO,CAAC,CAAC;IACb,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC;;;;;;;4BAzBtC,mBAAmB;;;;;;;;sCAQT,mBAAmB;;;;;;CAoBpD;AAED,MAAM,WAAW,2BAA2B,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;CAAG;AAE5F,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,EACnB,GAAG,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EACnB,EAAE,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,KAC5B,2BAA2B,CAAC,CAAC,CAAS,CAAA;AAE3C,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,6DAMrC;AAGD,cAAc,UAAU,CAAA"}

package/dist/NonEmptySet.js

@@ -1,3 +1,63 @@
-export * from "./NonEmptySetBase.js";
-export * as $ from "./NonEmptySetAspects.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTm9uRW1wdHlTZXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvTm9uRW1wdHlTZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQTtBQUVwQyxPQUFPLEtBQUssQ0FBQyxNQUFNLHlCQUF5QixDQUFBIn0=
+import { Option } from "effect";
+import { flow, pipe } from "./Function.js";
+import { filter_, filterMap, filterMap_, fromArray as fromArrayOriginal, insert as insertOriginal, insert_ as insert_Original, map, map_, reduce, reduce_, remove, remove_, toArray as toArrayOriginal } from "./Set.js";
+function make_(ord, eq_) {
+    const eq = eq_
+        ?? ((x, y) => ord(x, y) === 0);
+    const fromArray_ = fromArrayOriginal(eq);
+    const fromArray = flow(fromArray_, fromSet);
+    const fromNonEmptyArray = (arr) => fromArray_(arr);
+    const concat_ = (set, it) => fromArray([...set, ...it]);
+    const insert__ = insertOriginal(eq);
+    const insert = insert__;
+    const insert_ = insert_Original;
+    function replace_(set, a) {
+        return pipe(filter_(set, (x) => !eq(x, a)), insert__(a));
+    }
+    const toArray__ = toArrayOriginal(ord);
+    function toArray(s) {
+        return toArray__(s);
+    }
+    const remove__ = remove(eq);
+    const filterMap__ = filterMap(eq);
+    return {
+        insert,
+        insert_,
+        remove: (a) => flow(remove__(a), fromSet),
+        remove_: flow(remove_(eq), fromSet),
+        reduce: reduce(ord),
+        reduce_: reduce_(ord),
+        replace: (a) => (set) => replace_(set, a),
+        replace_,
+        toArray,
+        fromArray,
+        fromNonEmptyArray,
+        from: (it) => fromArray([...it]),
+        of: (a) => new Set([a]),
+        concat_,
+        concat: (it) => (set) => concat_(set, it),
+        // A and B the same, useful when editing elements.
+        map: map(eq),
+        map_: map_(eq),
+        filterMap: (f) => flow(filterMap__((a) => f(a)), fromSet),
+        filterMap_: flow(filterMap_(eq), fromSet)
+    };
+    // TODO: extend
+}
+class Wrapper {
+    wrapped(ord, eq) {
+        return make_(ord, eq);
+    }
+}
+export const make = make_;
+export function fromSet(set) {
+    if (set.size > 0) {
+        return Option.some(set);
+    }
+    else {
+        return Option.none();
+    }
+}
+// TODO
+export * from "./Set.js";
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "effect-app",
-  "version": "2.50.2",
+  "version": "2.51.0",
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "@effect/rpc": "^0.68.1",
+    "@effect/rpc": "^0.68.2",
     "@effect/rpc-http": "^0.52.4",
     "@tsconfig/strictest": "^2.0.5",
     "date-fns": "^4.1.0",
@@ -27,7 +27,7 @@
   },
   "peerDependencies": {
     "@effect/platform": "^0.90.0",
-    "effect": "^3.17.4"
+    "effect": "^3.17.5"
   },
   "typesVersions": {
     "*": {
@@ -73,14 +73,6 @@
       "types": "./dist/NonEmptySet.d.ts",
       "default": "./dist/NonEmptySet.js"
     },
-    "./NonEmptySetAspects": {
-      "types": "./dist/NonEmptySetAspects.d.ts",
-      "default": "./dist/NonEmptySetAspects.js"
-    },
-    "./NonEmptySetBase": {
-      "types": "./dist/NonEmptySetBase.d.ts",
-      "default": "./dist/NonEmptySetBase.js"
-    },
     "./Operations": {
       "types": "./dist/Operations.d.ts",
       "default": "./dist/Operations.js"

package/src/NonEmptySet.ts

@@ -1,3 +1,90 @@
-export * from "./NonEmptySetBase.js"
+import { type Equivalence, Option, type Order } from "effect"
+import type { NonEmptyReadonlyArray } from "effect/Array"
+import { flow, pipe } from "./Function.js"
+import { filter_, filterMap, filterMap_, fromArray as fromArrayOriginal, insert as insertOriginal, insert_ as insert_Original, map, map_, reduce, reduce_, remove, remove_, type Set, toArray as toArrayOriginal } from "./Set.js"
 
-export * as $ from "./NonEmptySetAspects.js"
+export interface NonEmptyBrand {
+  readonly NonEmpty: unique symbol
+}
+
+export type NonEmptySet<A> = Set<A> & NonEmptyBrand
+
+function make_<A>(ord: Order.Order<A>, eq_?: Equivalence.Equivalence<A>) {
+  const eq = eq_
+    ?? ((x, y) => ord(x, y) === 0)
+
+  const fromArray_ = fromArrayOriginal(eq)
+  const fromArray = flow(fromArray_, fromSet)
+  const fromNonEmptyArray = (arr: NonEmptyReadonlyArray<A>) => fromArray_(arr) as NonEmptySet<A>
+  const concat_ = (set: NonEmptySet<A>, it: Iterable<A>) => fromArray([...set, ...it])
+  const insert__ = insertOriginal(eq)
+  const insert: (a: A) => (set: NonEmptySet<A>) => NonEmptySet<A> = insert__ as any
+  const insert_: (set: NonEmptySet<A>, a: A) => NonEmptySet<A> = insert_Original as any
+
+  function replace_(set: NonEmptySet<A>, a: A) {
+    return (pipe(filter_(set, (x) => !eq(x, a)), insert__(a)) as NonEmptySet<A>)
+  }
+
+  const toArray__ = toArrayOriginal(ord)
+
+  function toArray(s: NonEmptySet<A>) {
+    return toArray__(s) as NonEmptyReadonlyArray<A>
+  }
+
+  const remove__ = remove(eq)
+  const filterMap__ = filterMap(eq)
+
+  return {
+    insert,
+    insert_,
+    remove: (a: A) => flow(remove__(a), fromSet),
+    remove_: flow(remove_(eq), fromSet),
+    reduce: reduce(ord),
+    reduce_: reduce_(ord),
+    replace: (a: A) => (set: NonEmptySet<A>) => replace_(set, a),
+    replace_,
+    toArray,
+    fromArray,
+    fromNonEmptyArray,
+    from: (it: Iterable<A>) => fromArray([...it]),
+    of: (a: A) => new Set<A>([a]) as unknown as NonEmptySet<A>,
+    concat_,
+    concat: (it: Iterable<A>) => (set: NonEmptySet<A>) => concat_(set, it),
+
+    // A and B the same, useful when editing elements.
+    map: map(eq) as unknown as <A>(
+      f: (x: A) => A
+    ) => (set: NonEmptySet<A>) => NonEmptySet<A>,
+    map_: map_(eq) as unknown as <A>(
+      set: NonEmptySet<A>,
+      f: (x: A) => A
+    ) => NonEmptySet<A>,
+    filterMap: (f: (a: A) => Option.Option<A>) => flow(filterMap__<A>((a) => f(a)), fromSet),
+    filterMap_: flow(filterMap_(eq), fromSet)
+  }
+  // TODO: extend
+}
+
+class Wrapper<A> {
+  wrapped(ord: Order.Order<A>, eq?: Equivalence.Equivalence<A>) {
+    return make_(ord, eq)
+  }
+}
+
+export interface NonEmptySetSchemaExtensions<A> extends ReturnType<Wrapper<A>["wrapped"]> {}
+
+export const make: <A>(
+  ord: Order.Order<A>,
+  eq?: Equivalence.Equivalence<A>
+) => NonEmptySetSchemaExtensions<A> = make_
+
+export function fromSet<A>(set: Set<A>) {
+  if (set.size > 0) {
+    return Option.some(set as NonEmptySet<A>)
+  } else {
+    return Option.none()
+  }
+}
+
+// TODO
+export * from "./Set.js"

package/dist/NonEmptySetAspects.d.ts

@@ -1,2 +0,0 @@
-export * from "./NonEmptySetBase.js";
-//# sourceMappingURL=NonEmptySetAspects.d.ts.map

package/dist/NonEmptySetAspects.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NonEmptySetAspects.d.ts","sourceRoot":"","sources":["../src/NonEmptySetAspects.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA"}

package/dist/NonEmptySetAspects.js

@@ -1,2 +0,0 @@
-export * from "./NonEmptySetBase.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTm9uRW1wdHlTZXRBc3BlY3RzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL05vbkVtcHR5U2V0QXNwZWN0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFBIn0=

package/dist/NonEmptySetBase.d.ts

@@ -1,35 +0,0 @@
-import { type Equivalence, Option, type Order } from "effect";
-import { type Set } from "./Set.js";
-export interface NonEmptyBrand {
-    readonly NonEmpty: unique symbol;
-}
-export type NonEmptySet<A> = Set<A> & NonEmptyBrand;
-declare class Wrapper<A> {
-    wrapped(ord: Order.Order<A>, eq?: Equivalence.Equivalence<A>): {
-        insert: (a: A) => (set: NonEmptySet<A>) => NonEmptySet<A>;
-        insert_: (set: NonEmptySet<A>, a: A) => NonEmptySet<A>;
-        remove: (a: A) => (set: Set<A>) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
-        remove_: (set: Set<A>, a: A) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
-        reduce: <B>(b: B, f: (b: B, a: A) => B) => (fa: Set<A>) => B;
-        reduce_: <B>(fa: Set<A>, b: B, f: (b: B, a: A) => B) => B;
-        replace: (a: A) => (set: NonEmptySet<A>) => NonEmptySet<A>;
-        replace_: (set: NonEmptySet<A>, a: A) => NonEmptySet<A>;
-        toArray: (s: NonEmptySet<A>) => readonly [A, ...A[]];
-        fromArray: (as: readonly A[]) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
-        fromNonEmptyArray: (arr: readonly [A, ...A[]]) => NonEmptySet<A>;
-        from: (it: Iterable<A>) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
-        of: (a: A) => NonEmptySet<A>;
-        concat_: (set: NonEmptySet<A>, it: Iterable<A>) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
-        concat: (it: Iterable<A>) => (set: NonEmptySet<A>) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
-        map: <A_1>(f: (x: A_1) => A_1) => (set: NonEmptySet<A_1>) => NonEmptySet<A_1>;
-        map_: <A_1>(set: NonEmptySet<A_1>, f: (x: A_1) => A_1) => NonEmptySet<A_1>;
-        filterMap: (f: (a: A) => Option.Option<A>) => (fa: Set<A>) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
-        filterMap_: <A_1>(fa: Set<A_1>, f: (a: A_1) => Option.Option<A>) => Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
-    };
-}
-export interface NonEmptySetSchemaExtensions<A> extends ReturnType<Wrapper<A>["wrapped"]> {
-}
-export declare const make: <A>(ord: Order.Order<A>, eq?: Equivalence.Equivalence<A>) => NonEmptySetSchemaExtensions<A>;
-export declare function fromSet<A>(set: Set<A>): Option.None<NonEmptySet<A>> | Option.Some<NonEmptySet<A>>;
-export * from "./Set.js";
-//# sourceMappingURL=NonEmptySetBase.d.ts.map

package/dist/NonEmptySetBase.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NonEmptySetBase.d.ts","sourceRoot":"","sources":["../src/NonEmptySetBase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,EAAE,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAA;AAG7D,OAAO,EAAqK,KAAK,GAAG,EAA8B,MAAM,UAAU,CAAA;AAElO,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,OAAO,MAAM,CAAA;CACjC;AAED,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,aAAa,CAAA;AA0DnD,cAAM,OAAO,CAAC,CAAC;IACb,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC;;;;;;;4BAzBtC,mBAAmB;;;;;;;;sCAQT,mBAAmB;;;;;;CAoBpD;AAED,MAAM,WAAW,2BAA2B,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;CAAG;AAE5F,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,EACnB,GAAG,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EACnB,EAAE,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,KAC5B,2BAA2B,CAAC,CAAC,CAAS,CAAA;AAE3C,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,6DAMrC;AAGD,cAAc,UAAU,CAAA"}

package/dist/NonEmptySetBase.js

@@ -1,63 +0,0 @@
-import { Option } from "effect";
-import { flow, pipe } from "./Function.js";
-import { filter_, filterMap, filterMap_, fromArray as fromArrayOriginal, insert as insertOriginal, insert_ as insert_Original, map, map_, reduce, reduce_, remove, remove_, toArray as toArrayOriginal } from "./Set.js";
-function make_(ord, eq_) {
-    const eq = eq_
-        ?? ((x, y) => ord(x, y) === 0);
-    const fromArray_ = fromArrayOriginal(eq);
-    const fromArray = flow(fromArray_, fromSet);
-    const fromNonEmptyArray = (arr) => fromArray_(arr);
-    const concat_ = (set, it) => fromArray([...set, ...it]);
-    const insert__ = insertOriginal(eq);
-    const insert = insert__;
-    const insert_ = insert_Original;
-    function replace_(set, a) {
-        return pipe(filter_(set, (x) => !eq(x, a)), insert__(a));
-    }
-    const toArray__ = toArrayOriginal(ord);
-    function toArray(s) {
-        return toArray__(s);
-    }
-    const remove__ = remove(eq);
-    const filterMap__ = filterMap(eq);
-    return {
-        insert,
-        insert_,
-        remove: (a) => flow(remove__(a), fromSet),
-        remove_: flow(remove_(eq), fromSet),
-        reduce: reduce(ord),
-        reduce_: reduce_(ord),
-        replace: (a) => (set) => replace_(set, a),
-        replace_,
-        toArray,
-        fromArray,
-        fromNonEmptyArray,
-        from: (it) => fromArray([...it]),
-        of: (a) => new Set([a]),
-        concat_,
-        concat: (it) => (set) => concat_(set, it),
-        // A and B the same, useful when editing elements.
-        map: map(eq),
-        map_: map_(eq),
-        filterMap: (f) => flow(filterMap__((a) => f(a)), fromSet),
-        filterMap_: flow(filterMap_(eq), fromSet)
-    };
-    // TODO: extend
-}
-class Wrapper {
-    wrapped(ord, eq) {
-        return make_(ord, eq);
-    }
-}
-export const make = make_;
-export function fromSet(set) {
-    if (set.size > 0) {
-        return Option.some(set);
-    }
-    else {
-        return Option.none();
-    }
-}
-// TODO
-export * from "./Set.js";
-//# sourceMappingURL=data:application/json;base64,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

package/src/NonEmptySetAspects.ts

@@ -1 +0,0 @@
-export * from "./NonEmptySetBase.js"

package/src/NonEmptySetBase.ts

@@ -1,90 +0,0 @@
-import { type Equivalence, Option, type Order } from "effect"
-import type { NonEmptyReadonlyArray } from "effect/Array"
-import { flow, pipe } from "./Function.js"
-import { filter_, filterMap, filterMap_, fromArray as fromArrayOriginal, insert as insertOriginal, insert_ as insert_Original, map, map_, reduce, reduce_, remove, remove_, type Set, toArray as toArrayOriginal } from "./Set.js"
-
-export interface NonEmptyBrand {
-  readonly NonEmpty: unique symbol
-}
-
-export type NonEmptySet<A> = Set<A> & NonEmptyBrand
-
-function make_<A>(ord: Order.Order<A>, eq_?: Equivalence.Equivalence<A>) {
-  const eq = eq_
-    ?? ((x, y) => ord(x, y) === 0)
-
-  const fromArray_ = fromArrayOriginal(eq)
-  const fromArray = flow(fromArray_, fromSet)
-  const fromNonEmptyArray = (arr: NonEmptyReadonlyArray<A>) => fromArray_(arr) as NonEmptySet<A>
-  const concat_ = (set: NonEmptySet<A>, it: Iterable<A>) => fromArray([...set, ...it])
-  const insert__ = insertOriginal(eq)
-  const insert: (a: A) => (set: NonEmptySet<A>) => NonEmptySet<A> = insert__ as any
-  const insert_: (set: NonEmptySet<A>, a: A) => NonEmptySet<A> = insert_Original as any
-
-  function replace_(set: NonEmptySet<A>, a: A) {
-    return (pipe(filter_(set, (x) => !eq(x, a)), insert__(a)) as NonEmptySet<A>)
-  }
-
-  const toArray__ = toArrayOriginal(ord)
-
-  function toArray(s: NonEmptySet<A>) {
-    return toArray__(s) as NonEmptyReadonlyArray<A>
-  }
-
-  const remove__ = remove(eq)
-  const filterMap__ = filterMap(eq)
-
-  return {
-    insert,
-    insert_,
-    remove: (a: A) => flow(remove__(a), fromSet),
-    remove_: flow(remove_(eq), fromSet),
-    reduce: reduce(ord),
-    reduce_: reduce_(ord),
-    replace: (a: A) => (set: NonEmptySet<A>) => replace_(set, a),
-    replace_,
-    toArray,
-    fromArray,
-    fromNonEmptyArray,
-    from: (it: Iterable<A>) => fromArray([...it]),
-    of: (a: A) => new Set<A>([a]) as unknown as NonEmptySet<A>,
-    concat_,
-    concat: (it: Iterable<A>) => (set: NonEmptySet<A>) => concat_(set, it),
-
-    // A and B the same, useful when editing elements.
-    map: map(eq) as unknown as <A>(
-      f: (x: A) => A
-    ) => (set: NonEmptySet<A>) => NonEmptySet<A>,
-    map_: map_(eq) as unknown as <A>(
-      set: NonEmptySet<A>,
-      f: (x: A) => A
-    ) => NonEmptySet<A>,
-    filterMap: (f: (a: A) => Option.Option<A>) => flow(filterMap__<A>((a) => f(a)), fromSet),
-    filterMap_: flow(filterMap_(eq), fromSet)
-  }
-  // TODO: extend
-}
-
-class Wrapper<A> {
-  wrapped(ord: Order.Order<A>, eq?: Equivalence.Equivalence<A>) {
-    return make_(ord, eq)
-  }
-}
-
-export interface NonEmptySetSchemaExtensions<A> extends ReturnType<Wrapper<A>["wrapped"]> {}
-
-export const make: <A>(
-  ord: Order.Order<A>,
-  eq?: Equivalence.Equivalence<A>
-) => NonEmptySetSchemaExtensions<A> = make_
-
-export function fromSet<A>(set: Set<A>) {
-  if (set.size > 0) {
-    return Option.some(set as NonEmptySet<A>)
-  } else {
-    return Option.none()
-  }
-}
-
-// TODO
-export * from "./Set.js"