matches.Parser | /mod.ts | embassyd_sdk@v0.3.3.0.4

class matches.Parser

implements IParser<A, B>

Re-export

import { matches } from "https://deno.land/x/embassyd_sdk@v0.3.3.0.4/mod.ts";
const { Parser } = matches;

A Parser is usually a function that takes a value and returns a Parsed value. For this class we have that as our main reason but we want to be able to have other methods including testing and showing text representations.

The main function unsafeCast which will take in a value A (usually unknown) and will always return a B. If it cannot it will throw an error.

The parse function is the lower level function that will take in a value and a dictionary of what to do with success and failure.

Constructors

new

Parser(parser: IParser<A, B>, description?)

Type Parameters

Properties

readonly

_TYPE: B

test: (value: A) => value is A & B

Use this as a guard clause, useful for escaping during the error cases. https://www.typescriptlang.org/docs/handbook/advanced-types.html#type-guards-and-differentiating-types

Methods

castPromise(value: A): Promise<B>

This is the like the unsafe parser, it assumes the happy path and will throw and return a failed promise during failure.

concat<C>(otherParser: IParser<B, C>): Parser<A, C>

Use this when you want to combine two parsers into one. This will make sure that both parsers will run against the same value.

defaultTo<C>(defaultValue: C): Parser<Optional<A>, C | NonNull<B, C>>

There are times that we would like to bring in a value that we know as null or undefined and want it to go to a default value

enumParsed(value: A): { value: B; } | { error: ISimpleParsedError; }

This is another type of parsing that will return a value that is a discriminated union of the success and failure cases. https://www.typescriptlang.org/docs/handbook/typescript-in-5-minutes-func.html#discriminated-unions

errorMessage(input: A): void | string

When we want to get the error message from the input, to know what is wrong

map<C>(fn: (apply: B) => C, mappingName?: string): Parser<A, C>

Use this that we want to do transformations after the value is valid and parsed. A use case would be parsing a string, making sure it can be parsed to a number, and then convert to a number

name(nameString: string): Parser<A, B>

Use this when we want to give the parser a name, and we want to be able to use the name in the error messages.

optional(name?: string): Parser<Optional<A>, Optional<B>>

When we want to make sure that we handle the null later on in a monoid fashion, and this ensures we deal with the value https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#optional-chaining

orParser<C>(otherParser: IParser<A, C>): Parser<A, B | C>

Use this to combine parsers into one. This will make sure that one or the other parsers will run against the value.

parse<C, D>(a: A, onParse: OnParse<A, B, C, D>): C | D

Use this when you want to decide what happens on the succes and failure cases of parsing

refine<C = B>(refinementTest: (value: B) => value is B & C, otherName?: string): Parser<A, B & C>

We want to refine to a new type given an original type, like isEven, or casting to a more specific type

unsafeCast(value: A): B

This is the most useful parser, it assumes the happy path and will throw an error if it fails.

unwrappedParser()

Return the unwrapped parser/ IParser

validate(isValid: (value: B) => boolean, otherName: string): Parser<A, B>

We want to test value with a test eg isEven

Static Properties

validatorErrorAsString: <A, B>(error: ISimpleParsedError) => string

This is the line of code that could be over written if One would like to have a custom error as any shape

Static Methods

isA<A, B extends A>(checkIsA: (value: A) => value is B, name: string): Parser<A, B>

This is a constructor helper that can use a predicate tester in the form of a guard function, and will return a parser that will only parse if the predicate returns true. https://www.typescriptlang.org/docs/handbook/advanced-types.html#type-guards-and-differentiating-types

parserAsString(parserComingIn: IParser<unknown, unknown>): string

Trying to convert the parser into a string representation