Function make_

packages/effect-app/src/NonEmptySet.ts:14–68

(ord: Order.Order<A>, eq_?: Equivalence.Equivalence<A>)

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>) {