Ts.Assert.array.not.exact

Import

NamespaceBarrel

typescript

import { Ts } from '@wollybeard/kit'

// Access via namespace
Ts.Assert.array.not.exact

typescript

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

Functions

`[F]` `ofAs`

typescript

<$Type>(): DispatchAfterInput<State.SetExpectedType<State.SetRelator<State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>, ExactKind>, $Type>>

Constants

`[C]` `any`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetAllowAny<
      State.SetRelator<
        State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
        ExactKind
      >
    >,
    any
  >
>

`[C]` `bigint`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
      ExactKind
    >,
    bigint
  >
>

`[C]` `boolean`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
      ExactKind
    >,
    boolean
  >
>

`[C]` `Date`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
      ExactKind
    >,
    Date
  >
>

`[C]` `Error`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
      ExactKind
    >,
    Error
  >
>

`[C]` `never`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetAllowNever<
      State.SetRelator<
        State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
        ExactKind
      >
    >,
    never
  >
>

`[C]` `noExcess`

typescript

never

`[C]` `null`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
      ExactKind
    >,
    null
  >
>

`[C]` `number`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
      ExactKind
    >,
    number
  >
>

`[C]` `of`

typescript

InputExpectedAsValueNarrow<
  State.SetRelator<
    State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
    ExactKind
  >
>

`[C]` `RegExp`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
      ExactKind
    >,
    RegExp
  >
>

`[C]` `string`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
      ExactKind
    >,
    string
  >
>

`[C]` `symbol`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
      ExactKind
    >,
    symbol
  >
>

`[C]` `undefined`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetRelator<
      State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
      ExactKind
    >,
    undefined
  >
>

`[C]` `unknown`

typescript

InputActualAsValueNarrow<
  State.SetExpectedType<
    State.SetAllowUnknown<
      State.SetRelator<
        State.SetNegated<State.AddExtractor<State.Empty, ArrayElement>>,
        ExactKind
      >
    >,
    unknown
  >
>

Types

`[T]` `any`

typescript

type any_<$Actual> = Kind.Apply<
  ExactKind,
  [any, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for any. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.any
<any[]>

// ✗ Fail
type _
 = Assert.array.exact.any
<string[]>

`[T]` `bigint`

typescript

type bigint_<$Actual> = Kind.Apply<
  ExactKind,
  [bigint, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for bigint. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.bigint
<bigint[]>

// ✗ Fail
type _
 = Assert.array.exact.bigint
<string[]>

`[T]` `boolean`

typescript

type boolean_<$Actual> = Kind.Apply<
  ExactKind,
  [boolean, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for boolean. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.boolean
<boolean[]>

// ✗ Fail
type _
 = Assert.array.exact.boolean
<string[]>

`[T]` `Date`

typescript

type Date_<$Actual> = Kind.Apply<
  ExactKind,
  [Date, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for Date. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.Date
<Date[]>

// ✗ Fail
type _
 = Assert.array.exact.Date
<string[]>

`[T]` `Error`

typescript

type Error_<$Actual> = Kind.Apply<
  ExactKind,
  [Error, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for Error. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.Error
<Error[]>

// ✗ Fail
type _
 = Assert.array.exact.Error
<string[]>

`[T]` `never`

typescript

type never_<$Actual> = Kind.Apply<
  ExactKind,
  [never, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for never. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.never
<never[]>

// ✗ Fail
type _
 = Assert.array.exact.never
<string[]>

`[T]` `noExcess`

typescript

type noExcess_ = never

`[T]` `null`

typescript

type null_<$Actual> = Kind.Apply<
  ExactKind,
  [null, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for null. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.null
<null[]>

// ✗ Fail
type _
 = Assert.array.exact.null
<string[]>

`[T]` `number`

typescript

type number_<$Actual> = Kind.Apply<
  ExactKind,
  [number, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for number. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.number
<number[]>

// ✗ Fail
type _
 = Assert.array.exact.number
<string[]>

`[T]` `of`

typescript

type of_<$Expected, $Actual> = Kind.Apply<
  ExactKind,
  [$Expected, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

array + exact relation matchers.

Extraction: extracts the element type from an array Relation: exact structural equality

`[T]` `RegExp`

typescript

type RegExp_<$Actual> = Kind.Apply<
  ExactKind,
  [RegExp, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for RegExp. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.RegExp
<RegExp[]>

// ✗ Fail
type _
 = Assert.array.exact.RegExp
<string[]>

`[T]` `string`

typescript

type string_<$Actual> = Kind.Apply<
  ExactKind,
  [string, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for string. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.string
<string[]>

// ✗ Fail
type _
 = Assert.array.exact.string
<number[]>

`[T]` `symbol`

typescript

type symbol_<$Actual> = Kind.Apply<
  ExactKind,
  [symbol, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for symbol. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.symbol
<symbol[]>

// ✗ Fail
type _
 = Assert.array.exact.symbol
<string[]>

`[T]` `undefined`

typescript

type undefined_<$Actual> = Kind.Apply<
  ExactKind,
  [undefined, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for undefined. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.undefined
<undefined[]>

// ✗ Fail
type _
 = Assert.array.exact.undefined
<string[]>

`[T]` `unknown`

typescript

type unknown_<$Actual> = Kind.Apply<
  ExactKind,
  [unknown, Kind.Apply<Path.ArrayElement, [$Actual]>, true]
>

Pre-curried matcher for unknown. Extraction chain: T[] → T

Examples:

typescript

// ✓ Pass
type _
 = Assert.array.exact.unknown
<unknown[]>

// ✗ Fail
type _
 = Assert.array.exact.unknown
<string[]>

Obj

Str

Ts

Ts.Assert.array.not.exact

Import

Functions

`[F]` `ofAs`

Constants

`[C]` `any`

`[C]` `bigint`

`[C]` `boolean`

`[C]` `Date`

`[C]` `Error`

`[C]` `never`

`[C]` `noExcess`

`[C]` `null`

`[C]` `number`

`[C]` `of`

`[C]` `RegExp`

`[C]` `string`

`[C]` `symbol`

`[C]` `undefined`

`[C]` `unknown`

Types

`[T]` `any`

`[T]` `bigint`

`[T]` `boolean`

`[T]` `Date`

`[T]` `Error`

`[T]` `never`

`[T]` `noExcess`

`[T]` `null`

`[T]` `number`

`[T]` `of`

`[T]` `RegExp`

`[T]` `string`

`[T]` `symbol`

`[T]` `undefined`

`[T]` `unknown`

Ts.Assert.array.not.exact ​

Import ​

Functions ​

[F] ofAs ​

Constants ​

[C] any ​

[C] bigint ​

[C] boolean ​

[C] Date ​

[C] Error ​

[C] never ​

[C] noExcess ​

[C] null ​

[C] number ​

[C] of ​

[C] RegExp ​

[C] string ​

[C] symbol ​

[C] undefined ​

[C] unknown ​

Types ​

[T] any ​

[T] bigint ​

[T] boolean ​

[T] Date ​

[T] Error ​

[T] never ​

[T] noExcess ​

[T] null ​

[T] number ​

[T] of ​

[T] RegExp ​

[T] string ​

[T] symbol ​

[T] undefined ​

[T] unknown ​

Ts.Assert.array.not.exact

Import

Functions

`[F]` `ofAs`

Constants

`[C]` `any`

`[C]` `bigint`

`[C]` `boolean`

`[C]` `Date`

`[C]` `Error`

`[C]` `never`

`[C]` `noExcess`

`[C]` `null`

`[C]` `number`

`[C]` `of`

`[C]` `RegExp`

`[C]` `string`

`[C]` `symbol`

`[C]` `undefined`

`[C]` `unknown`

Types

`[T]` `any`

`[T]` `bigint`

`[T]` `boolean`

`[T]` `Date`

`[T]` `Error`

`[T]` `never`

`[T]` `noExcess`

`[T]` `null`

`[T]` `number`

`[T]` `of`

`[T]` `RegExp`

`[T]` `string`

`[T]` `symbol`

`[T]` `undefined`

`[T]` `unknown`