Have ideas to improve npm?Join in the discussion! »

    @typed/core
    TypeScript icon, indicating that this package has built-in type declarations

    2.1.0 • Public • Published

    @typed/core -- 2.0.0

    Shared kernel of types for Typed organization

    Get it

    yarn add @typed/core
    # or 
    npm install --save @typed/core

    API Documentation

    All functions are curried!

    Arity0

     
    export type Arity0<A> = () => A
     

    Arity1

     
    export type Arity1<A, B> = (value: A) => B
     

    Arity10

     
    export type Arity10<A, B, C, D, E, F, G, H, I, J, K> = (
      aA,
      bB,
      cC,
      dD,
      eE,
      fF,
      gG,
      hH,
      iI,
      jJ
    ) => K
     

    Arity10N

     
    export type Arity10N<A, B, C, D, E, F, G, H, I, J, R> = (
      aA,
      bB,
      cC,
      dD,
      eE,
      fF,
      gG,
      hH,
      iI,
      jJ,
      ...argsArray<any>
    ) => R
     

    Arity1Bound

     
    export type Arity1Bound<that, A, B> = (this: that, a: A) => B
     

    Arity1N

     
    export type Arity1N<A, R> = (a: A, ...args: Array<any>) => R
     

    Arity2

     
    export type Arity2<A, B, C> = (a: A, b: B) => C
     

    Arity2Bound

     
    export type Arity2Bound<that, A, B, C> = (this: that, a: A, b: B) => C
     

    Arity2N

     
    export type Arity2N<A, B, R> = (a: A, b: B, ...args: Array<any>) => R
     

    Arity3

     
    export type Arity3<A, B, C, D> = (a: A, b: B, c: C) => D
     

    Arity3Bound

     
    export type Arity3Bound<that, A, B, C, D> = (this: that, a: A, b: B, c: C) => D
     

    Arity3N

     
    export type Arity3N<A, B, C, R> = (a: A, b: B, c: C, ...args: Array<any>) => R
     

    Arity4

     
    export type Arity4<A, B, C, D, E> = (a: A, b: B, c: C, d: D) => E
     

    Arity4Bound

     
    export type Arity4Bound<that, A, B, C, D, E> = (this: that, a: A, b: B, c: C, d: D) => E
     

    Arity4N

     
    export type Arity4N<A, B, C, D, R> = (a: A, b: B, c: C, d: D, ...args: Array<any>) => R
     

    Arity5

     
    export type Arity5<A, B, C, D, E, F> = (a: A, b: B, c: C, d: D, e: E) => F
     

    Arity5Bound

     
    export type Arity5Bound<that, A, B, C, D, E, F> = (this: that, a: A, b: B, c: C, d: D, e: E) => F
     

    Arity5N

     
    export type Arity5N<A, B, C, D, E, R> = (a: A, b: B, c: C, d: D, e: E, ...args: Array<any>) => R
     

    Arity6

     
    export type Arity6<A, B, C, D, E, F, G> = (a: A, b: B, c: C, d: D, e: E, f: F) => G
     

    Arity6N

     
    export type Arity6N<A, B, C, D, E, F, R> = (
      aA,
      bB,
      cC,
      dD,
      eE,
      fF,
      ...argsArray<any>
    ) => R
     

    Arity7

     
    export type Arity7<A, B, C, D, E, F, G, H> = (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H
     

    Arity7N

     
    export type Arity7N<A, B, C, D, E, F, G, R> = (
      aA,
      bB,
      cC,
      dD,
      eE,
      fF,
      gG,
      ...argsArray<any>
    ) => R
     

    Arity8

     
    export type Arity8<A, B, C, D, E, F, G, H, I> = (
      aA,
      bB,
      cC,
      dD,
      eE,
      fF,
      gG,
      hH
    ) => I
     

    Arity8N

     
    export type Arity8N<A, B, C, D, E, F, G, H, R> = (
      aA,
      bB,
      cC,
      dD,
      eE,
      fF,
      gG,
      hH,
      ...argsArray<any>
    ) => R
     

    Arity9

     
    export type Arity9<A, B, C, D, E, F, G, H, I, J> = (
      aA,
      bB,
      cC,
      dD,
      eE,
      fF,
      gG,
      hH,
      iI
    ) => J
     

    Arity9N

     
    export type Arity9N<A, B, C, D, E, F, G, H, I, R> = (
      aA,
      bB,
      cC,
      dD,
      eE,
      fF,
      gG,
      hH,
      iI,
      ...argsArray<any>
    ) => R
     

    ArityN

     
    export type ArityN<R> = (...args: Array<any>) => R
     

    Comparator

     
    export type Comparator<A> = (a: A, b: A) => ComparisonNumbers
     

    ComparisonNumber

     
    export type ComparisonNumbers = -1 | 0 | 1
     

    Curry10

     
    export type Curry10<A, B, C, D, E, F, G, H, I, J, K> = {
      (a: A): Curry9<B, C, D, E, F, G, H, I, J, K>
      (a: A, b: B): Curry8<C, D, E, F, G, H, I, J, K>
      (a: A, b: B, c: C): Curry7<D, E, F, G, H, I, J, K>
      (a: A, b: B, c: C, d: D): Curry6<E, F, G, H, I, J, K>
      (a: A, b: B, c: C, d: D, e: E): Curry5<F, G, H, I, J, K>
      (a: A, b: B, c: C, d: D, e: E, f: F): Curry4<G, H, I, J, K>
      (a: A, b: B, c: C, d: D, e: E, f: F, g: G): Curry3<H, I, J, K>
      (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H): Curry2<I, J, K>
      (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I): Arity1<J, K>
      (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J): K
    }
     

    Curry2

     
    export type Curry2<A, B, C> = {
      (a: A): Arity1<B, C>
      (a: A, b: B): C
    }
     

    Curry3

     
    export type Curry3<A, B, C, D> = {
      (a: A): Curry2<B, C, D>
      (a: A, b: B): Arity1<C, D>
      (a: A, b: B, c: C): D
    }
     

    Curry4

     
    export type Curry4<A, B, C, D, E> = {
      (a: A): Curry3<B, C, D, E>
      (a: A, b: B): Curry2<C, D, E>
      (a: A, b: B, c: C): Arity1<D, E>
      (a: A, b: B, c: C, d: D): E
    }
     

    Curry5

     
    export type Curry5<A, B, C, D, E, F> = {
      (a: A): Curry4<B, C, D, E, F>
      (a: A, b: B): Curry3<C, D, E, F>
      (a: A, b: B, c: C): Curry2<D, E, F>
      (a: A, b: B, c: C, d: D): Arity1<E, F>
      (a: A, b: B, c: C, d: D, e: E): F
    }
     

    Curry6

     
    export type Curry6<A, B, C, D, E, F, G> = {
      (a: A): Curry5<B, C, D, E, F, G>
      (a: A, b: B): Curry4<C, D, E, F, G>
      (a: A, b: B, c: C): Curry3<D, E, F, G>
      (a: A, b: B, c: C, d: D): Curry2<E, F, G>
      (a: A, b: B, c: C, d: D, e: E): Arity1<F, G>
      (a: A, b: B, c: C, d: D, e: E, f: F): G
    }
     

    Curry7

     
    export type Curry7<A, B, C, D, E, F, G, H> = {
      (a: A): Curry6<B, C, D, E, F, G, H>
      (a: A, b: B): Curry5<C, D, E, F, G, H>
      (a: A, b: B, c: C): Curry4<D, E, F, G, H>
      (a: A, b: B, c: C, d: D): Curry3<E, F, G, H>
      (a: A, b: B, c: C, d: D, e: E): Curry2<F, G, H>
      (a: A, b: B, c: C, d: D, e: E, f: F): Arity1<G, H>
      (a: A, b: B, c: C, d: D, e: E, f: F, g: G): H
    }
     

    Curry8

     
    export type Curry8<A, B, C, D, E, F, G, H, I> = {
      (a: A): Curry7<B, C, D, E, F, G, H, I>
      (a: A, b: B): Curry6<C, D, E, F, G, H, I>
      (a: A, b: B, c: C): Curry5<D, E, F, G, H, I>
      (a: A, b: B, c: C, d: D): Curry4<E, F, G, H, I>
      (a: A, b: B, c: C, d: D, e: E): Curry3<F, G, H, I>
      (a: A, b: B, c: C, d: D, e: E, f: F): Curry2<G, H, I>
      (a: A, b: B, c: C, d: D, e: E, f: F, g: G): Arity1<H, I>
      (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H): I
    }
     

    Curry9

     
    export type Curry9<A, B, C, D, E, F, G, H, I, J> = {
      (a: A): Curry8<B, C, D, E, F, G, H, I, J>
      (a: A, b: B): Curry7<C, D, E, F, G, H, I, J>
      (a: A, b: B, c: C): Curry6<D, E, F, G, H, I, J>
      (a: A, b: B, c: C, d: D): Curry5<E, F, G, H, I, J>
      (a: A, b: B, c: C, d: D, e: E): Curry4<F, G, H, I, J>
      (a: A, b: B, c: C, d: D, e: E, f: F): Curry3<G, H, I, J>
      (a: A, b: B, c: C, d: D, e: E, f: F, g: G): Curry2<H, I, J>
      (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H): Arity1<I, J>
      (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I): J
    }
     

    Either

    Either data structure. Extremely useful for handling errors or different logic paths without the use of if-statements.

     
    export type Either<A, B> = Left<A> | Right<B>
     

    Fork

    Fork function signature used by Future.

     
    export type Fork<A, B> = (reject: (value: A) => void, resolve: (value: B) => void) => void
     

    Future

    Asynchronous data-structure similar to a Promise, but lazy.

     
    export interface Future<A, B> {
      readonly fork: Fork<A, B>
    }
     

    Index

    A type-alias for numbers representing a List index

     
    export type Index = number
     

    Just

    A JSON-serializable Just data-structure

     
    export interface Just<A> {
      readonly '@typed/Just': A
    }
     

    Left

    A JSON-serializable Left<A> data-structure.

     
    export interface Left<A> {
      readonly '@typed/Left': A
    }
     

    List

    An immutable List type.

     
    export interface List<A> {
      readonly [key: number]: A
      readonly length: number
    }
     

    Maybe<A>

    Maybe type. Very useful when errors can occur.

     
    export type Maybe<A> = Just<A> | Nothing
     

    Nothing

    The Nothing type, used in place of nulls or undefined.

     
    export interface Nothing {
      readonly '@typed/Nothing': true
    }
     

    Predicate

     
    export type Predicate<A> = (value: A) => boolean
     

    Predicate2

     
    export type Predicate2<A> = (a: A, b: A) => boolean
     

    Right

    A JSON-serializable Right data-structure.

     
    export interface Right<A> {
      readonly '@typed/Right': A
    }
     

    Install

    npm i @typed/core

    DownloadsWeekly Downloads

    31

    Version

    2.1.0

    License

    MIT

    Last publish

    Collaborators

    • avatar