             }
         }
     }
-
-}
-
-
-
-
-public func curry<A, B, C, D, E, F, G, H, I>(f: (A, B, C, D, E, F, G, H) -> I) -> A -> B -> C -> D -> E -> F -> G -> H -> I {
-
-    return { (a: A) -> B -> C -> D -> E -> F -> G -> H -> I in
-        { (b: B) -> C -> D -> E -> F -> G -> H -> I in
-            { (c: C) -> D -> E -> F -> G -> H -> I in
-                { (d: D) -> E -> F -> G -> H -> I in
-                    { (e: E) -> F -> G -> H -> I in
-                        { (ff: F) -> G -> H -> I in
-                            { (g: G) -> H -> I in
-                                { (h: H) -> I in
-
+    
+}
+
+
+
+
+public func curry<A, B, C, D, E, F, G, H, I>(f : (A, B, C, D, E, F, G, H) -> I) -> A -> B -> C -> D -> E -> F -> G -> H -> I {
+    
+    return { (a : A) -> B -> C -> D -> E -> F -> G -> H -> I in
+        { (b : B) -> C -> D -> E -> F -> G -> H -> I in
+            { (c : C) -> D -> E -> F -> G -> H -> I in
+                { (d : D) -> E -> F -> G -> H -> I in
+                    { (e : E) -> F -> G -> H -> I in
+                        { (ff : F) -> G -> H -> I in
+                            { (g : G) -> H -> I in
+                                { (h : H) -> I in
+                                    
                                     f(a, b, c, d, e, ff, g, h)
                                 }
                             }

            }
        }
    }

}

/// Converts a curried function to an uncurried function.

/// as opposed to an uncurried function which may take tuples.


public func curry<A, B, C>(f : (A, B) -> C) -> A -> B -> C {
    
    return { (a : A) -> B -> C in
        { (b : B) -> C in
            
            f(a, b)
        }
    }
    
}




public func curry<A, B, C, D>(f : (A, B, C) -> D) -> A -> B -> C -> D {
    
    return { (a : A) -> B -> C -> D in
        { (b : B) -> C -> D in
            { (c : C) -> D in
                
                f(a, b, c)
            }
        }
    }
    
}




public func curry<A, B, C, D, E>(f : (A, B, C, D) -> E) -> A -> B -> C -> D -> E {
    
    return { (a : A) -> B -> C -> D -> E in
        { (b : B) -> C -> D -> E in
            { (c : C) -> D -> E in
                { (d : D) -> E in
                    
                    f(a, b, c, d)
                }
            }
        }
    }
    
}




public func curry<A, B, C, D, E, F>(f : (A, B, C, D, E) -> F) -> A -> B -> C -> D -> E -> F {
    
    return { (a : A) -> B -> C -> D -> E -> F in
        { (b : B) -> C -> D -> E -> F in
            { (c : C) -> D -> E -> F in
                { (d : D) -> E -> F in
                    { (e : E) -> F in
                        
                        f(a, b, c, d, e)
                    }
                }
            }
        }
    }
    
}




public func curry<A, B, C, D, E, F, G>(f : (A, B, C, D, E, F) -> G) -> A -> B -> C -> D -> E -> F -> G {
    
    return { (a : A) -> B -> C -> D -> E -> F -> G in
        { (b : B) -> C -> D -> E -> F -> G in
            { (c : C) -> D -> E -> F -> G in
                { (d : D) -> E -> F -> G in
                    { (e : E) -> F -> G in
                        { (ff : F) -> G in
                            
                            f(a, b, c, d, e, ff)
                        }
                    }
