@fncts/base 0.0.1

package/_src/data/function/pipe.ts

@@ -0,0 +1,301 @@
+/**
+ * @tsplus macro pipe
+ * @tsplus fluent fncts.global via
+ */
+export function pipe<A>(a: A): A;
+export function pipe<A, B>(a: A, ab: (a: A) => B): B;
+export function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
+export function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
+export function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
+export function pipe<A, B, C, D, E, F>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+): F;
+export function pipe<A, B, C, D, E, F, G>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+): G;
+export function pipe<A, B, C, D, E, F, G, H>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+): H;
+export function pipe<A, B, C, D, E, F, G, H, I>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+): I;
+export function pipe<A, B, C, D, E, F, G, H, I, J>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+): J;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+): K;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+): L;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+): M;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+): N;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+  no: (n: N) => O,
+): O;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+  no: (n: N) => O,
+  op: (o: O) => P,
+): P;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+  no: (n: N) => O,
+  op: (o: O) => P,
+  pq: (p: P) => Q,
+): Q;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+  no: (n: N) => O,
+  op: (o: O) => P,
+  pq: (p: P) => Q,
+  qr: (q: Q) => R,
+): R;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+  no: (n: N) => O,
+  op: (o: O) => P,
+  pq: (p: P) => Q,
+  qr: (q: Q) => R,
+  rs: (r: R) => S,
+): S;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+  no: (n: N) => O,
+  op: (o: O) => P,
+  pq: (p: P) => Q,
+  qr: (q: Q) => R,
+  rs: (r: R) => S,
+  st: (s: S) => T,
+): T;
+export function pipe(
+  a: unknown,
+  ab?: Function,
+  bc?: Function,
+  cd?: Function,
+  de?: Function,
+  ef?: Function,
+  fg?: Function,
+  gh?: Function,
+  hi?: Function,
+  ij?: Function,
+  jk?: Function,
+  kl?: Function,
+  lm?: Function,
+  mn?: Function,
+  no?: Function,
+  op?: Function,
+  pq?: Function,
+  qr?: Function,
+  rs?: Function,
+  st?: Function,
+): unknown {
+  switch (arguments.length) {
+    case 1:
+      return a;
+    case 2:
+      return ab!(a);
+    case 3:
+      return bc!(ab!(a));
+    case 4:
+      return cd!(bc!(ab!(a)));
+    case 5:
+      return de!(cd!(bc!(ab!(a))));
+    case 6:
+      return ef!(de!(cd!(bc!(ab!(a)))));
+    case 7:
+      return fg!(ef!(de!(cd!(bc!(ab!(a))))));
+    case 8:
+      return gh!(fg!(ef!(de!(cd!(bc!(ab!(a)))))));
+    case 9:
+      return hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a))))))));
+    case 10:
+      return ij!(hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a)))))))));
+    case 11:
+      return jk!(ij!(hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a))))))))));
+    case 12:
+      return kl!(jk!(ij!(hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a)))))))))));
+    case 13:
+      return lm!(kl!(jk!(ij!(hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a))))))))))));
+    case 14:
+      return mn!(lm!(kl!(jk!(ij!(hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a)))))))))))));
+    case 15:
+      return no!(mn!(lm!(kl!(jk!(ij!(hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a))))))))))))));
+    case 16:
+      return op!(no!(mn!(lm!(kl!(jk!(ij!(hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a)))))))))))))));
+    case 17:
+      return pq!(op!(no!(mn!(lm!(kl!(jk!(ij!(hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a))))))))))))))));
+    case 18:
+      return qr!(pq!(op!(no!(mn!(lm!(kl!(jk!(ij!(hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a)))))))))))))))));
+    case 19:
+      return rs!(qr!(pq!(op!(no!(mn!(lm!(kl!(jk!(ij!(hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a))))))))))))))))));
+    case 20:
+      return st!(rs!(qr!(pq!(op!(no!(mn!(lm!(kl!(jk!(ij!(hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a)))))))))))))))))));
+    default:
+      throw new Error("BUG");
+  }
+}

package/_src/data/function.ts

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

package/_src/data/number/api.ts

@@ -0,0 +1,6 @@
+/**
+ * @tsplus static fncts.NumberOps isNumber
+ */
+export function isNumber(u: unknown): u is number {
+  return typeof u === "number";
+}

package/_src/data/number/definition.ts

@@ -0,0 +1,13 @@
+declare global {
+  /**
+   * @tsplus type fncts.Number
+   */
+  export interface Number {}
+
+  /**
+   * @tsplus type fncts.NumberOps
+   */
+  export interface NumberConstructor {}
+}
+
+export {};

package/_src/data/number/instances.ts

@@ -0,0 +1,15 @@
+import * as P from "../../typeclass.js";
+import { EQ, GT, LT } from "../../typeclass.js";
+
+/**
+ * @tsplus static fncts.NumberOps Eq
+ */
+export const Eq: P.Eq<number> = P.Eq({ equals_: (x, y) => x === y });
+
+/**
+ * @tsplus static fncts.NumberOps Ord
+ */
+export const Ord: P.Ord<number> = P.Ord({
+  compare_: (x, y) => (x < y ? LT : x > y ? GT : EQ),
+  equals_: (x, y) => x === y,
+});

package/_src/data/number.ts

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

package/_src/data/object/definition.ts

@@ -0,0 +1,12 @@
+declare global {
+  /**
+   * @tsplus type fncts.global
+   */
+  export interface Object {}
+  /**
+   * @tsplus type fncts.globalOps
+   */
+  export interface ObjectConstructor {}
+}
+
+export {};

package/_src/data/object.ts

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

package/_src/data/string/api.ts

@@ -0,0 +1,182 @@
+import { Ord } from "../../typeclass.js";
+
+/**
+ * Capitalize the first letter of the string
+ *
+ * @tsplus getter fncts.String capitalize
+ */
+export function capitalize(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+/**
+ * Capitalize the first letter of every word in a string
+ *
+ * @tsplus getter fncts.String capitalizeAll
+ */
+export function capitalizeAll(s: string): string {
+  return s.split(" ").map(capitalize).join(" ");
+}
+
+/**
+ * Check is a string is empty
+ *
+ * @tsplus getter fncts.String isEmpty
+ */
+export function isEmpty(s: string): boolean {
+  return s === "";
+}
+
+/**
+ * Check is a string is non-empty
+ *
+ * @tsplus getter fncts.String isNonEmpty
+ */
+export function isNonEmpty(s: string): boolean {
+  return s !== "";
+}
+
+/**
+ * Split a string into substrings using any recognised newline as the separator.
+ *
+ * @tsplus getter fncts.String lines
+ */
+export function lines(s: string): ReadonlyArray<string> {
+  return s.split(/\r\n|\r|\n/);
+}
+
+/**
+ * Reverse a string
+ *
+ * @tsplus getter fncts.String reverse
+ */
+export function reverse(s: string): string {
+  return s.under((cs) => cs.reverse());
+}
+
+/**
+ * Surround a string. Equivalent to calling `prepend` and `append` with the
+ * same outer value.
+ *
+ * @tsplus fluent fncts.String surround
+ */
+export function surround_(s: string, x: string): string {
+  return x + s + x;
+}
+
+/**
+ * Surround a string. Equivalent to calling `prepend` and `append` with the
+ * same outer value.
+ *
+ * @tsplus static fncts.StringOps surround
+ */
+export const surround = Pipeable(surround_);
+
+/**
+ * Keep the specified number of characters from the start of a string.
+ *
+ * If `n` is larger than the available number of characters, the string will
+ * be returned whole.
+ *
+ * If `n` is not a positive number, an empty string will be returned.
+ *
+ * If `n` is a float, it will be rounded down to the nearest integer.
+ *
+ * @tsplus fluent fncts.String take
+ */
+export function take_(s: string, n: number): string {
+  return s.slice(0, Ord.max(Number.Ord)(0, n));
+}
+
+/**
+ * @tsplus static fncts.StringOps take
+ */
+export const take = Pipeable(take_);
+
+/**
+ * Keep the specified number of characters from the end of a string.
+ *
+ * If `n` is larger than the available number of characters, the string will
+ * be returned whole.
+ *
+ * If `n` is not a positive number, an empty string will be returned.
+ *
+ * If `n` is a float, it will be rounded down to the nearest integer.
+ *
+ * @tsplus fluent fncts.String takeLast
+ */
+export function takeLast_(s: string, n: number): string {
+  return s.slice(Ord.max(Number.Ord)(0, s.length - Math.floor(n)), Infinity);
+}
+
+/**
+ * @tsplus static fncts.StringOps takeLast
+ */
+export const takeLast = Pipeable(takeLast_);
+
+/**
+ * Removes the given string from the beginning, if it exists
+ *
+ * @tsplus fluent fncts.String unprepend
+ */
+export function unprepend_(s: string, s1: string): string {
+  return s.startsWith(s1) ? s.slice(s1.length) : s;
+}
+
+/**
+ * @tsplus static fncts.StringOps unprepend
+ */
+export const unprepend = Pipeable(unprepend_);
+
+/**
+ * Remove the end of a string, if it exists.
+ *
+ * @tsplus fluent fncts.String unappend
+ */
+export function unappend_(s: string, x: string): string {
+  return s.endsWith(x) ? s.substring(0, s.lastIndexOf(x)) : s;
+}
+
+/**
+ * @tsplus static fncts.StringOps unappend
+ */
+export const unappend = Pipeable(unappend_);
+
+/**
+ * Remove the start and end of a string, if they both exist.
+ *
+ * @tsplus fluent fncts.String unsurround
+ */
+export function unsurround_(s: string, x: string): string {
+  return s.startsWith(x) && s.endsWith(x) ? s.unprepend(x).unappend(x) : s;
+}
+
+/**
+ * @tsplus static fncts.StringOps unsurround
+ */
+export const unsurround = Pipeable(unsurround_);
+
+/**
+ * Apply an endomorphism upon an array of characters against a string.
+ * This is useful as it allows you to run many polymorphic functions targeting
+ * arrays against strings without having to rewrite them.
+ *
+ * @tsplus fluent fncts.String under
+ */
+export function under_(s: string, f: (chars: Array<string>) => Array<string>): string {
+  return f(s.split("")).join("");
+}
+
+/**
+ * @tsplus static fncts.StringOps under
+ */
+export const under = Pipeable(under_);
+
+/**
+ * Join newline-separated strings together.
+ *
+ * @tsplus getter fncts.base.ImmutableArray unlines
+ */
+export function unlines(as: ReadonlyArray<string>): string {
+  return as.join("\n");
+}

package/_src/data/string/definition.ts

@@ -0,0 +1,13 @@
+declare global {
+  /**
+   * @tsplus type fncts.String
+   */
+  export interface String {}
+
+  /**
+   * @tsplus type fncts.StringOps
+   */
+  export interface StringConstructor {}
+}
+
+export {};

package/_src/data/string/instances.ts

@@ -0,0 +1,24 @@
+import * as P from "../../typeclass.js";
+
+/**
+ * @tsplus static fncts.StringOps Eq
+ */
+export const Eq: P.Eq<string> = P.Eq({ equals_: (x, y) => x === y });
+
+/**
+ * @tsplus static fncts.StringOps Semigroup
+ */
+export const Semigroup: P.Semigroup<string> = P.Semigroup({ combine_: (x, y) => x + y });
+
+/**
+ * @tsplus static fncts.StringOps Monoid
+ */
+export const Monoid: P.Monoid<string> = P.Monoid({ combine_: (x, y) => x + y, nat: "" });
+
+/**
+ * @tsplus static fncts.StringOps Ord
+ */
+export const Ord: P.Ord<string> = P.Ord({
+  compare_: (x, y) => (x < y ? -1 : x > y ? 1 : 0),
+  equals_: (x, y) => x === y,
+});

package/_src/data/string.ts

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

package/_src/global/api.ts

@@ -0,0 +1,23 @@
+/**
+ * @tsplus fluent global if
+ */
+export function matchPredicate<A, B extends A, C, D>(
+  self: A,
+  predicate: Refinement<A, B>,
+  onFalse: (a: A) => C,
+  onTrue: (a: B) => D,
+): C | D;
+export function matchPredicate<A, B, C>(
+  self: A,
+  predicate: Predicate<A>,
+  onFalse: (a: A) => B,
+  onTrue: (a: A) => C,
+): B | C;
+export function matchPredicate<A, B, C>(
+  self: A,
+  predicate: Predicate<A>,
+  onFalse: (a: A) => B,
+  onTrue: (a: A) => C,
+): B | C {
+  return predicate(self) ? onTrue(self) : onFalse(self);
+}

package/_src/internal/AtomicBoolean.ts

@@ -0,0 +1,7 @@
+import { AtomicReference } from "./AtomicReference.js";
+
+export class AtomicBoolean extends AtomicReference<boolean> {
+  constructor(b: boolean) {
+    super(b);
+  }
+}

package/_src/internal/AtomicNumber.ts

@@ -0,0 +1,28 @@
+import { AtomicReference } from "./AtomicReference.js";
+
+export class AtomicNumber extends AtomicReference<number> {
+  constructor(n: number) {
+    super(n);
+
+    this.incrementAndGet = this.incrementAndGet.bind(this);
+    this.decrementAndGet = this.decrementAndGet.bind(this);
+  }
+
+  incrementAndGet() {
+    this.set(this.get + 1);
+    return this.get;
+  }
+
+  decrementAndGet() {
+    this.set(this.get - 1);
+    return this.get;
+  }
+
+  getAndIncrement(): number {
+    const ret = this.get;
+
+    this.set(this.get + 1);
+
+    return ret;
+  }
+}

package/_src/internal/AtomicReference.ts

@@ -0,0 +1,28 @@
+export class AtomicReference<A> {
+  private current: A;
+  constructor(readonly initial: A) {
+    this.current = initial;
+  }
+
+  get get() {
+    return this.current;
+  }
+
+  set(value: A) {
+    this.current = value;
+  }
+
+  compareAndSet(old: A, value: A) {
+    if (this.get === old) {
+      this.set(value);
+      return true;
+    }
+    return false;
+  }
+
+  getAndSet(value: A) {
+    const previous = this.current;
+    this.current   = value;
+    return previous;
+  }
+}