Function pipe

  • Creates a new function composed from the functions received as arguments. The composition is left to right (the first function is invoked first and it's result is passed as an argument to the second...).

    Using pipe is is the preferred way to compose functions in TS, because right to left composition can't be typed properly (TS design limitation).

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    Parameters

    • fn0: ((...args: V) => T1)
        • (...args: V): T1
        • Parameters

          • Rest ...args: V

          Returns T1

    Returns ((...args: V) => T1)

      • (...args: V): T1
      • Parameters

        • Rest ...args: V

        Returns T1

  • Creates a new function composed from the functions received as arguments. The composition is left to right (the first function is invoked first and it's result is passed as an argument to the second...).

    Using pipe is is the preferred way to compose functions in TS, because right to left composition can't be typed properly (TS design limitation).

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    Parameters

    • fn0: ((...args: V) => T1)
        • (...args: V): T1
        • Parameters

          • Rest ...args: V

          Returns T1

    • fn1: ((x: T1) => T2)
        • (x: T1): T2
        • Parameters

          • x: T1

          Returns T2

    Returns ((...args: V) => T2)

      • (...args: V): T2
      • Parameters

        • Rest ...args: V

        Returns T2

  • Creates a new function composed from the functions received as arguments. The composition is left to right (the first function is invoked first and it's result is passed as an argument to the second...).

    Using pipe is is the preferred way to compose functions in TS, because right to left composition can't be typed properly (TS design limitation).

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    Parameters

    • fn0: ((...args: V) => T1)
        • (...args: V): T1
        • Parameters

          • Rest ...args: V

          Returns T1

    • fn1: ((x: T1) => T2)
        • (x: T1): T2
        • Parameters

          • x: T1

          Returns T2

    • fn2: ((x: T2) => T3)
        • (x: T2): T3
        • Parameters

          • x: T2

          Returns T3

    Returns ((...args: V) => T3)

      • (...args: V): T3
      • Parameters

        • Rest ...args: V

        Returns T3

  • Creates a new function composed from the functions received as arguments. The composition is left to right (the first function is invoked first and it's result is passed as an argument to the second...).

    Using pipe is is the preferred way to compose functions in TS, because right to left composition can't be typed properly (TS design limitation).

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    Parameters

    • fn0: ((...args: V) => T1)
        • (...args: V): T1
        • Parameters

          • Rest ...args: V

          Returns T1

    • fn1: ((x: T1) => T2)
        • (x: T1): T2
        • Parameters

          • x: T1

          Returns T2

    • fn2: ((x: T2) => T3)
        • (x: T2): T3
        • Parameters

          • x: T2

          Returns T3

    • fn3: ((x: T3) => T4)
        • (x: T3): T4
        • Parameters

          • x: T3

          Returns T4

    Returns ((...args: V) => T4)

      • (...args: V): T4
      • Parameters

        • Rest ...args: V

        Returns T4

  • Creates a new function composed from the functions received as arguments. The composition is left to right (the first function is invoked first and it's result is passed as an argument to the second...).

    Using pipe is is the preferred way to compose functions in TS, because right to left composition can't be typed properly (TS design limitation).

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    • T5

    Parameters

    • fn0: ((...args: V) => T1)
        • (...args: V): T1
        • Parameters

          • Rest ...args: V

          Returns T1

    • fn1: ((x: T1) => T2)
        • (x: T1): T2
        • Parameters

          • x: T1

          Returns T2

    • fn2: ((x: T2) => T3)
        • (x: T2): T3
        • Parameters

          • x: T2

          Returns T3

    • fn3: ((x: T3) => T4)
        • (x: T3): T4
        • Parameters

          • x: T3

          Returns T4

    • fn4: ((x: T4) => T5)
        • (x: T4): T5
        • Parameters

          • x: T4

          Returns T5

    Returns ((...args: V) => T5)

      • (...args: V): T5
      • Parameters

        • Rest ...args: V

        Returns T5

  • Creates a new function composed from the functions received as arguments. The composition is left to right (the first function is invoked first and it's result is passed as an argument to the second...).

    Using pipe is is the preferred way to compose functions in TS, because right to left composition can't be typed properly (TS design limitation).

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    • T5

    • T6

    Parameters

    • fn0: ((...args: V) => T1)
        • (...args: V): T1
        • Parameters

          • Rest ...args: V

          Returns T1

    • fn1: ((x: T1) => T2)
        • (x: T1): T2
        • Parameters

          • x: T1

          Returns T2

    • fn2: ((x: T2) => T3)
        • (x: T2): T3
        • Parameters

          • x: T2

          Returns T3

    • fn3: ((x: T3) => T4)
        • (x: T3): T4
        • Parameters

          • x: T3

          Returns T4

    • fn4: ((x: T4) => T5)
        • (x: T4): T5
        • Parameters

          • x: T4

          Returns T5

    • fn5: ((x: T5) => T6)
        • (x: T5): T6
        • Parameters

          • x: T5

          Returns T6

    Returns ((...args: V) => T6)

      • (...args: V): T6
      • Parameters

        • Rest ...args: V

        Returns T6

  • Creates a new function composed from the functions received as arguments. The composition is left to right (the first function is invoked first and it's result is passed as an argument to the second...).

    Using pipe is is the preferred way to compose functions in TS, because right to left composition can't be typed properly (TS design limitation).

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    • T5

    • T6

    • T7

    Parameters

    • fn0: ((...args: V) => T1)
        • (...args: V): T1
        • Parameters

          • Rest ...args: V

          Returns T1

    • fn1: ((x: T1) => T2)
        • (x: T1): T2
        • Parameters

          • x: T1

          Returns T2

    • fn2: ((x: T2) => T3)
        • (x: T2): T3
        • Parameters

          • x: T2

          Returns T3

    • fn3: ((x: T3) => T4)
        • (x: T3): T4
        • Parameters

          • x: T3

          Returns T4

    • fn4: ((x: T4) => T5)
        • (x: T4): T5
        • Parameters

          • x: T4

          Returns T5

    • fn5: ((x: T5) => T6)
        • (x: T5): T6
        • Parameters

          • x: T5

          Returns T6

    • fn: ((x: T6) => T7)
        • (x: T6): T7
        • Parameters

          • x: T6

          Returns T7

    Returns ((...args: V) => T7)

      • (...args: V): T7
      • Parameters

        • Rest ...args: V

        Returns T7

  • Creates a new function composed from the functions received as arguments. The composition is left to right (the first function is invoked first and it's result is passed as an argument to the second...).

    Using pipe is is the preferred way to compose functions in TS, because right to left composition can't be typed properly (TS design limitation).

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    • T5

    • T6

    • T7

    • T8

    Parameters

    • fn0: ((...args: V) => T1)
        • (...args: V): T1
        • Parameters

          • Rest ...args: V

          Returns T1

    • fn1: ((x: T1) => T2)
        • (x: T1): T2
        • Parameters

          • x: T1

          Returns T2

    • fn2: ((x: T2) => T3)
        • (x: T2): T3
        • Parameters

          • x: T2

          Returns T3

    • fn3: ((x: T3) => T4)
        • (x: T3): T4
        • Parameters

          • x: T3

          Returns T4

    • fn4: ((x: T4) => T5)
        • (x: T4): T5
        • Parameters

          • x: T4

          Returns T5

    • fn5: ((x: T5) => T6)
        • (x: T5): T6
        • Parameters

          • x: T5

          Returns T6

    • fn6: ((x: T6) => T7)
        • (x: T6): T7
        • Parameters

          • x: T6

          Returns T7

    • fn: ((x: T7) => T8)
        • (x: T7): T8
        • Parameters

          • x: T7

          Returns T8

    Returns ((...args: V) => T8)

      • (...args: V): T8
      • Parameters

        • Rest ...args: V

        Returns T8

  • Creates a new function composed from the functions received as arguments. The composition is left to right (the first function is invoked first and it's result is passed as an argument to the second...).

    Using pipe is is the preferred way to compose functions in TS, because right to left composition can't be typed properly (TS design limitation).

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    • T5

    • T6

    • T7

    • T8

    • T9

    Parameters

    • fn0: ((...args: V) => T1)
        • (...args: V): T1
        • Parameters

          • Rest ...args: V

          Returns T1

    • fn1: ((x: T1) => T2)
        • (x: T1): T2
        • Parameters

          • x: T1

          Returns T2

    • fn2: ((x: T2) => T3)
        • (x: T2): T3
        • Parameters

          • x: T2

          Returns T3

    • fn3: ((x: T3) => T4)
        • (x: T3): T4
        • Parameters

          • x: T3

          Returns T4

    • fn4: ((x: T4) => T5)
        • (x: T4): T5
        • Parameters

          • x: T4

          Returns T5

    • fn5: ((x: T5) => T6)
        • (x: T5): T6
        • Parameters

          • x: T5

          Returns T6

    • fn6: ((x: T6) => T7)
        • (x: T6): T7
        • Parameters

          • x: T6

          Returns T7

    • fn7: ((x: T7) => T8)
        • (x: T7): T8
        • Parameters

          • x: T7

          Returns T8

    • fn8: ((x: T8) => T9)
        • (x: T8): T9
        • Parameters

          • x: T8

          Returns T9

    Returns ((...args: V) => T9)

      • (...args: V): T9
      • Parameters

        • Rest ...args: V

        Returns T9

  • Creates a new function composed from the functions received as arguments. The composition is left to right (the first function is invoked first and it's result is passed as an argument to the second...).

    Using pipe is is the preferred way to compose functions in TS, because right to left composition can't be typed properly (TS design limitation).

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    • T5

    • T6

    • T7

    • T8

    • T9

    • T10

    Parameters

    • fn0: ((...args: V) => T1)
        • (...args: V): T1
        • Parameters

          • Rest ...args: V

          Returns T1

    • fn1: ((x: T1) => T2)
        • (x: T1): T2
        • Parameters

          • x: T1

          Returns T2

    • fn2: ((x: T2) => T3)
        • (x: T2): T3
        • Parameters

          • x: T2

          Returns T3

    • fn3: ((x: T3) => T4)
        • (x: T3): T4
        • Parameters

          • x: T3

          Returns T4

    • fn4: ((x: T4) => T5)
        • (x: T4): T5
        • Parameters

          • x: T4

          Returns T5

    • fn5: ((x: T5) => T6)
        • (x: T5): T6
        • Parameters

          • x: T5

          Returns T6

    • fn6: ((x: T6) => T7)
        • (x: T6): T7
        • Parameters

          • x: T6

          Returns T7

    • fn7: ((x: T7) => T8)
        • (x: T7): T8
        • Parameters

          • x: T7

          Returns T8

    • fn8: ((x: T8) => T9)
        • (x: T8): T9
        • Parameters

          • x: T8

          Returns T9

    • fn9: ((x: T9) => T10)
        • (x: T9): T10
        • Parameters

          • x: T9

          Returns T10

    Returns ((...args: V) => T10)

      • (...args: V): T10
      • Parameters

        • Rest ...args: V

        Returns T10

  • Creates a new function composed from the functions received as arguments. The composition is left to right (the first function is invoked first and it's result is passed as an argument to the second...).

    Using pipe is is the preferred way to compose functions in TS, because right to left composition can't be typed properly (TS design limitation).

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T

    Parameters

    • Rest ...fns: ((...args: V) => T)[]

      functions that should be composed together

    Returns ((...args: V) => T)

      • (...args: V): T
      • Parameters

        • Rest ...args: V

        Returns T

Generated using TypeDoc