@fncts/base 0.0.21 → 0.0.23

package/_src/{typeclass → data}/Hashable/hash.ts

@@ -1,27 +1,32 @@
-import { isHashable } from "@fncts/base/typeclass/Hashable/definition";
+import { isHashable } from "@fncts/base/data/Hashable/definition";
 import { PCGRandom } from "@fncts/base/util/PCGRandom";
 import { isArray, isDefined, isIterable, isPlain } from "@fncts/base/util/predicates";
+
 const CACHE  = new WeakMap<any, number>();
 const RANDOM = new PCGRandom((Math.random() * 4294967296) >>> 0);
 let _current = 0;
+
 /**
  * @tsplus static fncts.HashableOps string
  */
 export function hashString(str: string) {
   return optimize(_hashString(str));
 }
+
 function _hashString(str: string) {
   let h = 5381;
   let i = str.length;
   while (i) h = (h * 33) ^ str.charCodeAt(--i);
   return h;
 }
+
 /**
  * @tsplus static fncts.HashableOps number
  */
 export function hashNumber(n: number): number {
   return optimize(_hashNumber(n));
 }
+
 function _hashNumber(n: number): number {
   if (n !== n || n === Infinity) return 0;
   let h = n | 0;
@@ -30,12 +35,14 @@ function _hashNumber(n: number): number {
   while (n > 0xffffffff) h ^= n /= 0xffffffff;
   return n;
 }
+
 /**
  * @tsplus static fncts.HashableOps object
  */
 export function hashObject(value: object): number {
   return optimize(_hashObject(value));
 }
+
 function _hashObject(value: object): number {
   let h = CACHE.get(value);
   if (isDefined(h)) return h;
@@ -53,12 +60,14 @@ function _hashObject(value: object): number {
   CACHE.set(value, h);
   return h;
 }
+
 /**
  * @tsplus static fncts.HashableOps plainObject
  */
 export function hashPlainObject(o: any) {
   return optimize(_hashPlainObject(o));
 }
+
 function _hashPlainObject(o: any): number {
   CACHE.set(o, randomInt());
   const keys = Object.keys(o);
@@ -70,12 +79,14 @@ function _hashPlainObject(o: any): number {
   }
   return h;
 }
+
 /**
  * @tsplus static fncts.HashableOps miscRef
  */
 export function hashMiscRef(o: any) {
   return optimize(_hashMiscRef(o));
 }
+
 function _hashMiscRef(o: any): number {
   let h = CACHE.get(o);
   if (isDefined(h)) return h;
@@ -83,12 +94,14 @@ function _hashMiscRef(o: any): number {
   CACHE.set(o, h);
   return h;
 }
+
 /**
  * @tsplus static fncts.HashableOps array
  */
 export function hashArray(arr: Array<any> | ReadonlyArray<any>): number {
   return optimize(_hashArray(arr));
 }
+
 function _hashArray(arr: Array<any> | ReadonlyArray<any>): number {
   let h = 6151;
   for (let i = 0; i < arr.length; i++) {
@@ -96,12 +109,14 @@ function _hashArray(arr: Array<any> | ReadonlyArray<any>): number {
   }
   return h;
 }
+
 /**
  * @tsplus static fncts.HashableOps iterator
  */
 export function hashIterator(it: Iterator<any>): number {
   return optimize(_hashIterator(it));
 }
+
 function _hashIterator(it: Iterator<any>): number {
   let res: IteratorResult<any>;
   let h = 6151;
@@ -110,15 +125,18 @@ function _hashIterator(it: Iterator<any>): number {
   }
   return h;
 }
+
 /**
  * @tsplus static fncts.HashableOps unknown
  */
 export function hashUnknown(value: unknown): number {
   return optimize(_hash(value));
 }
+
 function isZero(value: unknown): boolean {
   return value === null || value === void 0 || value === false;
 }
+
 function _hash(arg: any): number {
   let x = arg;
   if (isZero(x)) return 0;
@@ -146,22 +164,27 @@ function _hash(arg: any): number {
     }
   }
 }
+
 /**
  * @tsplus static fncts.HashableOps combine
  */
 export function combineHash(x: number, y: number): number {
   return optimize(_combineHash(x, y));
 }
+
 function _combineHash(x: number, y: number): number {
   return (x * 53) ^ y;
 }
+
 /**
  * @tsplus static fncts.HashableOps symbol
  */
 export function hashUniqueSymbol(sym: symbol): number {
   return optimize(_hashUniqueSymbol(sym));
 }
+
 const SYMBOL_CACHE = new Map<symbol, number>();
+
 function _hashUniqueSymbol(sym: symbol): number {
   let h = SYMBOL_CACHE.get(sym);
   if (isDefined(h)) {
@@ -171,12 +194,14 @@ function _hashUniqueSymbol(sym: symbol): number {
   SYMBOL_CACHE.set(sym, h);
   return h;
 }
+
 /**
  * @tsplus static fncts.HashableOps optimize
  */
 export function optimize(n: number): number {
   return (n & 0xbfffffff) | ((n >>> 1) & 0x40000000);
 }
+
 function randomInt(): number {
   return RANDOM.integer(0x7fffffff);
 }

package/_src/data/Interval.ts

@@ -96,8 +96,8 @@ export function isNonEmpty(self: Interval): boolean {
 /**
  * @tsplus getter fncts.io.Schedule.Interval size
  */
-export function size(self: Interval): number {
-  return self.endMilliseconds - self.startMilliseconds;
+export function size(self: Interval): Duration {
+  return Duration.fromInterval(self.startMilliseconds, self.endMilliseconds);
 }
 
 /**

package/_src/data/Maybe/api.ts

@@ -34,14 +34,14 @@ export function flatMap<A, B>(f: (a: A) => Maybe<B>) {
 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;
+    return self._tag === MaybeTag.Just ? E.equals(elem)(self.value) : false;
   };
 }
 
 /**
- * @tsplus pipeable fncts.Maybe exists
+ * @tsplus pipeable fncts.Maybe some
  */
-export function exists<A>(p: Predicate<A>) {
+export function some<A>(p: Predicate<A>) {
   return (self: Maybe<A>): boolean => {
     self.concrete();
     return self._tag === MaybeTag.Just ? p(self.value) : false;

package/_src/data/Maybe/definition.ts

@@ -5,8 +5,11 @@ export const enum MaybeTag {
   Nothing = "Nothing",
 }
 
+export const MaybeVariance = Symbol.for("fncts.Maybe.Variance");
+export type MaybeVariance = typeof MaybeVariance;
+
 export const MaybeTypeId = Symbol.for("fncts.Maybe");
-export type MaybeTypdId = typeof MaybeTypeId;
+export type MaybeTypeId = typeof MaybeTypeId;
 
 export interface MaybeF extends HKT {
   type: Maybe<this["A"]>;
@@ -22,9 +25,11 @@ const _nothingHash = Hashable.string("fncts.Nothing");
  * @tsplus type fncts.Maybe
  * @tsplus companion fncts.MaybeOps
  */
-export class Maybe<A> {
-  declare _A: () => A;
-  readonly _typeId: MaybeTypdId = MaybeTypeId;
+export abstract class Maybe<A> {
+  declare [MaybeVariance]: {
+    readonly _A: (_: never) => A;
+  };
+  readonly [MaybeTypeId]: MaybeTypeId = MaybeTypeId;
 }
 
 /**
@@ -63,15 +68,7 @@ export class Nothing extends Maybe<never> {
  */
 export function unifyMaybe<X extends Maybe<any>>(
   self: X,
-): Maybe<
-  [X] extends [
-    {
-      _A: () => infer A;
-    },
-  ]
-    ? A
-    : never
-> {
+): Maybe<[X] extends [{ [MaybeVariance]: { _A: (_: never) => infer A } }] ? A : never> {
   return self;
 }
 
@@ -79,11 +76,7 @@ export function unifyMaybe<X extends Maybe<any>>(
  * @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")))
-  );
+  return isObject(u) && MaybeTypeId in u;
 }
 
 /**

package/_src/data/Maybe/instances.ts

@@ -67,3 +67,24 @@ export function deriveDecoder<A extends Maybe<any>>(
     label,
   );
 }
+
+/**
+ * @tsplus derive fncts.Encoder[fncts.Maybe]<_> 10
+ */
+export function deriveEncoder<A extends Maybe<any>>(
+  ...[value]: [A] extends [Maybe<infer A>] ? [value: Encoder<A>] : never
+): Encoder<A> {
+  return Encoder((input) => {
+    Maybe.concrete(input);
+    if (input.isJust()) {
+      return {
+        _tag: "Just",
+        value: value.encode(input.value),
+      };
+    } else {
+      return {
+        _tag: "Nothing",
+      };
+    }
+  });
+}

package/_src/data/Ord/api/contramap.ts

@@ -0,0 +1,11 @@
+/**
+ * @tsplus pipeable fncts.Ord contramap
+ */
+export function contramap<A, B>(f: (b: B) => A) {
+  return (self: Ord<A>): Ord<B> => {
+    return {
+      compare: (y) => (x) => self.compare(f(y))(f(x)),
+      equals: (y) => (x) => self.equals(f(y))(f(x)),
+    };
+  };
+}

package/_src/data/Ord/api/max.ts

@@ -0,0 +1,7 @@
+/**
+ * @tsplus static fncts.OrdOps max
+ * @tsplus getter fncts.Ord max
+ */
+export function max<A>(O: Ord<A>): (y: A) => (x: A) => A {
+  return (y) => (x) => x === y || O.compare(y)(x) > -1 ? x : y;
+}

package/_src/data/Ord/api/min.ts

@@ -0,0 +1,7 @@
+/**
+ * @tsplus static fncts.OrdOps min
+ * @tsplus getter fncts.Ord min
+ */
+export function min<A>(O: Ord<A>): (y: A) => (x: A) => A {
+  return (y) => (x) => x === y || O.compare(y)(x) < 1 ? x : y;
+}

package/_src/{typeclass → data}/Ord/definition.ts

@@ -1,21 +1,21 @@
-import type { Ordering } from "@fncts/base/typeclass/Ordering";
-
-import { Eq } from "@fncts/base/typeclass/Eq";
 /**
  * @tsplus type fncts.Ord
  */
 export interface Ord<A> extends Eq<A> {
-  readonly compare: (x: A, y: A) => Ordering;
+  readonly compare: (y: A) => (x: A) => Ordering;
 }
+
 /**
  * @tsplus type fncts.OrdOps
  */
 export interface OrdOps {}
+
 export const Ord: OrdOps = {};
+
 /**
  * @tsplus static fncts.OrdOps __call
  */
-export function mkOrd<A>(O: Ord<A>): Ord<A> {
+export function makeOrd<A>(O: Ord<A>): Ord<A> {
   return {
     ...Eq(O),
     compare: O.compare,

package/_src/{typeclass → data}/Ord/instances.ts

@@ -1,28 +1,28 @@
 import { Monoid } from "@fncts/base/typeclass/Monoid";
-import { Ord } from "@fncts/base/typeclass/Ord/definition";
-import { Ordering } from "@fncts/base/typeclass/Ordering";
 import { Semigroup } from "@fncts/base/typeclass/Semigroup";
+
 /**
  * @tsplus static fncts.OrdOps getSemigroup
  */
 export function getSemigroup<A = never>(): Semigroup<Ord<A>> {
   return Semigroup({
-    combine: (x, y) =>
+    combine: (y) => (x) =>
       Ord({
-        compare: (a1, a2) => {
-          const ox = x.compare(a1, a2);
-          return ox !== 0 ? ox : y.compare(a1, a2);
+        compare: (a2) => (a1) => {
+          const ox = x.compare(a2)(a1);
+          return ox !== 0 ? ox : y.compare(a2)(a1);
         },
-        equals: (a1, a2) => x.equals(a1, a2) && y.equals(a1, a2),
+        equals: (a2) => (a1) => x.equals(a2)(a1) && y.equals(a2)(a1),
       }),
   });
 }
+
 /**
  * @tsplus static fncts.OrdOps getMonoid
  */
 export function getMonoid<A = never>(): Monoid<Ord<A>> {
   return Monoid({
     ...Ord.getSemigroup<A>(),
-    nat: Ord({ compare: () => Ordering.EQ, equals: () => true }),
+    nat: Ord({ compare: () => () => Ordering.EQ, equals: () => () => true }),
   });
 }

package/_src/{typeclass → data}/Showable/definition.ts

@@ -1,17 +1,23 @@
-import type { ShowComputationExternal } from "@fncts/base/typeclass/Showable/show";
-export const showable = Symbol("fncts.Showable");
+import type { ShowComputationExternal } from "@fncts/base/data/Showable/show";
+
+export const showableSymbol = Symbol("fncts.Showable");
+
 /**
  * @tsplus static fncts.builtin.SymbolOps showable
  */
-export const _showable: typeof showable = showable;
+export const _showable: typeof showableSymbol = showableSymbol;
+
 export interface Showable {
-  [showable]: ShowComputationExternal;
+  [showableSymbol]: ShowComputationExternal;
 }
+
 export function isShowable(value: unknown): value is Showable {
   return isObject(value) && Symbol.showable in value;
 }
+
 /**
  * @tsplus type ShowableOps
  */
 export interface ShowableOps {}
+
 export const Showable: ShowableOps = {};