@tempots/std 0.9.0

package/src/types/tuples.ts

@@ -0,0 +1,244 @@
+/* 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/types/utility.ts

@@ -0,0 +1,3 @@
+export type AnyKey = string | number | symbol
+
+export type Primitive = string | boolean | number | null | undefined

package/src/uuid.ts

@@ -0,0 +1,61 @@
+/*
+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

@@ -0,0 +1,69 @@
+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
+    }
+}