diff --git a/README.md b/README.md
index 8e54d28..3748ae1 100644
--- a/README.md
+++ b/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
diff --git a/src/index.ts b/src/index.ts
index c4f83d7..a8827fa 100644
--- a/src/index.ts
+++ b/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,6 +63,7 @@ export {
   Numbers,
   Tuples,
   Functions,
+  Parser,
   Booleans as B,
   Objects as O,
   Unions as U,
@@ -69,4 +71,5 @@ export {
   Numbers as N,
   Tuples as T,
   Functions as F,
+  Parser as P,
 };
diff --git a/src/internals/objects/Objects.ts b/src/internals/objects/Objects.ts
index c3979b8..d15671c 100644
--- a/src/internals/objects/Objects.ts
+++ b/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
diff --git a/src/internals/objects/impl/objects.ts b/src/internals/objects/impl/objects.ts
index 3a2125f..26647f8 100644
--- a/src/internals/objects/impl/objects.ts
+++ b/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]];
diff --git a/src/internals/parser/Parser.ts b/src/internals/parser/Parser.ts
new file mode 100644
index 0000000..cce3826
--- /dev/null
+++ b/src/internals/parser/Parser.ts
@@ -0,0 +1,914 @@
+import {
+  Call,
+  Compose,
+  Constant,
+  Eval,
+  Fn,
+  PartialApply,
+  Pipe,
+  unset,
+  _,
+} from "../core/Core";
+import { Match } from "../match/Match";
+import { CharToNumber } from "../strings/impl/chars";
+import { Strings } from "../strings/Strings";
+import { Tuples } from "../tuples/Tuples";
+import { GreaterThanOrEqual, LessThanOrEqual } from "../numbers/impl/compare";
+export namespace Parser {
+  /**
+   * A parser is a function that takes static parameters and a string input
+   * and returns a result or an error.
+   * @description to enable introspection, parsers augment the function type
+   * with a name and a list of parameters.
+   */
+  export interface ParserFn extends Fn {
+    name: string;
+    params: any;
+  }
+
+  /**
+   * Base functionnal Ok type to allow for advanced error handling in HOTScript.
+   */
+  export type Value<value> = {
+    kind: "Ok";
+    value: value;
+  };
+
+  /**
+   * Base functionnal Error type to allow for advanced error handling in HOTScript.
+   */
+  type Error<error> = {
+    kind: "Err";
+    error: error;
+  };
+
+  /**
+   * specialised Ok type for parsers.
+   */
+  export type Ok<Result = unknown, Input extends string = string> = Value<{
+    result: Result;
+    input: Input;
+  }>;
+
+  /**
+   * specialised Error type for parsers.
+   */
+  export type Err<
+    Parser,
+    Input extends string,
+    Cause extends unknown = ""
+  > = Error<{
+    message: `Expected '${Eval<ToString<Parser>>}' - Received '${Input}'`;
+    input: Input;
+    cause: Eval<Tuples.Join<" | ", Cause>>;
+  }>;
+
+  /**
+   * specialised Error type for parsers when the input is not a string.
+   */
+  export type InputError<Input extends string> = Error<{
+    message: "Input must be a string";
+    cause: Input;
+  }>;
+
+  /**
+   * Extract the most appropriate error message from an error type.
+   */
+  export type ErrMsg<TError> = TError extends Error<{
+    message: infer Msg;
+    cause: infer Cause;
+  }>
+    ? Cause extends ""
+      ? Msg
+      : Cause
+    : never;
+
+  interface ToStringFn extends Fn {
+    return: this["arg0"] extends infer Parser extends ParserFn
+      ? `${Parser["name"]}(${Eval<
+          Tuples.Join<
+            ",",
+            Pipe<
+              Parser["params"],
+              [
+                Tuples.Map<
+                  Match<
+                    [
+                      Match.With<ParserFn, ToString>,
+                      Match.With<
+                        number | undefined | null | boolean,
+                        Strings.ToString
+                      >,
+                      Match.With<
+                        string,
+                        Compose<[Strings.Append<"'">, Strings.Append<_, "'">]>
+                      >
+                    ]
+                  >
+                >
+              ]
+            >
+          >
+        >})`
+      : never;
+  }
+
+  /**
+   * Introspetion function to convert a parser to a string for error messages.
+   * @param Parser - the parser to convert to a string
+   *
+   * @example
+   * ```ts
+   * type T0 = Eval<ToString<Literal<"a">>>;
+   * //   ^? type T0 = "literal('a')"
+   * ```
+   */
+  export type ToString<Parser extends unknown | _ | unset = unset> =
+    PartialApply<ToStringFn, [Parser]>;
+
+  /**
+   * Parser that matches a string.
+   * It can be a union of string literals or a string literal.
+   * in case of a union, the correct string literal is returned.
+   */
+  type LiteralImpl<
+    Self,
+    ExpectedLiteral extends string,
+    Input extends string
+  > = Input extends `${ExpectedLiteral}${infer Rest}`
+    ? Input extends `${infer Lit}${Rest}`
+      ? Ok<Lit, Rest>
+      : Err<Self, Input>
+    : Err<Self, Input>;
+
+  /**
+   * Parser that matches a literal string or a union of literal strings.
+   * @param ExpectedLiteral - the literal string or a union of literal strings to match
+   * @returns an Ok type if the literal string is found, an Err type otherwise
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Literal<"a">, "a">;
+   * //   ^? type T0 = Ok< "a", "" >
+   * type T1 = Call<Literal<"a">, "b">;
+   * //   ^? type T1 = Error<{ message: "Expected 'literal('a')' - Received 'b'"; cause: "" }>
+   * type T2 = Call<Literal<"a" | "b">, "a">;
+   * //   ^? type T2 = Ok< "a", "" >
+   * ```
+   */
+  export interface Literal<ExpectedLiteral extends string> extends ParserFn {
+    name: "literal";
+    params: [ExpectedLiteral];
+    return: LiteralImpl<this, ExpectedLiteral, this["arg0"]>;
+  }
+
+  type ManyImpl<
+    Self,
+    Parser,
+    Input extends string,
+    Acc extends unknown[] = []
+  > = Input extends ""
+    ? Ok<Acc, Input>
+    : Parser extends infer F extends ParserFn
+    ? Call<F, Input> extends infer A
+      ? A extends Ok<infer Res extends unknown[], infer In>
+        ? ManyImpl<Self, Parser, In, [...Acc, ...Res]>
+        : A extends Ok<infer Res, infer In>
+        ? ManyImpl<Self, Parser, In, [...Acc, Res]>
+        : Ok<Acc, Input>
+      : Ok<Acc, Input>
+    : Err<Self, Input>;
+
+  /**
+   * Parser that matches a parser 0 or more times. It returns an array of the matched parsers results.
+   * @param Parser - the parser to match
+   * @returns an Ok type if the parser matches 0 or more times and the rest of the input
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Many<Literal<"a">>, "aaa">;
+   * //   ^? type T0 = Ok< ["a", "a", "a"], "" >
+   * type T1 = Call<Many<Literal<"a">>, "bbb">;
+   * //   ^? type T1 = Ok< [], "bbb" >
+   * ```
+   */
+  export interface Many<Parser> extends ParserFn {
+    name: "many";
+    params: [Parser];
+    return: this["arg0"] extends infer Input extends string
+      ? ManyImpl<this, Parser, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  type SequenceImpl<
+    Self,
+    Parsers,
+    Input extends string,
+    Acc extends unknown[] = []
+  > = Parsers extends [infer Head extends ParserFn, ...infer Tail]
+    ? Call<Head, Input> extends infer A
+      ? A extends Ok<infer Res extends unknown[], infer In>
+        ? SequenceImpl<Self, Tail, In, [...Acc, ...Res]>
+        : A extends Ok<infer Res, infer In>
+        ? SequenceImpl<Self, Tail, In, [...Acc, Res]>
+        : A // forwards error
+      : never
+    : Ok<Acc, Input>;
+
+  /**
+   * Parser that matches a list of parsers in sequence.
+   * @param Parsers - the parsers to match
+   * @returns an Ok type with an array of all the parsers results or the error of the first parser that fails
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Sequence<[Literal<"a">, Literal<"b">]>, "ab">;
+   * //   ^? type T0 = Ok< ["a", "b"], "" >
+   * type T1 = Call<Sequence<[Literal<"a">, Literal<"b">]>, "ac">;
+   * //   ^? type T1 = Error<{ message: "Expected 'literal('b')' - Received 'c'"; cause: "" }>
+   * ```
+   */
+  export interface Sequence<Parsers> extends ParserFn {
+    name: "sequence";
+    params: Parsers;
+    return: this["arg0"] extends infer Input extends string
+      ? SequenceImpl<this, Parsers, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  type CommaSep = Sequence<
+    [Trim<Word>, Optional<Sequence<[Literal<",">, CommaSep]>>]
+  >;
+
+  type test = Call<CommaSep, "a, b, c">;
+  //    ^?
+
+  /**
+   * Parser that fails if there is any input left.
+   * @returns an Ok type if there is no input left
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<EndOfInput, "">;
+   * //   ^? type T0 = Ok< [], "" >
+   * type T1 = Call<EndOfInput, "a">;
+   * //   ^? type T1 = Error<{ message: "Expected 'endOfInput()' - Received 'a'"; cause: "" }>
+   * ```
+   */
+  export interface EndOfInput extends ParserFn {
+    name: "endOfInput";
+    params: [];
+    return: this["arg0"] extends infer Input extends string
+      ? Input extends ""
+        ? Ok<[], Input>
+        : Err<this, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  /**
+   * Parser that transforms the result of another parser when it succeeds.
+   * @description The function `Map` is called with the result of `Parser` and the result of `Map` is returned.
+   * This allows you to transform the result of a parser to create an AST.
+   * @param Parser - the parser to match
+   * @param Map - the function to call with the result of `Parser`
+   * @returns an Ok type if the parser matches and the result of `Map` or the error of the parser
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Map<Literal<"a">, Constant<"b">>, "a">;
+   * //   ^? type T0 = Ok< "b", "" >
+   * type T1 = Call<Map<Literal<"a">, Constant<"b">>, "b">;
+   * //   ^? type T1 = Error<{ message: "Expected 'literal('a')' - Received 'b'"; cause: "" }>
+   * ```
+   */
+  export interface Map<Parser, Map extends Fn> extends ParserFn {
+    name: "map";
+    params: [Parser, "Fn"];
+    return: this["arg0"] extends infer Input extends string
+      ? Parser extends infer F extends ParserFn
+        ? Call<F, Input> extends infer A
+          ? A extends Ok<infer Result, infer Input>
+            ? Ok<Call<Map, Result>, Input>
+            : A
+          : never
+        : Err<this, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  /**
+   * Parser that discards the result of another parser when it succeeds.
+   * But it still returns the rest of the input.
+   * @param Parser - the parser to match
+   * @returns an Ok type if the parser matches and an empty array or the error of the parser
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Skip<Literal<"a">>, "a">;
+   * //   ^? type T0 = Ok< [], "" >
+   * type T1 = Call<Skip<Literal<"a">>, "b">;
+   * //   ^? type T1 = Error<{ message: "Expected 'literal('a')' - Received 'b'"; cause: "" }>
+   * ```
+   */
+  export type Skip<Parser> = Map<Parser, Constant<[]>>;
+
+  /**
+   * Parser that transforms the error of another parser when it fails.
+   * @description The function `Map` is called with the error of `Parser` and the error of `Map` is returned.
+   * This allows you to transform the error of a parser to create a more helpful error message or even to recover from an error.
+   * @param Parser - the parser to match
+   * @param Map - the function to call with the error of `Parser`
+   * @returns an Ok type if the parser matches or the result of `Map`
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<MapError<Literal<"a">, Constant<"b">>, "a">;
+   * //   ^? type T0 = Ok< "a", "" >
+   * type T1 = Call<MapError<Literal<"a">, Objects.Create<{
+   *  kind: "Ok";
+   *  value: {
+   *   result: 'not "a"';
+   *   input: Objects.Get<'error.input'>
+   *  }
+   * }>>, "b">; // transforms the error to an Ok type
+   * ```
+   */
+  export interface MapError<Parser, Map extends Fn> extends ParserFn {
+    name: "mapError";
+    params: [Parser, "Fn"];
+    return: this["arg0"] extends infer Input extends string
+      ? Parser extends infer F extends ParserFn
+        ? Call<F, Input> extends infer A
+          ? A extends Error<unknown>
+            ? Call<Map, A>
+            : A
+          : never
+        : Err<this, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  type ChoiceImpl<
+    Self,
+    Parsers,
+    Input extends string,
+    ErrorAcc extends unknown[] = []
+  > = Parsers extends [
+    infer Head extends ParserFn,
+    ...infer Tail extends ParserFn[]
+  ]
+    ? Call<Head, Input> extends infer A
+      ? A extends Ok
+        ? A
+        : ChoiceImpl<Self, Tail, Input, [...ErrorAcc, ErrMsg<A>]>
+      : never
+    : Err<Self, Input, ErrorAcc>;
+
+  /**
+   * Parser that tries to match the input with one of the given parsers.
+   * @description The parsers are tried in the order they are given.
+   * @param Parsers - the parsers to try
+   * @returns an Ok type if one of the parsers matches or an error with all the errors of the parsers
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Choice<[
+   * //   ^? type T0 = Ok< "a", "" >
+   *   Literal<"a">,
+   *   Literal<"b">,
+   * ]>, "a">;
+   * type T1 = Call<Choice<[
+   * //   ^? type T1 = Ok< "b", "" >
+   *  Literal<"a">,
+   *  Literal<"b">,
+   * ]>, "b">;
+   * type T2 = Call<Choice<[
+   * //   ^? type T2 = Error<{ message: "Expected 'choice(literal('a'),literal('b'))' - Received 'c'"; cause: "Expected 'literal('a')' - Received 'c' | Expected 'literal('b')' - Received 'c'";}>
+   * Literal<"a">,
+   * Literal<"b">,
+   * ]>, "c">;
+   * ```
+   */
+  export interface Choice<Parsers> extends ParserFn {
+    name: "choice";
+    params: Parsers;
+    return: this["arg0"] extends infer Input extends string
+      ? ChoiceImpl<this, Parsers, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  /**
+   * Parser that tries to match the input with one of the two given parsers.
+   * @description The parsers are tried in the order they are given.
+   * @param Parser1 - the first parser to try
+   * @param Parser2 - the second parser to try
+   * @returns an Ok type if one of the parsers matches or an error with all the errors of the parsers
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Or<Literal<"a">, Literal<"b">>, "a">;
+   * //   ^? type T0 = Ok<"a", "">
+   * ```
+   */
+  export type Or<Parser1, Parser2> = Choice<[Parser1, Parser2]>;
+
+  /**
+   * Parser that optionally matches the input with the given parser.
+   * @description If the parser matches it will return the result of the parser.
+   * If the parser doesn't match it will return an empty array.
+   * @param Parser - the parser to match
+   * @returns an Ok type if the parser matches and an empty array or the error of the parser
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Optional<Literal<"a">>, "a">;
+   * //   ^? type T0 = Ok<["a"],"">
+   * type T1 = Call<Optional<Literal<"a">>, "b">;
+   * //   ^? type T1 = Ok<[],"b">
+   * ```
+   */
+  export interface Optional<Parser> extends ParserFn {
+    name: "optional";
+    params: [Parser];
+    return: this["arg0"] extends infer Input extends string
+      ? Parser extends infer F extends ParserFn
+        ? Call<F, Input> extends infer A
+          ? A extends Ok
+            ? A
+            : Ok<[], Input>
+          : never
+        : Err<this, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  /**
+   * Parser that matches if the given parser doesn't match.
+   * it will not consume any input allowing to use it as a lookahead in a sequence.
+   * @param Parser - the parser to match
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Not<Literal<"test">>, "test">;
+   * //   ^? type T0 = Error<{ message: "Expected 'not(literal('test'))' - Received 'test'"; cause: "";}>
+   * type T1 = Call<Not<Literal<"test">>, "other">;
+   * //   ^? type T1 = Ok< [], "other" >
+   */
+  export interface Not<Parser> extends ParserFn {
+    name: "not";
+    params: [Parser];
+    return: this["arg0"] extends infer Input extends string
+      ? Parser extends infer F extends ParserFn
+        ? Call<F, Input> extends Ok
+          ? Err<this, Input>
+          : Ok<[], Input>
+        : Err<this, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  // prettier-ignore
+  type _lower = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
+  // prettier-ignore
+  type _upper = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z";
+  type _alpha = _lower | _upper;
+  // prettier-ignore
+  type _digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+  type _alhanum = _alpha | _digit;
+
+  /**
+   * Parser that matches a single character that is an alphabetical character.
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Alpha, "a">;
+   * //   ^? type T0 = Ok< "a", "" >
+   * type T1 = Call<Alpha, "A">;
+   * //   ^? type T1 = Ok< "A", "" >
+   * type T2 = Call<Alpha, "1">;
+   * //   ^? type T2 = Error<{ message: "Expected 'alpha()' - Received '1'"; cause: "";}>
+   * ```
+   */
+  export interface Alpha extends ParserFn {
+    name: "alpha";
+    params: [];
+    return: this["arg0"] extends infer Input extends string
+      ? Input extends `${infer Head}${infer Tail}`
+        ? Head extends _lower | _upper | "_"
+          ? Ok<Head, Tail>
+          : Err<this, Input>
+        : Err<this, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  /**
+   * Parser that matches a single character between the given characters.
+   * @param start - the start of the range
+   * @param end - the end of the range
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<CharRange<"a", "z">, "a">;
+   * //   ^? type T0 = Ok< "a", "" >
+   * type T1 = Call<CharRange<"a", "z">, "z">;
+   * //   ^? type T1 = Ok< "z", "" >
+   * type T2 = Call<CharRange<"a", "z">, "A">;
+   * //   ^? type T2 = Error<{ message: "Expected 'range('a', 'z')' - Received 'A'"; cause: "";}>
+   * ```
+   */
+  export interface CharRange<start extends string, end extends string>
+    extends ParserFn {
+    name: "range";
+    params: [start, end];
+    return: this["arg0"] extends infer Input extends string
+      ? Input extends `${infer Head}${infer Tail}`
+        ? [CharToNumber<start>, CharToNumber<Head>, CharToNumber<end>] extends [
+            infer S extends number,
+            infer H extends number,
+            infer E extends number
+          ]
+          ? [GreaterThanOrEqual<H, S>, LessThanOrEqual<H, E>] extends [
+              true,
+              true
+            ]
+            ? Ok<Head, Tail>
+            : Err<this, Input>
+          : Err<this, Input>
+        : Err<this, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  /**
+   * Parser that matches a single character that is an alphanumeric character.
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<AlphaNum, "a">;
+   * //   ^? type T0 = Ok< "a", "" >
+   * type T1 = Call<AlphaNum, "A">;
+   * //   ^? type T1 = Ok< "A", "" >
+   * type T2 = Call<AlphaNum, "1">;
+   * //   ^? type T2 = Ok< "1", "" >
+   * type T3 = Call<AlphaNum, "_">;
+   * //   ^? type T3 = Error<{ message: "Expected 'alphaNum()' - Received '_'"; cause: "";}>
+   * ```
+   */
+  export interface AlphaNum extends ParserFn {
+    name: "alphaNum";
+    params: [];
+    return: this["arg0"] extends infer Input extends string
+      ? Input extends `${infer Head}${infer Tail}`
+        ? Head extends _alhanum
+          ? Ok<Head, Tail>
+          : Err<this, Input>
+        : Err<this, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  /**
+   * Parser that matches a single character that is a digit.
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Digit, "1">;
+   * //   ^? type T0 = Ok< "1", "" >
+   * type T1 = Call<Digit, "a">;
+   * //   ^? type T1 = Error<{ message: "Expected 'digit()' - Received 'a'"; cause: "";}>
+   * ```
+   */
+  export interface Digit extends ParserFn {
+    name: "digit";
+    params: [];
+    return: this["arg0"] extends infer Input extends string
+      ? Input extends `${infer Head}${infer Tail}`
+        ? Head extends _digit
+          ? Ok<Head, Tail>
+          : Err<this, Input>
+        : Err<this, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  /**
+   * Parser that matches any single character
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Any, "a">;
+   * //   ^? type T0 = Ok< "a", "" >
+   * type T1 = Call<Any, "">;
+   * //   ^? type T1 = Error<{ message: "Expected 'any()' - Received ''"; cause: "";}>
+   * ```
+   */
+  export interface Any extends ParserFn {
+    name: "any";
+    params: [];
+    return: this["arg0"] extends infer Input extends string
+      ? Input extends `${infer Head}${infer Tail}`
+        ? Ok<Head, Tail>
+        : Err<this, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  /**
+   * Parser that matches a single character that is not the given literal.
+   * @param NotExpected - The character that should not be matched
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<NotLiteral<"a">, "b">;
+   * //   ^? type T0 = Ok< "b", "" >
+   * type T1 = Call<NotLiteral<"a">, "a">;
+   * //   ^? type T1 = Error<{ message: "Expected 'notLiteral('a')' - Received 'a'"; cause: "";}>
+   * ```
+   */
+  export type NotLiteral<NotExpected extends string> = Sequence<
+    [Not<Literal<NotExpected>>, Any]
+  >;
+
+  export type DigitsImpl<
+    Self,
+    Input extends string,
+    Acc extends string = ""
+  > = Input extends ""
+    ? Acc extends ""
+      ? Err<Self, Input>
+      : Ok<Acc, Input>
+    : Input extends `${infer Head}${infer Tail}`
+    ? Acc extends ""
+      ? Head extends _digit
+        ? DigitsImpl<Self, Tail, `${Acc}${Head}`>
+        : Err<Self, Input>
+      : Head extends _digit
+      ? DigitsImpl<Self, Tail, `${Acc}${Head}`>
+      : Ok<Acc, Input>
+    : never;
+
+  /**
+   * Parser that matches a sequence of digits.
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Digits, "123">;
+   * //   ^? type T0 = Ok< "123", "" >
+   * type T1 = Call<Digits, "a">;
+   * //   ^? type T1 = Error<{ message: "Expected 'digits()' - Received 'a'"; cause: "";}>
+   * ```
+   */
+  export interface Digits extends ParserFn {
+    name: "digits";
+    params: [];
+    return: this["arg0"] extends infer Input extends string
+      ? DigitsImpl<this, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  type WordImpl<
+    Self,
+    Input extends string,
+    Acc extends string = ""
+  > = Input extends ""
+    ? Acc extends ""
+      ? Err<Self, Input>
+      : Ok<Acc, Input>
+    : Input extends `${infer Head}${infer Tail}`
+    ? Acc extends ""
+      ? Head extends _alpha | "_"
+        ? WordImpl<Self, Tail, Head>
+        : Err<Self, Input>
+      : Head extends _alhanum | "_"
+      ? WordImpl<Self, Tail, `${Acc}${Head}`>
+      : Ok<Acc, Input>
+    : never;
+
+  /**
+   * Parser that matches a sequence of alphanumeric characters that starts with an alphabetical character or an underscore.
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Word, "abc">;
+   * //   ^? type T0 = Ok< "abc", "" >
+   * type T1 = Call<Word, "123">;
+   * //   ^? type T1 = Error<{ message: "Expected 'word()' - Received '123'"; cause: "";}>
+   * type T2 = Call<Word, "_abc">;
+   * //   ^? type T2 = Ok< "_abc", "" >
+   * type T3 = Call<Word, "a_123">;
+   * //   ^? type T3 = Ok< "a_123", "" >
+   * ```
+   */
+  export interface Word extends ParserFn {
+    name: "word";
+    params: [];
+    return: this["arg0"] extends infer Input extends string
+      ? WordImpl<this, Input>
+      : InputError<this["arg0"]>;
+  }
+
+  /**
+   * Parser that matches at least one time the given parser and tries to match it as many times as possible.
+   * @param Parser - the parser to match
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Many1<Alpha>, "abc">;
+   * //   ^? type T0 = Ok< ["a", "b", "c"], "" >
+   * type T1 = Call<Many1<Alpha>, "123">;
+   * //  ^? type T1 = Error<{ message: "Expected 'alpha()' - Received '123'"; cause: "";}>
+   * ```
+   */
+  export type Many1<Parser> = Sequence<[Parser, Many<Parser>]>;
+
+  /**
+   * Parser that matches the given parser followed by the given separator
+   * and tries to match it as many times as possible while discarding the separator.
+   * @param Parser - the parser to match
+   * @param Sep - the separator to match
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<SepBy<Alpha, Literal<",">>, "a,b,c">;
+   * //   ^? type T0 = Ok< ["a", "b", "c"], "" >
+   * type T1 = Call<SepBy<Alpha, Literal<",">>, "a,b,c,">;
+   * //   ^? type T1 = Error<{ message: "Expected 'alpha()' - Received ''"; cause: "";}>
+   * ```
+   */
+  export type SepBy<Parser, Sep> = Sequence<
+    [Many<Sequence<[Parser, Skip<Sep>]>>, Parser]
+  >;
+
+  export type SepByLiteral<Parser, Sep extends string> = SepBy<
+    Parser,
+    Literal<Sep>
+  >;
+
+  /**
+   * Parser that matches 3 parsers in sequence but discards the result of the enclosing parsers.
+   * @param Open - the parser to match before the parser to match
+   * @param Parser - the parser to match
+   * @param Close - the parser to match after the parser to match
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Between<Literal<"(">, Alpha, Literal<")">>, "(a)">;
+   * //   ^? type T0 = Ok< "a", "" >
+   * type T1 = Call<Between<Literal<"(">, Alpha, Literal<")">>, "(a">;
+   * //   ^? type T1 = Error<{ message: "Expected Literal(')') - Received ''"; cause: "";}>
+   * ```
+   */
+  export type Between<Open, Parser, Close> = Sequence<
+    [Skip<Open>, Parser, Skip<Close>]
+  >;
+
+  export type BetweenLiterals<
+    Open extends string,
+    Parser,
+    Close extends string
+  > = Between<Literal<Open>, Parser, Literal<Close>>;
+
+  /**
+   * Parser that matches the given prefix parser and the given parser and discards the result of the prefix parser.
+   * @param Prefix - the parser to match before the parser to match and discard
+   * @param Parser - the parser to match
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<PrefixBy<Literal<":">, Alpha>, ":a">;
+   * //   ^? type T0 = Ok< "a", "" >
+   * type T1 = Call<PrefixBy<Literal<":">, Alpha>, "a">;
+   * //   ^? type T1 = Error<{ message: "Expected Literal(':') - Received 'a'"; cause: "";}>
+   * ```
+   */
+  export type PrefixBy<Prefix, Parser> = Sequence<[Skip<Prefix>, Parser]>;
+
+  export type PrefixByLiteral<Prefix extends string, Parser> = PrefixBy<
+    Literal<Prefix>,
+    Parser
+  >;
+
+  /**
+   * Parser that matches the given parser and the given suffix parser and discards the result of the suffix parser.
+   * @param Parser - the parser to match
+   * @param Suffix - the parser to match after the parser to match and discard
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Suffix<Alpha, Literal<":">>, "a:">;
+   * //   ^? type T0 = Ok< "a", "" >
+   * type T1 = Call<Suffix<Alpha, Literal<":">>, "a">;
+   * //   ^? type T1 = Error<{ message: "Expected Literal(':') - Received ''"; cause: "";}>
+   * ```
+   */
+  export type SuffixBy<Parser, Suffix> = Sequence<[Parser, Skip<Suffix>]>;
+
+  export type SuffixByLiteral<Parser, Suffix extends string> = SuffixBy<
+    Parser,
+    Literal<Suffix>
+  >;
+
+  /**
+   * Parser that matches whitespace characters.
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Whitespace, " ">; // space
+   * //   ^? type T0 = Ok< " ", "" >
+   * type T1 = Call<Whitespace, "\t">; // tab
+   * //   ^? type T1 = Ok< "\t", "" >
+   * ```
+   */
+  export type Whitespace = Literal<" " | "\t" | "\n" | "\r">;
+
+  /**
+   * Parser that matches 0 or more whitespace characters.
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Whitespaces, " \t \n \r ">;
+   * //   ^? type T0 = Ok< [" ", "\t", " ", "\n", " ", "\r", " "], "" >
+   * ```
+   */
+  export type Whitespaces = Many<Whitespace>;
+
+  /**
+   * Parser that matches the given parser and discards the enclosing whitespace characters.
+   * @param Parser - the parser to match
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Trim<Literal<"test">>, "     test  ">;
+   * //   ^? type T0 = Ok< "test", "" >
+   * ```
+   */
+  export type Trim<Parser> = Sequence<
+    [Skip<Whitespaces>, Parser, Skip<Whitespaces>]
+  >;
+
+  /**
+   * Parser that matches the given parser and discards the enclosing whitespace characters.
+   * @param Parser - the parser to match
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<TrimLeft<Literal<"test">>, "     test  ">;
+   * //   ^? type T0 = Ok<["test"], "  " >
+   * ```
+   */
+  export type TrimLeft<Parser> = Sequence<[Skip<Whitespaces>, Parser]>;
+
+  /**
+   * Parser that matches the given parser and discards the enclosing whitespace characters.
+   * @param Parser - the parser to match
+   * @returns an Ok type if the parser matches or an error
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<TrimRight<Literal<"test">>, "test  ">;
+   * //   ^? type T0 = Ok< "test", "" >
+   * ```
+   */
+  export type TrimRight<Parser> = Sequence<[Parser, Skip<Whitespaces>]>;
+
+  interface ParseFn extends Fn {
+    return: this["args"] extends [
+      infer Parser extends ParserFn,
+      infer Input extends string
+    ]
+      ? Call<Parser, Input> extends infer A
+        ? A extends Ok<infer Result>
+          ? Result
+          : A extends Error<infer Err>
+          ? Err
+          : never
+        : never
+      : never;
+  }
+
+  /**
+   * Parse a string using the given parser and return the result.
+   * @param Parser - the parser to use
+   * @param Input - the string to parse
+   * @returns the result of the parser
+   *
+   * @example
+   * ```ts
+   * type T0 = Eval<Parse<Word, "abc">>;
+   * ```
+   */
+  export type Parse<
+    Parser extends unknown | _ | unset = unset,
+    Input extends string | _ | unset = unset
+  > = PartialApply<ParseFn, [Parser, Input]>;
+}
diff --git a/src/internals/strings/Strings.ts b/src/internals/strings/Strings.ts
index 1952e44..6dffd29 100644
--- a/src/internals/strings/Strings.ts
+++ b/src/internals/strings/Strings.ts
@@ -3,7 +3,6 @@ import { Std } from "../std/Std";
 import { Tuples } from "../tuples/Tuples";
 import * as H from "../helpers";
 import * as Impl from "./impl/strings";
-import { Functions } from "../functions/Functions";
 
 export namespace Strings {
   export type Stringifiable =
diff --git a/src/internals/strings/impl/chars.ts b/src/internals/strings/impl/chars.ts
new file mode 100644
index 0000000..ba09a21
--- /dev/null
+++ b/src/internals/strings/impl/chars.ts
@@ -0,0 +1,73 @@
+// prettier-ignore
+export type ascii = {
+  " ": 32; "!": 33; '"': 34; "#": 35; $: 36; "%": 37; "&": 38; "'": 39;
+  "(": 40; ")": 41; "*": 42; "+": 43; ",": 44; "-": 45; ".": 46; "/": 47; "0": 48; "1": 49;
+  "2": 50; "3": 51; "4": 52; "5": 53; "6": 54; "7": 55; "8": 56; "9": 57; ":": 58; ";": 59;
+  "<": 60; "=": 61; ">": 62; "?": 63; "@": 64; A: 65; B: 66; C: 67; D: 68; E: 69;
+  F: 70; G: 71; H: 72; I: 73; J: 74; K: 75; L: 76; M: 77; N: 78; O: 79;
+  P: 80; Q: 81; R: 82; S: 83; T: 84; U: 85; V: 86; W: 87; X: 88; Y: 89;
+  Z: 90; "[": 91; "\\": 92; "]": 93; "^": 94; _: 95; "`": 96; a: 97; b: 98; c: 99;
+  d: 100; e: 101; f: 102; g: 103; h: 104; i: 105; j: 106; k: 107; l: 108; m: 109;
+  n: 110; o: 111; p: 112; q: 113; r: 114; s: 115; t: 116; u: 117; v: 118; w: 119;
+  x: 120; y: 121; z: 122; "{": 123; "|": 124; "}": 125; "~": 126;
+  é: 130; â: 131; ä: 132; à: 133; å: 134; ç: 135; ê: 136; ë: 137; è: 138; ï: 139;
+  î: 140; ì: 141; Ä: 142; Å: 143; É: 144; æ: 145; Æ: 146; ô: 147; ö: 148; ò: 149;
+  û: 150; ù: 151; ÿ: 152; Ö: 153; Ü: 154; ø: 155; "£": 156; Ø: 157; "×": 158; ƒ: 159;
+  á: 160; í: 161; ó: 162; ú: 163; ñ: 164; Ñ: 165; ª: 166; º: 167; "¿": 168; "®": 169;
+  "½": 171; "¼": 172; "¡": 173; "«": 174; "»": 175; "░": 176; "▒": 177; "▓": 178; "│": 179;
+  "┤": 180; Á: 181; Â: 182; À: 183; "©": 184; "╣": 185; "║": 186; "╗": 187; "╝": 188; "¢": 189;
+  "¥": 190; "┐": 191; "└": 192; "┴": 193; "┬": 194; "├": 195; "─": 196; "┼": 197; ã: 198; Ã: 199;
+  "╚": 200; "╔": 201; "╩": 202; "╦": 203; "╠": 204; "═": 205; "╬": 206; "¤": 207; ð: 208; Ð: 209;
+  Ê: 210; Ë: 211; È: 212; ı: 213; Í: 214; Î: 215; Ï: 216; "┘": 217; "┌": 218; "█": 219;
+  "▄": 220; "¦": 221; Ì: 222; "▀": 223; Ó: 224; ß: 225; Ô: 226; Ò: 227; õ: 228; Õ: 229;
+  µ: 230; þ: 231; Þ: 232; Ú: 233; Û: 234; Ù: 235; ý: 236; Ý: 237; "¯": 238; "´": 239;
+  "¬": 240; "±": 241; "‗": 242; "¾": 243; "¶": 244; "§": 245; "÷": 246; "¸": 247; "°": 248; "¨": 249;
+  "•": 250; "¹": 251; "³": 252; "²": 253; "■": 254;
+};
+
+// prettier-ignore
+export type toNextAscii = [
+  "", "", "", "", "", "","", "", "","", "", "","", "", "","", "", "","", "", "","", "", "","", "", "","", "", "", "",
+  " ", "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-", ".", "/",
+  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ":", ";", "<", "=", ">", "?",
+  "@", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O",
+  "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "[", "\\", "]", "^", "_",
+  "`", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o",
+  "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~", "", "", "",
+  "é", "â", "ä", "à", "å", "ç", "ê", "ë", "è", "ï", "î", "ì", "Ä", "Å", "É", "æ",
+  "Æ", "ô", "ö", "ò", "û", "ù", "ÿ", "Ö", "Ü", "ø", "£", "Ø", "×", "ƒ", "á", "í",
+  "ó", "ú", "ñ", "Ñ", "ª", "º", "¿", "®", "", "½", "¼", "¡", "«", "»", "░", "▒",
+  "▓", "│", "┤", "Á", "Â", "À", "©", "", "╣", "║", "╗", "╝", "¢", "¥", "┐", "└",
+  "┴", "┬", "├", "─", "┼", "ã", "Ã", "╚", "╔", "╩", "╦", "╠", "═", "╬", "¤", "ð",
+  "Ð", "Ê", "Ë", "È", "ı", "Í", "Î", "Ï", "┘", "┌", "█", "▄", "¦", "Ì", "▀", "Ó",
+  "ß", "Ô", "Ò", "õ", "Õ", "µ", "þ", "Þ", "Ú", "Û", "Ù", "ý", "Ý", "¯", "´",
+  "¬", "±", "‗", "¾", "¶", "§", "÷", "¸", "°", "¨", "•", "¹", "³", "²", "■"
+];
+
+export type toPrevAscii = ["", "", ...toNextAscii];
+
+export type toAscii = ["", ...toNextAscii];
+
+export type CharToNumber<T extends string> = T extends keyof ascii
+  ? ascii[T]
+  : 0;
+
+export type NumberToChar<T extends number> = T extends keyof toNextAscii
+  ? toAscii[T]
+  : "";
+
+export type CharNext<T extends string> = T extends keyof ascii
+  ? toNextAscii[ascii[T]]
+  : "";
+
+export type CharPrev<T extends string> = T extends keyof ascii
+  ? toPrevAscii[ascii[T]]
+  : "";
+
+export type CharRange<
+  start extends string,
+  end extends string,
+  acc extends string[] = []
+> = start extends end
+  ? [...acc, start]
+  : CharRange<CharNext<start>, end, [...acc, start]>;
diff --git a/src/internals/strings/impl/compare.ts b/src/internals/strings/impl/compare.ts
index a0ecbe1..372eee1 100644
--- a/src/internals/strings/impl/compare.ts
+++ b/src/internals/strings/impl/compare.ts
@@ -2,33 +2,7 @@ import { Call2 } from "../../core/Core";
 import { Numbers } from "../../numbers/Numbers";
 import { StringToTuple } from "./split";
 import { Equal as _Equal } from "../../helpers";
-
-// prettier-ignore
-type ascii = {
-  " ": 32; "!": 33; '"': 34; "#": 35; $: 36; "%": 37; "&": 38; "'": 39;
-  "(": 40; ")": 41; "*": 42; "+": 43; ",": 44; "-": 45; ".": 46; "/": 47; "0": 48; "1": 49;
-  "2": 50; "3": 51; "4": 52; "5": 53; "6": 54; "7": 55; "8": 56; "9": 57; ":": 58; ";": 59;
-  "<": 60; "=": 61; ">": 62; "?": 63; "@": 64; A: 65; B: 66; C: 67; D: 68; E: 69;
-  F: 70; G: 71; H: 72; I: 73; J: 74; K: 75; L: 76; M: 77; N: 78; O: 79;
-  P: 80; Q: 81; R: 82; S: 83; T: 84; U: 85; V: 86; W: 87; X: 88; Y: 89;
-  Z: 90; "[": 91; "\\": 92; "]": 93; "^": 94; _: 95; "`": 96; a: 97; b: 98; c: 99;
-  d: 100; e: 101; f: 102; g: 103; h: 104; i: 105; j: 106; k: 107; l: 108; m: 109;
-  n: 110; o: 111; p: 112; q: 113; r: 114; s: 115; t: 116; u: 117; v: 118; w: 119;
-  x: 120; y: 121; z: 122; "{": 123; "|": 124; "}": 125; "~": 126;
-  é: 130; â: 131; ä: 132; à: 133; å: 134; ç: 135; ê: 136; ë: 137; è: 138; ï: 139;
-  î: 140; ì: 141; Ä: 142; Å: 143; É: 144; æ: 145; Æ: 146; ô: 147; ö: 148; ò: 149;
-  û: 150; ù: 151; ÿ: 152; Ö: 153; Ü: 154; ø: 155; "£": 156; Ø: 157; "×": 158; ƒ: 159;
-  á: 160; í: 161; ó: 162; ú: 163; ñ: 164; Ñ: 165; ª: 166; º: 167; "¿": 168; "®": 169;
-  "½": 171; "¼": 172; "¡": 173; "«": 174; "»": 175; "░": 176; "▒": 177; "▓": 178; "│": 179;
-  "┤": 180; Á: 181; Â: 182; À: 183; "©": 184; "╣": 185; "║": 186; "╗": 187; "╝": 188; "¢": 189;
-  "¥": 190; "┐": 191; "└": 192; "┴": 193; "┬": 194; "├": 195; "─": 196; "┼": 197; ã: 198; Ã: 199;
-  "╚": 200; "╔": 201; "╩": 202; "╦": 203; "╠": 204; "═": 205; "╬": 206; "¤": 207; ð: 208; Ð: 209;
-  Ê: 210; Ë: 211; È: 212; ı: 213; Í: 214; Î: 215; Ï: 216; "┘": 217; "┌": 218; "█": 219;
-  "▄": 220; "¦": 221; Ì: 222; "▀": 223; Ó: 224; ß: 225; Ô: 226; Ò: 227; õ: 228; Õ: 229;
-  µ: 230; þ: 231; Þ: 232; Ú: 233; Û: 234; Ù: 235; ý: 236; Ý: 237; "¯": 238; "´": 239;
-  "¬": 240; "±": 241; "‗": 242; "¾": 243; "¶": 244; "§": 245; "÷": 246; "¸": 247; "°": 248; "¨": 249;
-  "•": 250; "¹": 251; "³": 252; "²": 253; "■": 254;
-};
+import { ascii } from "./chars";
 
 type CharacterCompare<
   Char1 extends string,
diff --git a/test/objects.test.ts b/test/objects.test.ts
index e903702..af67f53 100644
--- a/test/objects.test.ts
+++ b/test/objects.test.ts
@@ -137,6 +137,22 @@ describe("Objects", () => {
     type test1 = Expect<Equal<res1, { a: string; b: number }>>;
   });
 
+  it("FromArray", () => {
+    type res1 = Call<
+      //   ^?
+      Objects.FromArray,
+      ["a", string, "b", number]
+    >;
+    type test1 = Expect<Equal<res1, { a: string; b: number }>>;
+    // emptry array
+    type res2 = Call<
+      //   ^?
+      Objects.FromArray,
+      []
+    >;
+    type test2 = Expect<Equal<res2, {}>>;
+  });
+
   it("Entries", () => {
     type res1 = Call<
       //   ^?
diff --git a/test/parser.test.ts b/test/parser.test.ts
new file mode 100644
index 0000000..7e7b424
--- /dev/null
+++ b/test/parser.test.ts
@@ -0,0 +1,490 @@
+import { Equal, Expect } from "../src/internals/helpers";
+import { Parser as P } from "../src/internals/parser/Parser";
+import { Objects } from "../src/internals/objects/Objects";
+import { Tuples } from "../src/internals/tuples/Tuples";
+import {
+  arg0,
+  arg1,
+  Call,
+  ComposeLeft,
+  Constant,
+  Eval,
+  Identity,
+} from "../src/internals/core/Core";
+import { Strings } from "../src/internals/strings/Strings";
+import { Numbers as N } from "../src/internals/numbers/Numbers";
+import { Match } from "../src/internals/match/Match";
+
+describe("Parser", () => {
+  describe("P.Literal", () => {
+    it("should parse a literal", () => {
+      type res1 = Eval<P.Parse<P.Literal<"hello">, "hello">>;
+      //   ^?
+      type test1 = Expect<Equal<res1, "hello">>;
+      type res2 = Eval<P.Parse<P.Literal<"hello">, "hello world">>;
+      //   ^?
+      type test2 = Expect<Equal<res2, "hello">>;
+    });
+
+    it("should not parse another literal", () => {
+      type res1 = Eval<P.Parse<P.Literal<"hello">, "world">>;
+      //   ^?
+      type test1 = Expect<
+        Equal<
+          res1,
+          {
+            message: "Expected 'literal('hello')' - Received 'world'";
+            input: "world";
+            cause: "";
+          }
+        >
+      >;
+    });
+
+    it("should not parse an empty string", () => {
+      type res1 = Eval<P.Parse<P.Literal<"hello">, "">>;
+      //   ^?
+      type test1 = Expect<
+        Equal<
+          res1,
+          {
+            message: "Expected 'literal('hello')' - Received ''";
+            input: "";
+            cause: "";
+          }
+        >
+      >;
+    });
+  });
+
+  describe("P.Word", () => {
+    it("should parse a word", () => {
+      type res1 = Eval<P.Parse<P.Word, "hello">>;
+      //   ^?
+      type test1 = Expect<Equal<res1, "hello">>;
+      type res2 = Eval<P.Parse<P.Word, "hello world">>;
+      //   ^?
+      type test2 = Expect<Equal<res2, "hello">>;
+      type res3 = Eval<P.Parse<P.Word, "hello_world">>;
+      //   ^?
+      type test3 = Expect<Equal<res3, "hello_world">>;
+      type res4 = Eval<P.Parse<P.Word, "hello-world">>;
+      //   ^?
+      type test4 = Expect<Equal<res4, "hello">>;
+      type res5 = Eval<P.Parse<P.Word, "_42">>;
+      //   ^?
+      type test5 = Expect<Equal<res5, "_42">>;
+      type res6 = Eval<P.Parse<P.Word, "42">>;
+      //   ^?
+      type test6 = Expect<
+        Equal<
+          res6,
+          {
+            message: "Expected 'word()' - Received '42'";
+            input: "42";
+            cause: "";
+          }
+        >
+      >;
+    });
+    it("should not parse and empty string", () => {
+      type res1 = Eval<P.Parse<P.Word, "">>;
+      //   ^?
+      type test1 = Expect<
+        Equal<
+          res1,
+          { message: "Expected 'word()' - Received ''"; input: ""; cause: "" }
+        >
+      >;
+    });
+  });
+
+  describe("P.Digits", () => {
+    it("should parse digits", () => {
+      type res1 = Eval<P.Parse<P.Digits, "42">>;
+      //   ^?
+      type test1 = Expect<Equal<res1, "42">>;
+      type res2 = Eval<P.Parse<P.Digits, "42hello">>;
+      //   ^?
+      type test2 = Expect<Equal<res2, "42">>;
+      type res3 = Eval<P.Parse<P.Digits, "hello">>;
+      //   ^?
+      type test3 = Expect<
+        Equal<
+          res3,
+          {
+            message: "Expected 'digits()' - Received 'hello'";
+            input: "hello";
+            cause: "";
+          }
+        >
+      >;
+    });
+
+    it("should not parse and empty string", () => {
+      type res1 = Eval<P.Parse<P.Digits, "">>;
+      //   ^?
+      type test1 = Expect<
+        Equal<
+          res1,
+          { message: "Expected 'digits()' - Received ''"; input: ""; cause: "" }
+        >
+      >;
+    });
+  });
+
+  describe("P.Parse", () => {
+    it("should parse complex grammar and allow to transform it", () => {
+      type res1 = Eval<
+        //  ^?
+        P.Parse<
+          P.Map<
+            P.Sequence<
+              [
+                P.Skip<P.Literal<"function">>,
+                P.Trim<P.Word>,
+                P.Between<
+                  P.Literal<"(">,
+                  P.SepBy<P.Trim<P.Word>, P.Literal<",">>,
+                  P.Literal<")">
+                >,
+                P.Skip<P.Literal<";">>,
+                P.EndOfInput
+              ]
+            >,
+            Objects.Create<{
+              type: "function";
+              name: Tuples.At<0>;
+              parameters: Tuples.Drop<1>;
+            }>
+          >,
+          `function test ( aaaaa, hello_  ,  allo  );`
+        >
+      >;
+      type test1 = Expect<
+        Equal<
+          res1,
+          {
+            type: "function";
+            name: "test";
+            parameters: ["aaaaa", "hello_", "allo"];
+          }
+        >
+      >;
+    });
+
+    it("should parse a calculator grammar", () => {
+      // The grammar is defined as a recursive grammar:
+      // ---------------------------------------------
+      // | Expr = Added (AddOp Added)*               |
+      // | Added = Multiplied (MulOp Multipled)*     |
+      // | Multiplied = (Expr) | Integer             |
+      // | AddOp = + | -                             |
+      // | MulOp = * | /                             |
+      // ---------------------------------------------
+
+      type MulOp = P.Literal<"*" | "/">;
+      type AddOp = P.Literal<"+" | "-">;
+      type Integer = P.Map<
+        P.Trim<P.Digits>,
+        ComposeLeft<[Tuples.At<0>, Strings.ToNumber]>
+      >;
+      type Multiplied = P.Choice<
+        [
+          P.Between<P.Trim<P.Literal<"(">>, Expr, P.Trim<P.Literal<")">>>,
+          Integer
+        ]
+      >;
+      type Added = P.Map<
+        P.Sequence<[Multiplied, P.Many<P.Sequence<[MulOp, Multiplied]>>]>,
+        Match<
+          [
+            Match.With<[arg0, "*", arg1], N.Mul>,
+            Match.With<[arg0, "/", arg1], N.Div>,
+            Match.With<arg0, Identity>
+          ]
+        >
+      >;
+      type Expr = P.Map<
+        P.Sequence<[Added, P.Many<P.Sequence<[AddOp, Added]>>]>,
+        Match<
+          [
+            Match.With<[arg0, "+", arg1], N.Add>,
+            Match.With<[arg0, "-", arg1], N.Sub>,
+            Match.With<arg0, Identity>
+          ]
+        >
+      >;
+      type Calc<T extends string> = Eval<
+        P.Parse<P.Map<P.Sequence<[Expr, P.EndOfInput]>, Tuples.At<0>>, T>
+      >;
+
+      type res1 = Calc<"( 3*2 ) / ( 4/2 ) - 2">;
+      //   ^?
+      type test1 = Expect<Equal<res1, 1>>;
+      type res2 = Calc<"3*(2-5)">;
+      //   ^?
+      type test2 = Expect<Equal<res2, -9>>;
+      type res3 = Calc<"3*(2-5">;
+      //   ^?
+      type test3 = Expect<
+        Equal<
+          res3,
+          {
+            message: "Expected 'endOfInput()' - Received '*(2-5'";
+            input: "*(2-5";
+            cause: "";
+          }
+        >
+      >;
+    });
+
+    it("should parse json grammar", () => {
+      // The grammar is defined as a recursive grammar:
+      // -------------------------------------------------------------
+      // | Value = Object | Array | String | Number | Boolean | Null |
+      // | Object = { (Pair (, Pair)*)? }                            |
+      // | Pair = String : Value                                     |
+      // | Array = [ (Value (, Value)*)? ]                           |
+      // | String = " Character* "                                   |
+      // | Character = any character except "                        |
+      // | Number = -? Digits ( . Digits )?                          |
+      // | Boolean = true | false                                    |
+      // | Null = null                                               |
+      // -------------------------------------------------------------
+      type Value = P.Choice<
+        [JSonObject, JSonArray, JSonString, JSonNumber, JsonBoolean, JSonNull]
+      >;
+      type JSonObject = P.Map<
+        P.Sequence<
+          [
+            P.Trim<P.Skip<P.Literal<"{">>>,
+            P.Optional<P.SepBy<JSonPair, P.Trim<P.Literal<",">>>>,
+            P.Trim<P.Skip<P.Literal<"}">>>
+          ]
+        >,
+        Objects.FromArray
+      >;
+      type JSonPair = P.Sequence<
+        [JSonString, P.Trim<P.Skip<P.Literal<":">>>, Value]
+      >;
+      type JSonArray = P.Map<
+        P.Sequence<
+          [
+            P.Trim<P.Skip<P.Literal<"[">>>,
+            P.Optional<P.SepBy<Value, P.Trim<P.Literal<",">>>>,
+            P.Trim<P.Skip<P.Literal<"]">>>
+          ]
+        >,
+        Objects.Create<[arg0]>
+      >;
+
+      type JSonString = P.Map<
+        P.Between<
+          P.TrimLeft<P.Skip<P.Literal<'"'>>>,
+          P.Many<P.NotLiteral<'"'>>,
+          P.TrimRight<P.Skip<P.Literal<'"'>>>
+        >,
+        Tuples.Join<"">
+      >;
+
+      type JSonNumber = P.Map<
+        P.Sequence<
+          [
+            P.Optional<P.Literal<"-" | "+">>,
+            P.Digits,
+            P.Optional<P.Sequence<[P.Literal<".">, P.Digits]>>
+          ]
+        >,
+        ComposeLeft<[Tuples.Join<"">, Strings.ToNumber]>
+      >;
+      type JsonBoolean = P.Map<
+        P.Literal<"true" | "false">,
+        Match<[Match.With<"true", true>, Match.With<"false", false>]>
+      >;
+      type JSonNull = P.Map<P.Literal<"null">, Constant<null>>;
+
+      type Json<T extends string> = Eval<
+        P.Parse<P.Map<P.Sequence<[Value, P.EndOfInput]>, Tuples.At<0>>, T>
+      >;
+
+      type res1 = Json<`{"hello": " world! with @", "foo": [1.4, 2, 3]}`>;
+      //   ^?
+      type test1 = Expect<
+        Equal<res1, { hello: " world! with @"; foo: [1.4, 2, 3] }>
+      >;
+      type res2 = Json<`[]`>;
+      //   ^?
+      type test2 = Expect<Equal<res2, []>>;
+      type res3 = Json<`{}`>;
+      //   ^?
+      type test3 = Expect<Equal<res3, {}>>;
+      // 4 deep nested objects
+      type res4 = Json<`{"a": {"b": {"c": {"d": 8}}}}`>;
+      //   ^?
+      type test4 = Expect<Equal<res4, { a: { b: { c: { d: 8 } } } }>>;
+    });
+  });
+
+  it("should parse regex grammar", () => {
+    // The grammar is defined as a recursive grammar for Extended Regular Expressions:
+    // -------------------------------------------------------------
+    // | ERE = ERE_branch (| ERE_branch)*
+    // | ERE_branch = ERE_expr+
+    // | ERE_expr = ERE_term ERE_quant*
+    // | ERE_term = ERE_atom | ERE_group | ERE_assertion
+    // | ERE_atom = ERE_char | ERE_quoted_char | . | ERE_char_class | \d | \D | \s | \S | \w | \W | \t | \r | \v | \f | \n
+    // | ERE_group = ( ERE ) | (?<name> ERE ) | (?: ERE ) | \ Digit | \k<name>
+    // | ERE_assertion = ^ | $ | \b | \B | (?= ERE ) | (?! ERE ) | (?<= ERE ) | (?<! ERE )
+    // | ERE_char = any char exept ^ . [ $ ( ) | * + ? { \
+    // | ERE_any_char_class = any char exept ]
+    // | ERE_quoted_char = one of the following char sequences: \^ \. \[ \$ \( \) \| \* \+ \? \{ \\
+    // | ERE_quant = * | + | ? | { Digits } | { Digits , } | { Digits , Digits }
+    // | ERE_char_class = [ ERE_char_class_expr+ ] | [^ ERE_char_class_expr+ ]
+    // | ERE_char_class_expr = ERE_range | ERE_any_char_class
+    // | ERE_range = ERE_char - ERE_char
+    // | name = word
+    // -------------------------------------------------------------
+
+    type ERE = P.Choice<[ERE_branch, P.SepBy<ERE_branch, P.Literal<"|">>]>;
+    type ERE_branch = P.Many<ERE_expr>;
+    type ERE_expr = P.Sequence<[ERE_term, P.Many<ERE_quant>]>;
+    type ERE_term = P.Choice<[ERE_atom, ERE_group, ERE_assertion]>;
+    type ERE_atom = P.Choice<
+      [
+        ERE_char,
+        ERE_quoted_char,
+        // prettier-ignore
+        P.Literal<"." | "\\d" | "\\D" | "\\s" | "\\S" | "\\w" | "\\W" | "\\t" | "\\r" | "\\v" | "\\f" | "\\n">,
+        ERE_char_class
+      ]
+    >;
+    type ERE_group = P.Choice<
+      [
+        P.Between<P.Literal<"(">, ERE, P.Literal<")">>,
+        P.Between<P.Literal<"(?<">, ERE, P.Literal<")">>,
+        P.Between<P.Literal<"(?:">, ERE, P.Literal<")">>,
+        P.Sequence<[P.Literal<"\\">, P.Digits]>,
+        P.Sequence<[P.Literal<"\\k<">, P.Word, P.Literal<">">]>
+      ]
+    >;
+    type ERE_assertion = P.Choice<
+      [
+        P.Literal<"^" | "$" | "\\b" | "\\B">,
+        P.Between<P.Literal<"(?=">, ERE, P.Literal<")">>,
+        P.Between<P.Literal<"(?!">, ERE, P.Literal<")">>,
+        P.Between<P.Literal<"(?<=">, ERE, P.Literal<")">>,
+        P.Between<P.Literal<"(?<!">, ERE, P.Literal<")">>
+      ]
+    >;
+    // prettier-ignore
+    type ERE_char = P.NotLiteral<"^" | "." | "[" | "$" | "(" | ")" | "|" | "*" | "+" | "?" | "{" | "\\" | "]" | "-">;
+    type ERE_any_char_class = P.NotLiteral<"]">;
+    // prettier-ignore
+    type ERE_quoted_char = P.Literal<
+      "\\^" | "\\." | "\\[" | "\\$" | "\\(" | "\\)" | "\\|" | "\\*" | "\\+" | "\\?" | "\\{" | "\\\\"
+    >;
+    type ERE_quant = P.Choice<
+      [
+        P.Literal<"*" | "+" | "?">,
+        P.BetweenLiterals<"{", P.Digits, "}">,
+        P.Sequence<[P.Literal<"{">, P.Digits, P.Literal<",">, P.Literal<"}">]>,
+        P.Sequence<
+          [P.Literal<"{">, P.Digits, P.Literal<",">, P.Digits, P.Literal<"}">]
+        >
+      ]
+    >;
+    type ERE_char_class = P.Choice<
+      [
+        P.Between<P.Literal<"[">, P.Many<ERE_char_class_expr>, P.Literal<"]">>,
+        P.Between<P.Literal<"[^">, P.Many<ERE_char_class_expr>, P.Literal<"]">>
+      ]
+    >;
+    type ERE_char_class_expr = P.Choice<[ERE_range, ERE_any_char_class]>;
+    type ERE_range = P.Sequence<[ERE_char, P.Literal<"-">, ERE_char]>;
+
+    type RegExpr<T extends string> = Eval<
+      P.Parse<P.Sequence<[ERE, P.EndOfInput]>, T>
+    >;
+
+    type test1 = RegExpr<"a+[a-zA-Z]">;
+  });
+
+  it("should parse complex endpoint routing grammar", () => {
+    // examples route:
+    // /api/v1/users/{id:number}/posts/{postId:number}/comments/{commentId:number}
+    // /api/v2/emails/{email:string}/lists/{listEmail:string}
+
+    // The grammar is defined as a recursive grammar for routing paths.
+    // -------------------------------------------------------------
+    // | path = path_segment ( / path_segment )*
+    // | path_segment = path_parameter | path_literal
+    // | path_parameter = { name : type } | { name }
+    // | path_literal = word
+    // | name = word
+    // | type = string | number | boolean
+    // -------------------------------------------------------------
+
+    type path = P.Map<
+      P.PrefixByLiteral<"/", P.SepByLiteral<path_segment, "/">>,
+      Objects.FromArray
+    >;
+    type path_segment = P.Choice<[path_parameter, P.Skip<P.Word>]>;
+    type path_parameter = P.BetweenLiterals<
+      "{",
+      P.Sequence<
+        [
+          P.Trim<P.Word>,
+          P.Map<
+            P.Optional<P.PrefixByLiteral<":", type>>,
+            Match<
+              [
+                Match.With<["string"], string>,
+                Match.With<["number"], number>,
+                Match.With<["boolean"], boolean>,
+                Match.With<any, string>
+              ]
+            >
+          >
+        ]
+      >,
+      "}"
+    >;
+    type type = P.Trim<P.Literal<"string" | "number" | "boolean">>;
+
+    type PathParams<T extends string> = Eval<
+      P.Parse<P.Map<P.Sequence<[path, P.EndOfInput]>, Tuples.At<0>>, T>
+    >;
+
+    // should allow to cast to number or boolean
+    type res1 =
+      //  ^?
+      PathParams<"/api/v1/users/{ id : number }/posts/{postId:number}/comments/{commentId:number}/active/{active:boolean}">;
+    type test1 = Expect<
+      Equal<
+        res1,
+        { id: number; postId: number; commentId: number; active: boolean }
+      >
+    >;
+
+    // should default to string
+    type res2 = PathParams<"/api/v2/emails/{email}/lists/{listEmail}">;
+    //    ^?
+    type test2 = Expect<Equal<res2, { email: string; listEmail: string }>>;
+
+    // should error
+    type res3 =
+      //  ^?
+      PathParams<"/api/v2/emails/{email:string}/lists/{listEmail:string">;
+    type test3 = Expect<
+      Equal<
+        res3,
+        {
+          message: never;
+          input: "{listEmail:string";
+          cause: "Expected 'literal('}')' - Received '' | Expected 'word()' - Received '{listEmail:string'";
+        }
+      >
+    >;
+  });
+});