 /////////////////
 
 // NoneNone
-func cumin(fn: () -> ()) -> ([Any]) -> () {
-    return { (args: [Any]) in fn() }
+func cumin(fn: () -> ()) -> ([AnyObject]) -> () {
+    return { (args: [AnyObject]) in fn() }
 }
 
 // OneNone
-func cumin<A>(fn: A -> ()) -> ([Any]) -> () {
-    return { (args: [Any]) in fn(args[0] as! A) }
+func cumin<A>(fn: A -> ()) -> ([AnyObject]) -> () {
+    return { (args: [AnyObject]) in fn(args[0] as! A) }
 }
 
 
 // TwoNone
-func cumin<A, B>(fn: (A, B) -> ()) -> ([Any]) -> () {
-    return { (args: [Any]) -> () in fn(args[0] as! A, args[0] as! B) }
+func cumin<A, B>(fn: (A, B) -> ()) -> ([AnyObject]) -> () {
+    return { (args: [AnyObject]) -> () in fn(args[0] as! A, args[1] as! B) }
 }
 
 // ThreeNone
-func cumin<A, B, C>(fn: (A, B, C) -> ()) -> ([Any]) -> () {
-    return { (args: [Any]) -> () in fn(args[0] as! A, args[0] as! B, args[0] as! C) }
+func cumin<A, B, C>(fn: (A, B, C) -> ()) -> ([AnyObject]) -> () {
+    return { (args: [AnyObject]) -> () in fn(args[0] as! A, args[2] as! B, args[3] as! C) }
 }
 
 /////////////////
 // *One
 /////////////////
 // OneOne
-func cumin<A, R>(fn: A -> R) -> ([Any]) -> R {
-    return { (args: [Any]) -> R in fn(args[0] as! A) }
+func cumin<A, R>(fn: A -> R) -> ([AnyObject]) -> R {
+    return { (args: [AnyObject]) -> R in fn(args[0] as! A) }
 }
 
 // TwoOne
-func cumin<A, B, R>(fn: (A, B) -> R) -> ([Any]) -> R {
-    return { (args: [Any]) -> R in fn(args[0] as! A, args[0] as! B) }
+func cumin<A, B, R>(fn: (A, B) -> R) -> ([AnyObject]) -> R {
+    return { (args: [AnyObject]) -> R in fn(args[0] as! A, args[1] as! B) }
 }
 
 // ThreeOne
-func cumin<A, B, C, R>(fn: (A, B, C) -> R) -> ([Any]) -> R {
-    return { (args: [Any]) -> R in fn(args[0] as! A, args[0] as! B, args[0] as! C) }
+func cumin<A, B, C, R>(fn: (A, B, C) -> R) -> ([AnyObject]) -> R {
+    return { (args: [AnyObject]) -> R in fn(args[0] as! A, args[1] as! B, args[2] as! C) }
 }
////////////////////

/*
 Cumin allows for type-safe deferred method evaluation
 through currying. Not sure how to make it play without variadic generics, though there might be a way

TODO: 
    throw a well known error on miscast
    throw a well known error if args size doesn't match
    hold method weakly, dont call if deallocd
*/

/////////////////

    
    
    // Testing a sample call
    func _subscribe(endpoint: String, fn: ([AnyObject]) -> ()) {
        // This is the real subscrive method
        session.subscribe(endpoint, onEvent: { (event: MDWampEvent!) -> Void in
            print("Sub came in: ", event)
