@tempots/std 0.9.6 → 0.9.7

package/src/objects.ts

@@ -1,47 +0,0 @@
-import { type TupleToUnion } from './types/tuples'
-import { type Merge } from './types/objects'
-import { type AnyKey } from './types/utility'
-
-export function keys<T extends object> (obj: T): Array<keyof T> {
-  return Object.keys(obj) as Array<keyof T>
-}
-
-export function sameKeys<T extends object> (a: T, b: T): boolean {
-  const ak = keys(a)
-  const bk = keys(b)
-  if (ak.length !== bk.length) return false
-  for (const k of ak) {
-    if (!(k in b)) return false
-  }
-  return true
-}
-
-export function isObject (obj: unknown): obj is Record<AnyKey, unknown> {
-  return Object.prototype.toString.call(obj) === '[object Object]'
-}
-
-export function removeFields<T extends object, F extends Array<keyof T>> (
-  ob: T,
-  ...fields: F
-): Omit<T, TupleToUnion<F>> {
-  const ks = keys(ob)
-  return ks.reduce((acc: Record<AnyKey, unknown>, key) => {
-    if (!fields.includes(key)) acc[key] = ob[key]
-    return acc
-  }, {}) as Omit<T, TupleToUnion<F>>
-}
-
-export function merge<
-  A extends Record<AnyKey, unknown>,
-  B extends Record<AnyKey, unknown>
-> (a: A, b: B): Merge<A, B> {
-  return Object.assign({}, a, b) as Merge<A, B>
-}
-
-export function isEmpty (obj: object): boolean {
-  return (
-    obj != null &&
-    Object.keys(obj).length === 0 &&
-    Object.getPrototypeOf(obj) === Object.prototype
-  )
-}

package/src/ord.ts

@@ -1,79 +0,0 @@
-/*
-Copyright 2019 Google LLC
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    https://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-export enum Ordering {
-  LT = -1,
-  EQ = 0,
-  GT = 1
-}
-
-export type CompareOrd<T> = (a: T, b: T) => Ordering
-export type Compare<T> = (a: T, b: T) => number
-
-export class Ord<T> {
-  static fromNumberComparison<T>(compare: (a: T, b: T) => number): Ord<T> {
-    return new Ord<T>(fromNumberComparison(compare))
-  }
-
-  constructor (readonly compare: CompareOrd<T>) {}
-
-  max (a: T, b: T): T {
-    switch (this.compare(a, b)) {
-      case Ordering.LT:
-      case Ordering.EQ:
-        return a
-      case Ordering.GT:
-        return b
-    }
-  }
-
-  min (a: T, b: T): T {
-    switch (this.compare(a, b)) {
-      case Ordering.GT:
-      case Ordering.EQ:
-        return a
-      case Ordering.LT:
-        return b
-    }
-  }
-
-  equals (a: T, b: T): boolean {
-    switch (this.compare(a, b)) {
-      case Ordering.EQ:
-        return true
-      default:
-        return false
-    }
-  }
-
-  contramap<B>(f: (b: B) => T): Ord<B> {
-    return new Ord((b0: B, b1: B) => this.compare(f(b0), f(b1)))
-  }
-
-  inverse (): Ord<T> {
-    return new Ord((a0: T, a1: T) => this.compare(a1, a0))
-  }
-
-  numberComparison (a0: T, a1: T): number {
-    return this.compare(a0, a1)
-  }
-}
-
-export function fromNumberComparison<A> (f: (a: A, b: A) => number) {
-  return function compare (a: A, b: A) {
-    const r = f(a, b)
-    if (r < 0) return Ordering.LT
-    else if (r === 0) return Ordering.EQ
-    else return Ordering.GT
-  }
-}

package/src/result.ts

@@ -1,140 +0,0 @@
-import { type AsyncResult } from './async-result'
-
-export interface Success<V> {
-  type: 'success'
-  value: V
-}
-export interface Failure<E> {
-  type: 'failure'
-  error: E
-}
-
-export type Result<V, E> = Success<V> | Failure<E>
-
-export type PromiseResult<V, E> = PromiseLike<Result<V, E>>
-
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export const Result = {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  success<V>(value: V): Result<V, any> {
-    return { type: 'success', value }
-  },
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  failure<E>(error: E): Result<any, E> {
-    return { type: 'failure', error }
-  },
-  cmap:
-    <V1, V2, E>(f: (value: V1) => V2) =>
-    (r: Result<V1, E>): Result<V2, E> => {
-      if (r.type === 'success') {
-        return Result.success(f(r.value))
-      } else {
-        return r
-      }
-    },
-  map: <V1, V2, E>(r: Result<V1, E>, f: (value: V1) => V2): Result<V2, E> => {
-    if (r.type === 'success') {
-      return Result.success(f(r.value))
-    } else {
-      return r
-    }
-  },
-  cflatMap:
-    <V1, V2, E>(f: (value: V1) => Result<V2, E>) =>
-    (r: Result<V1, E>): Result<V2, E> => {
-      if (r.type === 'success') {
-        return f(r.value)
-      } else {
-        return r
-      }
-    },
-  flatMap: <V1, V2, E>(
-    r: Result<V1, E>,
-    f: (value: V1) => Result<V2, E>
-  ): Result<V2, E> => {
-    if (r.type === 'success') {
-      return f(r.value)
-    } else {
-      return r
-    }
-  },
-  toAsync<V, E>(r: Result<V, E>): AsyncResult<V, E> {
-    return r
-  },
-  isSuccess<V, E>(r: Result<V, E>): r is Success<V> {
-    return r.type === 'success'
-  },
-  isFailure<V, E>(r: Result<V, E>): r is Failure<E> {
-    return r.type === 'failure'
-  },
-  getOrElse<V, E>(r: Result<V, E>, alt: V): V {
-    return Result.isSuccess(r) ? r.value : alt
-  },
-  getOrElseLazy<V, E>(r: Result<V, E>, altf: () => V): V {
-    return Result.isSuccess(r) ? r.value : altf()
-  },
-  getOrNull<V, E>(r: Result<V, E>): V | null {
-    return Result.isSuccess(r) ? r.value : null
-  },
-  getOrUndefined<V, E>(r: Result<V, E>): V | undefined {
-    return Result.isSuccess(r) ? r.value : undefined
-  },
-  cmatch:
-    <V1, V2, E>(success: (value: V1) => V2, failure: (error: E) => V2) =>
-    (r: Result<V1, E>): V2 => {
-      if (Result.isSuccess(r)) {
-        return success(r.value)
-      } else {
-        return failure(r.error)
-      }
-    },
-  match: <V1, V2, E>(
-    r: Result<V1, E>,
-    success: (value: V1) => V2,
-    failure: (error: E) => V2
-  ): V2 => {
-    if (Result.isSuccess(r)) {
-      return success(r.value)
-    } else {
-      return failure(r.error)
-    }
-  },
-  whenSuccess:
-    <V, E>(apply: (v: V) => void) =>
-    (r: Result<V, E>): Result<V, E> => {
-      if (Result.isSuccess(r)) {
-        apply(r.value)
-      }
-      return r
-    },
-  whenFailure:
-    <V, E>(apply: (e: E) => void) =>
-    (r: Result<V, E>): Result<V, E> => {
-      if (Result.isFailure(r)) {
-        apply(r.error)
-      }
-      return r
-    },
-  combine: <V, E>(
-    r1: Result<V, E>,
-    r2: Result<V, E>,
-    combineV: (v1: V, v2: V) => V,
-    combineE: (e1: E, e2: E) => E
-  ): Result<V, E> =>
-    Result.match<V, Result<V, E>, E>(
-      r1,
-      (v1: V) =>
-        Result.match<V, Result<V, E>, E>(
-          r2,
-          (v2: V) => Result.success<V>(combineV(v1, v2)),
-          (e2: E) => Result.failure<E>(e2)
-        ),
-      (e1: E) =>
-        Result.match<V, Result<V, E>, E>(
-          r2,
-          // eslint-disable-next-line @typescript-eslint/no-unused-vars
-          (_: V) => Result.failure<E>(e1),
-          (e2: E) => Result.failure<E>(combineE(e1, e2))
-        )
-    )
-}