PureParse

Appearance

Failure ​

ts
type Failure: {
  message: string;
  path: PathSegment[];
};

Type declaration ​

message ​

ts
message: string;

path ​

ts
path: PathSegment[];

ParseFailure ​

ts
type ParseFailure: {
  error: Failure;
  tag: "failure";
};

The parsing failed.

Type declaration ​

error ​

ts
error: Failure;

tag ​

ts
tag: "failure";

ParseResult<T> ​

ts
type ParseResult<T>: ParseSuccess<T> | ParseFailure;

Describes the result of a parsing operation. The tag and error properties can be used to distinguish between success and failure.

Type Parameters ​

Type Parameter
T

Examples ​

Use error to distinguish between success and failure:

ts
const result = parseNumber(data)
if(result.error) {
  console.error(formatResult(result))
  return
}
console.log(result.value)

Use tag to distinguish between success and failure:

ts
const result = parseNumber(data)
switch (result.tag) {
  case 'failure':
   console.error(formatResult(result))
   break
  case 'success':
   console.log(result.value)
   break

***

## ParseSuccess\<T\>

```ts
type ParseSuccess<T>: {
  error: never;
  tag: "success";
  value: T;
};

The data adheres to the schema. The value is equal to the parsed data

Type Parameters ​

Type Parameter
T

Type declaration ​

error? ​

ts
optional error: never;

tag ​

ts
tag: "success";

value ​

ts
value: T;

PathSegment ​

ts
type PathSegment: {
  key: string;
  tag: "object";
 } | {
  index: number;
  tag: "array";
};

Describes the path in a data structure where parsing failed.

failure() ​

ts
function failure(message): ParseFailure

Create a failure parsing result.

Example ​

ts
const customParser: Parser<number> = (data) => {
  if (typeof data === 'number') {
   return success(data)
  }
  return failure('Expected a number')
}

Parameters ​

ParameterTypeDescription
messagestring

Returns ​

ParseFailure

isFailure() ​

ts
function isFailure<T>(result): result is ParseFailure

Check if the result is a failure

Type Parameters ​

Type Parameter
T

Parameters ​

ParameterTypeDescription
resultParseResult<T>

Returns ​

result is ParseFailure

isSuccess() ​

ts
function isSuccess<T>(result): result is ParseSuccess<T>

Check if the result is a success

Type Parameters ​

Type Parameter
T

Parameters ​

ParameterTypeDescription
resultParseResult<T>

Returns ​

result is ParseSuccess<T>

propagateFailure() ​

ts
function propagateFailure(failureRes, pathSegment): ParseFailure

Propagate a failure result in a nested structure. When parsing objects and arrays with nested values, the failure at the root level should convey where in the hierarchy the failure occurred.

Parameters ​

ParameterTypeDescription
failureResParseFailure
pathSegmentPathSegment

Returns ​

ParseFailure

success() ​

ts
function success<T>(value): ParseSuccess<T>

Create a successful parsing result.

Example ​

ts
const customParser: Parser<number> = (data) => {
  if (typeof data === 'number') {
   return success(data)
  }
  return failure('Expected a number')
}
@param value

### Type Parameters

| Type Parameter |
| ------ |
| `T` |

### Parameters

| Parameter | Type |
| ------ | ------ |
| `value` | `T` |

### Returns

[`ParseSuccess`](ParseResult.md#parsesuccesst)\<`T`\>