@tempots/std 0.9.6 → 0.9.7

package/src/types/tuples.ts

@@ -1,244 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/*
-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 Pointer, type DeRef } from './generic'
-
-// export type LoseLast<A extends any[]> = Reverse<LoseLastImpl<[], A>>
-
-// TYPE TESTS
-import { type Assert, type Equals, type AssertNot, type NotEquals } from './assert'
-
-export type Tail<T extends any[]> = ((...args: T) => void) extends (
-  _: any,
-  ...rest: infer Rest
-) => void
-  ? Rest
-  : never
-
-type DropNImpl<N extends number, T extends any[], I extends any[]> = {
-  return: T
-  next: DropNImpl<N, Tail<T>, Prepend<any, I>>
-}[Length<I> extends N ? 'return' : 'next']
-
-export type DropN<N extends number, T extends any[]> = DropNImpl<N, T, []>
-
-type ReverseImpl<T extends any[], R extends any[], I extends any[]> = {
-  return: DeRef<Pointer<R>>
-  next: ReverseImpl<T, Prepend<T[Length<I>], R>, Prepend<any, I>>
-}[Length<I> extends Length<T> ? 'return' : 'next']
-
-export type Reverse<T extends any[]> = ReverseImpl<T, [], []>
-
-export type Head<T extends any[]> = T extends [infer H, ...any[]] ? H : never
-
-export type Last<T extends any[]> = {
-  n: Last<Tail<T>>
-  one: T extends [infer H] ? H : never
-  empty: never
-}[T extends [] ? 'empty' : T extends [any] ? 'one' : 'n']
-
-export type TupleToUnion<T extends any[]> = T[number]
-
-export type Prepend<Insert, Tail extends any[]> = [Insert, ...Tail]
-
-export type Append<Tuple extends any[], Element> = [...Tuple, Element]
-
-export type Length<T extends any[]> = T['length']
-
-// export type Concat<A extends any[], B extends any[]> =
-//   ReverseImpl<Cast<ReverseImpl<A, [], []>, any[]>, B, []>
-
-// export type Append<A extends any[], B> = Concat<A, [B]>
-
-// export type Pop<A extends any[]> = Head<Reverse<A>>
-
-export type LoseLastImpl<A extends any[], B extends any[]> = {
-  empty: A
-  next: LoseLastImpl<Prepend<B[0], A>, Tail<B>>
-}[B extends [] ? 'empty' : B extends [any] ? 'empty' : 'next']
-
-export type UnionToIntersection<U> = (
-  U extends any ? (k: U) => void : never
-) extends (k: infer I) => void
-  ? I
-  : never
-
-type LastOf<T> = UnionToIntersection<
-T extends any ? () => T : never
-> extends () => infer R
-  ? R
-  : never
-
-export type Push<T extends any[], V> = [...T, V]
-
-export type UnionToTuple<
-  T,
-  L = LastOf<T>,
-  N = [T] extends [never] ? true : false
-> = true extends N ? [] : Push<UnionToTuple1<Exclude<T, L>>, L>
-type UnionToTuple1<
-  T,
-  L = LastOf<T>,
-  N = [T] extends [never] ? true : false
-> = true extends N ? [] : Push<UnionToTuple2<Exclude<T, L>>, L>
-type UnionToTuple2<
-  T,
-  L = LastOf<T>,
-  N = [T] extends [never] ? true : false
-> = true extends N ? [] : Push<UnionToTuple3<Exclude<T, L>>, L>
-type UnionToTuple3<
-  T,
-  L = LastOf<T>,
-  N = [T] extends [never] ? true : false
-> = true extends N ? [] : Push<UnionToTuple4<Exclude<T, L>>, L>
-type UnionToTuple4<
-  T,
-  L = LastOf<T>,
-  N = [T] extends [never] ? true : false
-> = true extends N ? [] : Push<UnionToTuple5<Exclude<T, L>>, L>
-type UnionToTuple5<
-  T,
-  L = LastOf<T>,
-  N = [T] extends [never] ? true : false
-> = true extends N ? [] : Push<UnionToTuple6<Exclude<T, L>>, L>
-type UnionToTuple6<
-  T,
-  L = LastOf<T>,
-  N = [T] extends [never] ? true : false
-> = true extends N ? [] : Push<UnionToTuple7<Exclude<T, L>>, L>
-type UnionToTuple7<
-  T,
-  L = LastOf<T>,
-  N = [T] extends [never] ? true : false
-> = true extends N ? [] : Push<UnionToTuple8<Exclude<T, L>>, L>
-type UnionToTuple8<
-  T,
-  L = LastOf<T>,
-  N = [T] extends [never] ? true : false
-> = true extends N ? [] : Push<UnionToTuple9<Exclude<T, L>>, L>
-type UnionToTuple9<
-  T,
-  L = LastOf<T>,
-  N = [T] extends [never] ? true : false
-> = true extends N ? [] : Push<UnionToTupleX<Exclude<T, L>>, L>
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-type UnionToTupleX<T> = never
-
-type _head = Head<[number, string]>
-type _tail = Tail<[number, string, boolean]>
-type _head_is_number = Assert<Equals<_head, number>>
-type _tail_is_string_boolean = Assert<Equals<_tail, [string, boolean]>>
-type _head_is_not_string = AssertNot<Equals<Head<[number, string]>, boolean>>
-type _last_is_boolean = Assert<Equals<Last<[number, string, boolean]>, boolean>>
-type _last_is_not_string = Assert<NotEquals<Last<[number, string]>, boolean>>
-type _tuple_to_union_of_empty_is_never = Assert<Equals<TupleToUnion<[]>, never>>
-type _tuple_to_union_of_not_empty_is_list = Assert<
-Equals<TupleToUnion<[string, 1]>, string | 1>
->
-type _union_to_tuple_of_not_empty_set_is_list = Assert<
-Equals<UnionToTuple<string | 1>, [string, 1]>
->
-type _prepend_works_on_empty_tail = Assert<
-Equals<Prepend<string, []>, [string]>
->
-type _prepend_works_on_non_empty_tail = Assert<
-Equals<Prepend<string, [number]>, [string, number]>
->
-type _prepend_fails_on_mismatching_types = Assert<
-NotEquals<Prepend<string, [boolean]>, [string, number]>
->
-type _append_works_on_empty_list = Assert<Equals<Append<[], string>, [string]>>
-type _append_works_on_non_empty_list = Assert<
-Equals<Append<[number], string>, [number, string]>
->
-type _append_works_on_non_empty_list2 = Assert<
-Equals<Append<[number, boolean], string>, [number, boolean, string]>
->
-type _append_fails_on_mismatching_types = Assert<
-NotEquals<Append<[boolean], string>, [string, number]>
->
-type _length_works_with_empty = Assert<Equals<Length<[]>, 0>>
-type _length_works_with_one = Assert<Equals<Length<[1]>, 1>>
-type _length_works_with_tewo = Assert<Equals<Length<[1, 2]>, 2>>
-type _length_works_with_three = Assert<Equals<Length<[1, 2, 3]>, 3>>
-type _length_works_with_four = Assert<Equals<Length<[1, 2, 3, 4]>, 4>>
-
-type _DropN_works_dropping_1_of_2 = Assert<Equals<DropN<1, [1, 2]>, [2]>>
-type _DropN_works_dropping_2_of_4 = Assert<
-Equals<DropN<2, [1, 2, 3, 4]>, [3, 4]>
->
-type _DropN_works_dropping_4_of_4 = Assert<Equals<DropN<4, [1, 2, 3, 4]>, []>>
-
-type _reverse_empty_works = Assert<Equals<Reverse<[]>, []>>
-type _reverse_one_works = Assert<Equals<Reverse<[1]>, [1]>>
-type _reverse_two_works = Assert<Equals<Reverse<[1, 2]>, [2, 1]>>
-type _reverse_three_works = Assert<Equals<Reverse<[1, 2, 3]>, [3, 2, 1]>>
-type _reverse_four_works = Assert<Equals<Reverse<[1, 2, 3, 4]>, [4, 3, 2, 1]>>
-
-// type _Concat_0_0 = Assert<Equals<Concat<[], []>, []>>
-// type _Concat_0_1 = Assert<Equals<Concat<[], [1]>, [1]>>
-// type _Concat_1_0 = Assert<Equals<Concat<[1], []>, [1]>>
-// type _Concat_2_3 = Assert<Equals<Concat<[1, 2], [3, 4, 5]>, [1, 2, 3, 4, 5]>>
-
-// type _Pop_1 = Assert<Equals<Pop<[1]>, 1>>
-// type _Pop_2 = Assert<Equals<Pop<[1, 2]>, 2>>
-// type _LoseLast_1 = Assert<Equals<LoseLast<[1]>, []>>
-// type _LoseLast_2 = Assert<Equals<LoseLast<[1, 2]>, [1]>>
-// type _LoseLast_3 = Assert<Equals<LoseLast<[1, 2, 3]>, [1, 2]>>
-// type _LoseLast_4 = Assert<Equals<LoseLast<[1, 2, 3, 4]>, [1, 2, 3]>>
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-type _TESTS_ =
-  | _head_is_number
-  | _tail_is_string_boolean
-  | _head_is_not_string
-  | _last_is_boolean
-  | _last_is_not_string
-  | _tuple_to_union_of_empty_is_never
-  | _tuple_to_union_of_not_empty_is_list
-  | _union_to_tuple_of_not_empty_set_is_list
-  | _prepend_works_on_empty_tail
-  | _prepend_works_on_non_empty_tail
-  | _prepend_fails_on_mismatching_types
-  | _append_works_on_empty_list
-  | _append_works_on_non_empty_list
-  | _append_works_on_non_empty_list2
-  | _append_fails_on_mismatching_types
-  | _length_works_with_empty
-  | _length_works_with_one
-  | _length_works_with_tewo
-  | _length_works_with_three
-  | _length_works_with_four
-  | _DropN_works_dropping_1_of_2
-  | _DropN_works_dropping_2_of_4
-  | _DropN_works_dropping_4_of_4
-  | _reverse_empty_works
-  | _reverse_one_works
-  | _reverse_two_works
-  | _reverse_three_works
-  | _reverse_four_works
-// | _Concat_0_0
-// | _Concat_0_1
-// | _Concat_1_0
-// | _Concat_2_3
-// | _Pop_1
-// | _Pop_2
-// | _LoseLast_1
-// | _LoseLast_2
-// | _LoseLast_3
-// | _LoseLast_4

package/src/uuid.ts

@@ -1,61 +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.
-*/
-
-/**
- * Helper functions to generate and validate [UUID](http://en.wikipedia.org/wiki/Universally_unique_identifier)
- * strings (version 4).
- */
-
-import { type Newtype, NewtypeClass } from './newtype'
-
-const random = (max: number): number => Math.floor(Math.random() * max)
-const srandom = (): string => '0123456789abcdef'.charAt(random(0x10))
-
-/**
- * `Uuid.create()` returns a string value representing a random UUID string.
- */
-export function create (): UUID {
-  const s = [] as string[]
-  let i = 0
-  for (i = 0; i < 8; i++) s[i] = srandom()
-  s[8] = '-'
-  for (i = 9; i < 13; i++) s[i] = srandom()
-  s[13] = '-'
-  s[14] = '4'
-  for (i = 15; i < 18; i++) s[i] = srandom()
-  s[18] = '-'
-  s[19] = '89AB'.charAt(random(0x3))
-  for (i = 20; i < 23; i++) s[i] = srandom()
-  s[23] = '-'
-  for (i = 24; i < 36; i++) s[i] = srandom()
-  return UUID.unsafeOf(s.join(''))
-}
-
-const pattern =
-  /^[0123456789abcdef]{8}-[0123456789abcdef]{4}-4[0123456789abcdef]{3}-[89ab][0123456789abcdef]{3}-[0123456789abcdef]{12}$/i
-
-export type UUID = Newtype<string, { readonly UUID: unique symbol }>
-
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export const UUID: NewtypeClass<UUID> = new (class extends NewtypeClass<UUID> {
-  /**
-   * Returns `true` if the passed `uuid` conforms to the UUID v.4 format.
-   */
-  isValid (uuid: string): boolean {
-    return pattern.test(uuid)
-  }
-
-  override toString (uuid: UUID): string {
-    return UUID.get(uuid)
-  }
-})()

package/src/validation.ts

@@ -1,69 +0,0 @@
-import { Result } from './result'
-
-export interface Valid {
-  type: 'valid'
-}
-export interface Invalid<E> {
-  type: 'invalid'
-  error: E
-}
-
-export type Validation<E> = Valid | Invalid<E>
-
-export type PromiseValidation<E> = PromiseLike<Validation<E>>
-
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export const Validation = {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  valid: { type: 'valid' } satisfies Validation<any>,
-  invalid<E>(error: E): Validation<E> {
-    return { type: 'invalid', error }
-  },
-  isValid<E>(r: Validation<E>): r is Valid {
-    return r.type === 'valid'
-  },
-  isInvalid<E>(r: Validation<E>): r is Invalid<E> {
-    return r.type === 'invalid'
-  },
-  cmatch:
-    <V, E>(valid: () => V, invalid: (error: E) => V) =>
-    (r: Validation<E>): V => {
-      if (Validation.isValid(r)) {
-        return valid()
-      } else {
-        return invalid(r.error)
-      }
-    },
-  match: <V, E>(
-    r: Validation<E>,
-    valid: () => V,
-    invalid: (error: E) => V
-  ): V => {
-    if (Validation.isValid(r)) {
-      return valid()
-    } else {
-      return invalid(r.error)
-    }
-  },
-  toResult: <T, E>(value: T): ((validation: Validation<E>) => Result<T, E>) =>
-    Validation.cmatch(
-      () => Result.success<T>(value),
-      (err: E) => Result.failure<E>(err)
-    ),
-  whenValid:
-    <E>(apply: () => void) =>
-    (r: Validation<E>): Validation<E> => {
-      if (Validation.isValid(r)) {
-        apply()
-      }
-      return r
-    },
-  whenInvalid:
-    <E>(apply: (e: E) => void) =>
-    (r: Validation<E>): Validation<E> => {
-      if (Validation.isInvalid(r)) {
-        apply(r.error)
-      }
-      return r
-    }
-}