@tempots/std 0.9.6 → 0.10.3

package/src/edit.ts

@@ -1,29 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export abstract class Edit<V, I, E> {
-  abstract readonly type: 'Input' | 'Error' | 'Value'
-}
-
-export class Input<I> extends Edit<never, I, never> {
-  override readonly type = 'Input' as const
-  constructor (readonly input: I) {
-    super()
-  }
-}
-
-export class Error<I, E> extends Edit<never, I, E> {
-  override readonly type = 'Error' as const
-  constructor (readonly input: I, readonly error: E) {
-    super()
-  }
-}
-
-export class Value<V> extends Edit<V, never, never> {
-  override readonly type = 'Value' as const
-  constructor (readonly value: V) {
-    super()
-  }
-}
-
-export type Validate<V, I, E> = (
-  input: Input<I> | Error<I, E>
-) => Error<I, E> | Value<V>

package/src/equals.ts

@@ -1,116 +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 function strictEqual<A> (a: A, b: A): boolean {
-  // eslint-disable-next-line no-self-compare
-  return a === b || (a !== a && b !== b)
-}
-
-export function deepEqual<A> (a: A, b: A): boolean {
-  if (strictEqual(a, b)) return true
-  if (a == null || b == null) return false
-  const aIsArr = Array.isArray(a)
-  const bIsArr = Array.isArray(b)
-
-  if (aIsArr !== bIsArr) return false
-  if (aIsArr) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const aArr: never[] = a as any
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const bArr: never[] = b as any
-    const aLength = aArr.length
-    if (aLength !== bArr.length) return false
-    for (let i = 0; i < aLength; i++) {
-      if (!deepEqual(aArr[i], bArr[i])) return false
-    }
-    return true
-  }
-
-  const aIsDate = a instanceof Date
-  const bIsDate = b instanceof Date
-  if (aIsDate !== bIsDate) return false
-  if (aIsDate) {
-    const aDate: Date = a as never
-    const bDate: Date = b as never
-    return +aDate === +bDate
-  }
-
-  const aIsSet = a instanceof Set
-  const bIsSet = b instanceof Set
-  if (aIsSet !== bIsSet) return false
-  if (aIsSet) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const aSet: Set<any> = a as never
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const bSet: Set<any> = b as never
-    if (aSet.size !== bSet.size) return false
-    const it = aSet.keys()
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const curr = it.next()
-      if (curr.done ?? false) break
-      if (!bSet.has(curr.value)) return false
-    }
-    return true
-  }
-
-  const aIsMap = a instanceof Map
-  const bIsMap = b instanceof Map
-  if (aIsMap !== bIsMap) return false
-  if (aIsMap) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const aMap: Map<any, any> = a as never
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const bMap: Map<any, any> = b as never
-    const aMapLength = aMap.size
-    if (aMapLength !== bMap.size) return false
-    const it = aMap.keys()
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const curr = it.next()
-      if (curr.done ?? false) break
-      if (!deepEqual(aMap.get(curr.value), bMap.get(curr.value))) return false
-    }
-    return true
-  }
-
-  const aIsObj = typeof a === 'object'
-  const bIsObj = typeof b === 'object'
-  if (aIsObj !== bIsObj) return false
-  if (aIsObj) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const aObj: any = a
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const bObj: any = b
-    const aFields = Object.keys(aObj)
-    const bFields = Object.keys(bObj)
-    const aLength = aFields.length
-
-    if (aLength !== bFields.length) return false
-
-    for (let i = 0; i < aLength; i++) {
-      const field = aFields[i]
-      if (!Object.prototype.hasOwnProperty.call(bObj, field)) return false
-      if (!deepEqual(aObj[field], bObj[field])) return false
-    }
-
-    return true
-  }
-
-  return false
-}
-
-export function looseEqual<T> (a: T, b: T): boolean {
-  // eslint-disable-next-line eqeqeq
-  return a == b
-}

package/src/functions.ts

@@ -1,108 +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.
-*/
-
-import { type Fun1, type FirstArgument } from './types/functions'
-
-export function compose<A> (): (a: A) => A
-export function compose<A, B> (f1: (a: A) => B): (a: A) => B
-export function compose<A, B, C> (f1: (a: A) => B, f2: (b: B) => C): (a: A) => C
-export function compose<A, B, C, D> (
-  f1: (a: A) => B,
-  f2: (b: B) => C,
-  f3: (c: C) => D
-): (a: A) => D
-export function compose<A, B, C, D, E> (
-  f1: (a: A) => B,
-  f2: (b: B) => C,
-  f3: (c: C) => D,
-  f4: (d: D) => E
-): (a: A) => E
-export function compose<A, B, C, D, E, F> (
-  f1: (a: A) => B,
-  f2: (b: B) => C,
-  f3: (c: C) => D,
-  f4: (d: D) => E,
-  f5: (e: E) => F
-): (a: A) => F
-export function compose<A, B, C, D, E, F, G> (
-  f1: (a: A) => B,
-  f2: (b: B) => C,
-  f3: (c: C) => D,
-  f4: (d: D) => E,
-  f5: (e: E) => F,
-  f6: (f: F) => G
-): (a: A) => G
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function compose<Args extends Array<Fun1<any, any>>> (...args: Args) {
-  return (a: FirstArgument<Args[0]>) => args.reduce((acc, f) => f(acc), a)
-}
-
-export function identity<T> (v: T): T {
-  return v
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function curryLeft<A, Rest extends any[], Ret> (
-  f: (a: A, ...rest: Rest) => Ret
-) {
-  return (a: A) =>
-    (...rest: Rest): Ret =>
-      f(a, ...rest)
-}
-
-export function curryRight<A, B, C, D> (
-  f: (a: A, b: B, c: C) => D
-): (a: A, b: B) => (c: C) => D
-export function curryRight<A, B, C, D, E> (
-  f: (a: A, b: B, c: C, d: D) => E
-): (a: A, b: B, c: C) => (d: D) => E
-export function curryRight<A, B, C, D, E, F> (
-  f: (a: A, b: B, c: C, d: D, e: E) => F
-): (a: A, b: B, c: C, d: D) => (e: E) => F
-export function curryRight<A, B, C, D, E, F, G> (
-  f: (a: A, b: B, c: C, d: D, e: E, f: F) => G
-): (a: A, b: B, c: C, d: D, e: E) => (f: F) => G
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function curryRight<Ret> (f: (...rest: any[]) => Ret) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return (...args: any[]) =>
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (a: any): Ret =>
-      f(...args.concat([a]))
-}
-
-export function flip<A, B, C> (f: (a: A, b: B) => C): (b: B, a: A) => C
-export function flip<A, B, C, D> (
-  f: (a: A, b: B, c: C) => D
-): (c: C, b: B, a: A) => D
-export function flip<A, B, C, D, E> (
-  f: (a: A, b: B, c: C, d: D) => E
-): (d: D, c: C, b: B, a: A) => E
-export function flip<A, B, C, D, E> (
-  f: (a: A, b: B, c: C, d: D) => E
-): (d: D, c: C, b: B, a: A) => E
-export function flip<A, B, C, D, E, F> (
-  f: (a: A, b: B, c: C, d: D, e: E) => F
-): (e: E, d: D, c: C, b: B, a: A) => F
-export function flip<A, B, C, D, E, F, G> (
-  f: (a: A, b: B, c: C, d: D, e: E, f: F) => G
-): (f: F, e: E, d: D, c: C, b: B, a: A) => G
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function flip<Ret> (f: (...rest: any[]) => Ret) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return (...args: any[]) => f(...args.reverse())
-}
-
-export function id<T> (v: T): T {
-  return v
-}

package/src/json.ts

@@ -1,52 +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.
-*/
-
-import { Result } from './result'
-
-export type JSONPrimitive = string | boolean | number | null
-// eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
-export interface JSONObject {
-  [k: string]: JSONValue
-}
-export type JSONArray = JSONValue[]
-export type JSONValue = JSONPrimitive | JSONObject | JSONArray
-
-export function deserialize (s: string): Result<JSONValue, string> {
-  try {
-    return Result.success(JSON.parse(s))
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  } catch (e: any) {
-    return Result.failure(e.message)
-  }
-}
-
-export function makeSerializer (options: {
-  minified?: boolean
-  whitelist?: string[]
-}) {
-  return function serialize (v: JSONValue): string {
-    return JSON.stringify(
-      v,
-      options.whitelist,
-      options.minified === false ? undefined : 2
-    )
-  }
-}
-
-export function serialize (v: JSONValue): string {
-  return JSON.stringify(v, null, 2)
-}
-
-export function serializeMinified (v: JSONValue): string {
-  return JSON.stringify(v)
-}

package/src/match.ts

@@ -1,88 +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.
-*/
-
-import { type Differentiate, type DifferentiateAt } from './types/differentiate'
-import { type AnyKey } from './types/utility'
-import { type ObjectWithField, type ObjectWithPath, type TypeAtPath } from './types/objects'
-
-export function matchLiteral<A extends AnyKey, B> (
-  input: A,
-  matcher: { [k in A]: B }
-): B {
-  return matcher[input]
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function match<F extends AnyKey, T extends ObjectWithField<F, any>, B> (
-  input: T,
-  field: F,
-  matcher: { [k in T[F]]: (arg: Differentiate<F, T, k>) => B }
-): B {
-  const k = input[field]
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return matcher[k](input as any)
-}
-
-export function deepMatch<
-  Path extends AnyKey[],
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  T extends ObjectWithPath<Path, any>,
-  B
-> (
-  input: T,
-  path: Path,
-  matcher: {
-    [k in TypeAtPath<Path, T>]: (arg: DifferentiateAt<Path, T, k>) => B
-  }
-): B {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const k = path.reduce((res: any, key) => res[key], input) as TypeAtPath<
-  Path,
-  T
-  >
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return matcher[k](input as any)
-}
-
-export function createMatch<F extends AnyKey> (field: F) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return <T extends ObjectWithField<F, any>, B>(
-    input: T,
-    matcher: { [k in T[F]]: (arg: Differentiate<F, T, k>) => B }
-  ): B => {
-    const k = input[field]
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return matcher[k](input as any)
-  }
-}
-
-export const createDeepMatch =
-  <Path extends AnyKey[]>(...path: Path) =>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  <T extends ObjectWithPath<Path, any>, B>(
-      input: T,
-      matcher: {
-        [k in TypeAtPath<Path, T>]: (arg: DifferentiateAt<Path, T, k>) => B
-      }
-    ): B => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const k = path.reduce((res: any, key) => res[key], input) as TypeAtPath<
-    Path,
-    T
-    >
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return matcher[k](input as any)
-  }
-
-export const matchKind = createMatch('kind')
-export const matchType = createMatch('type')

package/src/maybe.ts

@@ -1,32 +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 type Maybe<T> = Just<T> | Nothing
-
-export type Nothing = undefined | null
-export type Just<T> = T
-
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export const Maybe = {
-  nothing: undefined as Maybe<never>,
-  just: <T>(value: T): Maybe<T> => {
-    return value
-  },
-
-  isNothing: <T>(maybe: Maybe<T>): maybe is Nothing => {
-    return maybe == null
-  },
-  isJust: <T>(maybe: Maybe<T>): maybe is Just<T> => {
-    return maybe != null
-  }
-}

package/src/memoize.ts

@@ -1,9 +0,0 @@
-export function memoize<T> (f: () => T): () => T {
-  let value: T | undefined
-  return () => {
-    if (value === undefined) {
-      value = f()
-    }
-    return value
-  }
-}

package/src/newtype.ts

@@ -1,59 +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.
-*/
-
-/**
- * Usage:
- *
- * ```ts
- * export interface Int extends Newtype<
- *   number,
- *   { readonly Int: unique symbol }
- * > {}
- *
- * export const Int = new class extends NewtypeClass<Int> {
- *   isValid(v: number) { return Number.isInteger(v) }
- * }()
- * ```
- */
-
-import { type Maybe } from './maybe'
-
-export type TypeOfN<T extends Newtype<unknown, unknown>> = T['_T']
-
-export interface Newtype<V, S> {
-  readonly _T: V
-  readonly _S: S
-}
-
-export abstract class NewtypeClass<T extends Newtype<unknown, unknown>> {
-  abstract isValid (v: TypeOfN<T>): boolean
-  unsafeOf (v: TypeOfN<T>): T {
-    return v as unknown as T
-  }
-
-  of (v: TypeOfN<T>): Maybe<T> {
-    return this.isValid(v) ? (v as unknown as T) : undefined
-  }
-
-  get (v: T): TypeOfN<T> {
-    return v as unknown as TypeOfN<T>
-  }
-
-  modify (f: (v: TypeOfN<T>) => TypeOfN<T>): (value: T) => Maybe<T> {
-    return (value: T) => this.of(f(this.get(value)))
-  }
-
-  unsafeModify (f: (v: TypeOfN<T>) => TypeOfN<T>): (value: T) => T {
-    return (value: T) => this.unsafeOf(f(this.get(value)))
-  }
-}