feat(parser): add parser combinators

README.md

@@ -261,3 +261,39 @@ type res5 = Pipe<
   - [x] `Extends<A, B>`
   - [x] `Equals<A, B>`
   - [x] `DoesNotExtend<A, B>`
+- [ ] Parser
+  - [x] Parse
+  - [x] ToString
+  - [x] Literal
+  - [x] NotLiteral
+  - [x] Optional
+  - [x] Many
+  - [x] Many1
+  - [x] Sequence
+  - [x] EndOfInput
+  - [x] Map
+  - [x] MapError
+  - [x] Skip
+  - [x] Choice
+  - [x] Or
+  - [x] Not
+  - [x] Whitespace
+  - [x] Whitespaces
+  - [x] Trim
+  - [x] TrimLeft
+  - [x] TrimRight
+  - [x] Any
+  - [x] CharRange
+  - [x] Alpha
+  - [x] AlphaNum
+  - [x] Digit
+  - [x] Digits
+  - [x] Word
+  - [x] SepBy
+  - [x] Between
+  - [x] PrefixBy
+  - [x] SufixBy
+  - [x] SepByLiteral
+  - [x] BetweenLiterals
+  - [x] PrefixByLiteral
+  - [x] SufixByLiteral

src/index.ts

@@ -30,6 +30,7 @@ import { Tuples } from "./internals/tuples/Tuples";
 import { Unions } from "./internals/unions/Unions";
 import { Booleans } from "./internals/booleans/Booleans";
 import { Match } from "./internals/match/Match";
+import { Parser } from "./internals/parser/Parser";
 
 export {
   _,
@@ -62,11 +63,13 @@ export {
   Numbers,
   Tuples,
   Functions,
+  Parser,
   Booleans as B,
   Objects as O,
   Unions as U,
   Strings as S,
   Numbers as N,
   Tuples as T,
   Functions as F,
+  Parser as P,
 };

src/internals/objects/Objects.ts

@@ -18,6 +18,20 @@ export namespace Objects {
     return: Impl.FromEntries<Extract<this["arg0"], [PropertyKey, any]>>;
   }
 
+  /**
+   * Create an object from an array like `[key1, value1, key2, value2, ...]`.
+   * @param arr - array to convert to an object
+   * @returns an object
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Objects.FromArray, ["a", 1, "b", true]>; // { a: 1; b: true }
+   * ```
+   */
+  export interface FromArray extends Fn {
+    return: Impl.FromArray<this["arg0"]>;
+  }
+
   /**
    * Turn an object into a union of entries
    * @param obj - The object to transform to entries

src/internals/objects/impl/objects.ts

@@ -26,6 +26,13 @@ export type FromEntries<entries extends [PropertyKey, any]> = {
   [entry in entries as entry[0]]: entry[1];
 };
 
+export type FromArray<
+  arr extends unknown[],
+  Acc extends Record<PropertyKey, unknown> = {}
+> = arr extends [infer key extends PropertyKey, infer value, ...infer rest]
+  ? FromArray<rest, Prettify<Acc & { [K in key]: value }>>
+  : Acc;
+
 export type Entries<T> = Keys<T> extends infer keys extends keyof T
   ? {
       [K in keys]: [K, T[K]];