Tag

Index

Interfaces

• Module
• Parameters

Functions

• define

Interfaces

Module

• Module(value: From): To

• Convert an underlying type to a tagged type Alias to wrap(value)

typeName

Re-exports typeName

__call__

__call__: (value: From) => To

Inherited from Callable.__call__

Callable property

__inspect__

__inspect__: Option<(anyValue: To, depth: number, options: InspectOptions, inspect: InspectFunction) => string>

Inherited from Module.__inspect__

When defined, returns a custom string representation. To be useful, it should be bound to a prototype (ex: Struct)

@example

import { inspect } from 'node:util';

interface Foo {
  foo: boolean;
}
const Foo = Struct.define<Foo>({
  typeName: 'Foo',
  __inspect__: (self) => `Foo { ${String(self.foo)} }`,
});
const myStruct = Struct.create(Foo, { foo: true });// 'Foo { true }'
inspect(myStruct);// 'Foo { true }'

@param

__decode__

• __decode__(this: void, input: unknown, context: Context<To>): Result<To, CodecError>

• Inherited from Module.__decode__

  Returns the decoded input, Result.Ok or Result.Error()

  @example

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const input: unknown = ...;
  const decoded = Codec.decode(someCodec, input);

__encode__

• __encode__(this: void, input: To): unknown

• Inherited from Module.__encode__

  Returns the encoded input

  @example

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const someObject: SomeObject = { foo: "bar" }
  const encoded = Codec.decode(someCodec, someObject);

__schema__

• __schema__(this: void): JSONValue

• Inherited from Module.__schema__

  Returns the JSONSchema corresponding to the decoded type

  @example

  const someCodec: Codec<unknown> = ...;
  const jsonSchema = Codec.schema(someCodec);

asInstance

• asInstance(anyValue: unknown): Option<To>

• Inherited from Module.asInstance

  Try to convert anyValue to enum value or else returns Option.None

  @example

  const StringType: Type<string>;
  StringType.asInstance('foo'); // Option.Some('foo')
  StringType.asInstance(12); // Option.None

asString

• asString(this: void, self: To): string

• Inherited from Module.asString

  Converts the given value to a String.

  @example

  Number.asString(123); // '123'

hasInstance

• hasInstance(anyValue: unknown): anyValue is To

• Inherited from Module.hasInstance

  Return true if the given value is an instance of the class.

  @example

  const StringType: Type<string>;
  StringType.hasInstance('foo'); // true
  StringType.hasInstance(42); // false

unwrap

• unwrap(value: To): From

• Convert a tagged value to the underlying type

wrap

• wrap(value: From): To

• Convert an underlying type to a tagged type

Parameters

Parameters<T>:

Type module constructor parameters

---

Type parameters

• T

optional__inspect__

__inspect__?: Option<(anyValue: T, depth: number, options: InspectOptions, inspect: InspectFunction) => string>

Inherited from Parameters.__inspect__

When defined, returns a custom string representation. To be useful, it should be bound to a prototype (ex: Struct)

@example

import { inspect } from 'node:util';

interface Foo {
  foo: boolean;
}
const Foo = Struct.define<Foo>({
  typeName: 'Foo',
  __inspect__: (self) => `Foo { ${String(self.foo)} }`,
});
const myStruct = Struct.create(Foo, { foo: true });// 'Foo { true }'
inspect(myStruct);// 'Foo { true }'

@param

hasInstance

hasInstance: (value: unknown) => boolean

Inherited from Parameters.hasInstance

typeName

typeName: string

Inherited from Parameters.typeName

Type string representation

@example

StringType.typeName // 'String'
Int.typeName // 'Int'
Person.typeName // 'Person'

optional__decode__

• __decode__(this: void, input: unknown, context: Context<T>): Result<T, CodecError>

• Inherited from Parameters.__decode__

  Returns the decoded input, Result.Ok or Result.Error()

  @example

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const input: unknown = ...;
  const decoded = Codec.decode(someCodec, input);

optional__encode__

• __encode__(this: void, input: T): unknown

• Inherited from Parameters.__encode__

  Returns the encoded input

  @example

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const someObject: SomeObject = { foo: "bar" }
  const encoded = Codec.decode(someCodec, someObject);

optional__schema__

• __schema__(this: void): JSONValue

• Inherited from Parameters.__schema__

  Returns the JSONSchema corresponding to the decoded type

  @example

  const someCodec: Codec<unknown> = ...;
  const jsonSchema = Codec.schema(someCodec);

optionalasInstance

• asInstance(anyValue: unknown): Option<T>

• Inherited from Parameters.asInstance

  Try to convert anyValue to enum value or else returns Option.None

  @example

  const StringType: Type<string>;
  StringType.asInstance('foo'); // Option.Some('foo')
  StringType.asInstance(12); // Option.None

optionalasString

• asString(this: void, self: T): string

• Inherited from Parameters.asString

  Converts the given value to a String.

  @example

  Number.asString(123); // '123'

Functions

define

• define<From, To>(parameters: Parameters<To>): Tag.Module<From, To>

• Returns a new Tag module

  @example

  type Foo = string & Tag<'Foo'>;
  const Foo = Tag.define<string, Foo>({
    typeName: 'Foo',
    hasInstance: (anyValue) => typeof anyValue === 'string',
  });

  ---

  Type parameters

  • From
  • To