Ts.Assert.parameters.sub

Import

Namespace

import { Ts } from '@wollybeard/kit'

// Access via namespace
Ts.Assert.parameters.sub

Barrel

import { sub } from '@wollybeard/kit/ts'

Functions

[F] noExcessAs

<$Type>(): DispatchAfterInput<State.SetExpectedType<State.SetRelator<State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>, SubNoExcessKind>, $Type>>

[F] ofAs

<$Type>(): DispatchAfterInput<State.SetExpectedType<State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>, $Type>>

Constants

[C] any

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetAllowAny<
      State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>
    >,
    any
  >
>

[C] bigint

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>,
    bigint
  >
>

[C] boolean

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>,
    boolean
  >
>

[C] Date

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>,
    Date
  >
>

[C] Error

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>,
    Error
  >
>

[C] never

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetAllowNever<
      State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>
    >,
    never
  >
>

[C] noExcess

InputExpectedAsValueNarrow<
  State.SetRelator<
    State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>,
    SubNoExcessKind
  >
>

[C] null

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>,
    null
  >
>

[C] number

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>,
    number
  >
>

[C] of

InputExpectedAsValueNarrow<
  State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>
>

[C] RegExp

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>,
    RegExp
  >
>

[C] string

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>,
    string
  >
>

[C] symbol

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>,
    symbol
  >
>

[C] undefined

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>,
    undefined
  >
>

[C] unknown

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetAllowUnknown<
      State.SetRelator<State.AddExtractor<State.Empty, Parameters$>, SubKind>
    >,
    unknown
  >
>

Types

[T] any

type any_<$Actual> = Kind.Apply<
  SubKind,
  [any, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for any. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.any<(...args: any[]) => any>

// ✗ Fail
type _ = Assert.parameters.sub.any<(...args: any[]) => string>

[T] bigint

type bigint_<$Actual> = Kind.Apply<
  SubKind,
  [bigint, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for bigint. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.bigint<(...args: any[]) => bigint>

// ✗ Fail
type _ = Assert.parameters.sub.bigint<(...args: any[]) => string>

[T] boolean

type boolean_<$Actual> = Kind.Apply<
  SubKind,
  [boolean, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for boolean. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.boolean<(...args: any[]) => boolean>

// ✗ Fail
type _ = Assert.parameters.sub.boolean<(...args: any[]) => string>

[T] Date

type Date_<$Actual> = Kind.Apply<
  SubKind,
  [Date, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for Date. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.Date<(...args: any[]) => Date>

// ✗ Fail
type _ = Assert.parameters.sub.Date<(...args: any[]) => string>

[T] Error

type Error_<$Actual> = Kind.Apply<
  SubKind,
  [Error, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for Error. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.Error<(...args: any[]) => Error>

// ✗ Fail
type _ = Assert.parameters.sub.Error<(...args: any[]) => string>

[T] never

type never_<$Actual> = Kind.Apply<
  SubKind,
  [never, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for never. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.never<(...args: any[]) => never>

// ✗ Fail
type _ = Assert.parameters.sub.never<(...args: any[]) => string>

[T] noExcess

type noExcess_<$Expected, $Actual> = Kind.Apply<
  SubNoExcessKind,
  [$Expected, Kind.Apply<Path.Parameters$, [$Actual]>]
>

No-excess variant of sub relation. Checks that actual has no excess properties beyond expected.

[T] null

type null_<$Actual> = Kind.Apply<
  SubKind,
  [null, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for null. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.null<(...args: any[]) => null>

// ✗ Fail
type _ = Assert.parameters.sub.null<(...args: any[]) => string>

[T] number

type number_<$Actual> = Kind.Apply<
  SubKind,
  [number, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for number. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.number<(...args: any[]) => number>

// ✗ Fail
type _ = Assert.parameters.sub.number<(...args: any[]) => string>

[T] of

type of_<$Expected, $Actual> = Kind.Apply<
  SubKind,
  [$Expected, Kind.Apply<Path.Parameters$, [$Actual]>]
>

parameters + sub relation matchers.

Extraction: extracts the parameters tuple from a function Relation: subtype relation (extends)

[T] RegExp

type RegExp_<$Actual> = Kind.Apply<
  SubKind,
  [RegExp, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for RegExp. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.RegExp<(...args: any[]) => RegExp>

// ✗ Fail
type _ = Assert.parameters.sub.RegExp<(...args: any[]) => string>

[T] string

type string_<$Actual> = Kind.Apply<
  SubKind,
  [string, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for string. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.string<(...args: any[]) => string>

// ✗ Fail
type _ = Assert.parameters.sub.string<(...args: any[]) => number>

[T] symbol

type symbol_<$Actual> = Kind.Apply<
  SubKind,
  [symbol, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for symbol. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.symbol<(...args: any[]) => symbol>

// ✗ Fail
type _ = Assert.parameters.sub.symbol<(...args: any[]) => string>

[T] undefined

type undefined_<$Actual> = Kind.Apply<
  SubKind,
  [undefined, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for undefined. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.undefined<(...args: any[]) => undefined>

// ✗ Fail
type _ = Assert.parameters.sub.undefined<(...args: any[]) => string>

[T] unknown

type unknown_<$Actual> = Kind.Apply<
  SubKind,
  [unknown, Kind.Apply<Path.Parameters$, [$Actual]>]
>

Pre-curried matcher for unknown. Extraction chain: (...args: any[]) = T → Parameters

Examples:

// ✓ Pass
type _ = Assert.parameters.sub.unknown<(...args: any[]) => unknown>

// ✗ Fail
type _ = Assert.parameters.sub.unknown<(...args: any[]) => string>