Module

# Data.Function.Uncurried

Package
purescript-functions
Repository
purescript/purescript-functions

### #Fn0Source

``data Fn0 t0``

A function of zero arguments

### #Fn1Source

``type Fn1 a b = a -> b``

A function of one argument

### #Fn2Source

``data Fn2 t0 t1 t2``

A function of two arguments

### #Fn3Source

``data Fn3 t0 t1 t2 t3``

A function of three arguments

### #Fn4Source

``data Fn4 t0 t1 t2 t3 t4``

A function of four arguments

### #Fn5Source

``data Fn5 t0 t1 t2 t3 t4 t5``

A function of five arguments

### #Fn6Source

``data Fn6 t0 t1 t2 t3 t4 t5 t6``

A function of six arguments

### #Fn7Source

``data Fn7 t0 t1 t2 t3 t4 t5 t6 t7``

A function of seven arguments

### #Fn8Source

``data Fn8 t0 t1 t2 t3 t4 t5 t6 t7 t8``

A function of eight arguments

### #Fn9Source

``data Fn9 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9``

A function of nine arguments

### #Fn10Source

``data Fn10 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10``

A function of ten arguments

### #mkFn0Source

``mkFn0 :: forall a. (Unit -> a) -> Fn0 a``

Create a function of no arguments

### #mkFn1Source

``mkFn1 :: forall a b. (a -> b) -> Fn1 a b``

Create a function of one argument

### #mkFn2Source

``mkFn2 :: forall a b c. (a -> b -> c) -> Fn2 a b c``

Create a function of two arguments from a curried function

### #mkFn3Source

``mkFn3 :: forall a b c d. (a -> b -> c -> d) -> Fn3 a b c d``

Create a function of three arguments from a curried function

### #mkFn4Source

``mkFn4 :: forall a b c d e. (a -> b -> c -> d -> e) -> Fn4 a b c d e``

Create a function of four arguments from a curried function

### #mkFn5Source

``mkFn5 :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> Fn5 a b c d e f``

Create a function of five arguments from a curried function

### #mkFn6Source

``mkFn6 :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> Fn6 a b c d e f g``

Create a function of six arguments from a curried function

### #mkFn7Source

``mkFn7 :: forall a b c d e f g h. (a -> b -> c -> d -> e -> f -> g -> h) -> Fn7 a b c d e f g h``

Create a function of seven arguments from a curried function

### #mkFn8Source

``mkFn8 :: forall a b c d e f g h i. (a -> b -> c -> d -> e -> f -> g -> h -> i) -> Fn8 a b c d e f g h i``

Create a function of eight arguments from a curried function

### #mkFn9Source

``mkFn9 :: forall a b c d e f g h i j. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j) -> Fn9 a b c d e f g h i j``

Create a function of nine arguments from a curried function

### #mkFn10Source

``mkFn10 :: forall a b c d e f g h i j k. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k) -> Fn10 a b c d e f g h i j k``

Create a function of ten arguments from a curried function

### #runFn0Source

``runFn0 :: forall a. Fn0 a -> a``

Apply a function of no arguments

### #runFn1Source

``runFn1 :: forall a b. Fn1 a b -> a -> b``

Apply a function of one argument

### #runFn2Source

``runFn2 :: forall a b c. Fn2 a b c -> a -> b -> c``

Apply a function of two arguments

### #runFn3Source

``runFn3 :: forall a b c d. Fn3 a b c d -> a -> b -> c -> d``

Apply a function of three arguments

### #runFn4Source

``runFn4 :: forall a b c d e. Fn4 a b c d e -> a -> b -> c -> d -> e``

Apply a function of four arguments

### #runFn5Source

``runFn5 :: forall a b c d e f. Fn5 a b c d e f -> a -> b -> c -> d -> e -> f``

Apply a function of five arguments

### #runFn6Source

``runFn6 :: forall a b c d e f g. Fn6 a b c d e f g -> a -> b -> c -> d -> e -> f -> g``

Apply a function of six arguments

### #runFn7Source

``runFn7 :: forall a b c d e f g h. Fn7 a b c d e f g h -> a -> b -> c -> d -> e -> f -> g -> h``

Apply a function of seven arguments

### #runFn8Source

``runFn8 :: forall a b c d e f g h i. Fn8 a b c d e f g h i -> a -> b -> c -> d -> e -> f -> g -> h -> i``

Apply a function of eight arguments

### #runFn9Source

``runFn9 :: forall a b c d e f g h i j. Fn9 a b c d e f g h i j -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j``

Apply a function of nine arguments

### #runFn10Source

``runFn10 :: forall a b c d e f g h i j k. Fn10 a b c d e f g h i j k -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k``

Apply a function of ten arguments