Function compose

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

    Unfortunately, this function can't be typed properly (TS design limitation, see: https://github.com/microsoft/TypeScript/issues/31738). Use pipe if with left to right composition instead if possible.

    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 right to left (the last function is invoked first and it's result is passed as an argument to the previous function...).

    Unfortunately, this function can't be typed properly (TS design limitation, see: https://github.com/microsoft/TypeScript/issues/31738). Use pipe if with left to right composition instead if possible.

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    Parameters

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

          • x: T1

          Returns T2

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

          • Rest ...args: V

          Returns T1

    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 right to left (the last function is invoked first and it's result is passed as an argument to the previous function...).

    Unfortunately, this function can't be typed properly (TS design limitation, see: https://github.com/microsoft/TypeScript/issues/31738). Use pipe if with left to right composition instead if possible.

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    Parameters

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

          • x: T2

          Returns T3

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

          • x: T1

          Returns T2

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

          • Rest ...args: V

          Returns T1

    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 right to left (the last function is invoked first and it's result is passed as an argument to the previous function...).

    Unfortunately, this function can't be typed properly (TS design limitation, see: https://github.com/microsoft/TypeScript/issues/31738). Use pipe if with left to right composition instead if possible.

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    Parameters

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

          • x: T3

          Returns T4

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

          • x: T2

          Returns T3

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

          • x: T1

          Returns T2

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

          • Rest ...args: V

          Returns T1

    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 right to left (the last function is invoked first and it's result is passed as an argument to the previous function...).

    Unfortunately, this function can't be typed properly (TS design limitation, see: https://github.com/microsoft/TypeScript/issues/31738). Use pipe if with left to right composition instead if possible.

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    • T5

    Parameters

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

          • x: T4

          Returns T5

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

          • x: T3

          Returns T4

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

          • x: T2

          Returns T3

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

          • x: T1

          Returns T2

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

          • Rest ...args: V

          Returns T1

    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 right to left (the last function is invoked first and it's result is passed as an argument to the previous function...).

    Unfortunately, this function can't be typed properly (TS design limitation, see: https://github.com/microsoft/TypeScript/issues/31738). Use pipe if with left to right composition instead if possible.

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    • T5

    • T6

    Parameters

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

          • x: T5

          Returns T6

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

          • x: T4

          Returns T5

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

          • x: T3

          Returns T4

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

          • x: T2

          Returns T3

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

          • x: T1

          Returns T2

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

          • Rest ...args: V

          Returns T1

    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 right to left (the last function is invoked first and it's result is passed as an argument to the previous function...).

    Unfortunately, this function can't be typed properly (TS design limitation, see: https://github.com/microsoft/TypeScript/issues/31738). Use pipe if with left to right composition instead if possible.

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    • T5

    • T6

    Parameters

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

          • x: T5

          Returns T6

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

          • x: T4

          Returns T5

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

          • x: T3

          Returns T4

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

          • x: T2

          Returns T3

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

          • x: T1

          Returns T2

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

          • Rest ...args: V

          Returns T1

    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 right to left (the last function is invoked first and it's result is passed as an argument to the previous function...).

    Unfortunately, this function can't be typed properly (TS design limitation, see: https://github.com/microsoft/TypeScript/issues/31738). Use pipe if with left to right composition instead if possible.

    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

    • fn6: ((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 right to left (the last function is invoked first and it's result is passed as an argument to the previous function...).

    Unfortunately, this function can't be typed properly (TS design limitation, see: https://github.com/microsoft/TypeScript/issues/31738). Use pipe if with left to right composition instead if possible.

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    • T5

    • T6

    • T7

    • T8

    Parameters

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

          • x: T7

          Returns T8

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

          • x: T6

          Returns T7

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

          • x: T5

          Returns T6

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

          • x: T4

          Returns T5

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

          • x: T3

          Returns T4

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

          • x: T2

          Returns T3

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

          • x: T1

          Returns T2

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

          • Rest ...args: V

          Returns T1

    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 right to left (the last function is invoked first and it's result is passed as an argument to the previous function...).

    Unfortunately, this function can't be typed properly (TS design limitation, see: https://github.com/microsoft/TypeScript/issues/31738). Use pipe if with left to right composition instead if possible.

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    • T5

    • T6

    • T7

    • T8

    • T9

    Parameters

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

          • x: T8

          Returns T9

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

          • x: T7

          Returns T8

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

          • x: T6

          Returns T7

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

          • x: T5

          Returns T6

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

          • x: T4

          Returns T5

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

          • x: T3

          Returns T4

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

          • x: T2

          Returns T3

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

          • x: T1

          Returns T2

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

          • Rest ...args: V

          Returns T1

    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 right to left (the last function is invoked first and it's result is passed as an argument to the previous function...).

    Unfortunately, this function can't be typed properly (TS design limitation, see: https://github.com/microsoft/TypeScript/issues/31738). Use pipe if with left to right composition instead if possible.

    Returns

    the composed function

    Type Parameters

    • V extends any[]

    • T1

    • T2

    • T3

    • T4

    • T5

    • T6

    • T7

    • T8

    • T9

    • T10

    Parameters

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

          • x: T9

          Returns T10

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

          • x: T8

          Returns T9

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

          • x: T7

          Returns T8

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

          • x: T6

          Returns T7

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

          • x: T5

          Returns T6

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

          • x: T4

          Returns T5

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

          • x: T3

          Returns T4

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

          • x: T2

          Returns T3

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

          • x: T1

          Returns T2

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

          • Rest ...args: V

          Returns T1

    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 right to left (the last function is invoked first and it's result is passed as an argument to the previous function...).

    Unfortunately, this function can't be typed properly (TS design limitation, see: https://github.com/microsoft/TypeScript/issues/31738). Use pipe if with left to right composition instead if possible.

    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