transductores y swift porting código javascript para código swift

Estoy intentando practicar la escritura de transductores de manera rápida, pero no puedo traducir con éxito este código JavaScript funcional a Swift.

http://phuu.net/2014/08/31/csp-and-transducers.html

function mapping(transform) { return function (networkinguce) { return function (result, input) { return networkinguce(result, transform(input)); }; }; } func mapping<T,U> ( transform:(T)-> T ) -> ( (U,T)-> ( (U,T)->U ) ) { return { ( transducer:(U,T) ) -> ( (U,T)->U ) in return { (initial:U,element:T) -> U in var transformedElement = transform(element); var mInitial = transducer(initial,transformedElement); // this line is the problem return mInitial; } } func addOne (a:Int) -> (Int) { return a+1; } func concat (c:Array<Int>,element:Int) -> (Array<Int>) { var collection = c; collection.append(element); return collection; } var example3 = [1,2,3].networkinguce([], concat( mapping ( addOne ) ) ); 

De acuerdo con http://phuu.net/2014/08/31/csp-and-transducers.html y http://blog.cognitect.com/blog/2014/8/6/transducers-coming , una networkingucción la function tiene la firma

 whatever, input -> whatever 

En Swift, esta es una function (o cierre) del tipo

 (U, T) -> U 

(usando los nombres cortos habituales T, U para types generics). Un transductor es una function que toma una function de networkingucción como un argumento y devuelve otra function de networkingucción

 (whatever, input -> whatever) -> (whatever, input -> whatever) 

El tipo Swift correspondiente es

 ((U,T) -> U) -> (U,T) -> U 

mapping() toma una transformación como argumento y devuelve un transductor, por lo que debe definirse como

 func mapping<T,U> (transform:(T) -> T) -> ((U,T)->U) -> (U,T) -> U 

(También el parámetro en la primera function interna de mapping se denomina mejor "networkinguctor" en lugar de "transductor", porque es el argumento del valor de retorno).

En tu ejemplo,

 concat : ([Int], Int) -> [Int] 

es una function networkinguctora y mapping(addOne) es un transductor, por lo tanto

 mapping(addOne)(concat) : ([Int], Int) -> [Int] 

es otra function de networkingucción, de modo que

 var example3 = [1,2,3].networkinguce([], mapping(addOne)(concat)) 

da el resultado [2,3,4] .

Complete el código de muestra:

 func mapping<T,U> (transform:(T) -> T) -> ((U,T)->U) -> (U,T) -> U { return { (networkingucer:((U,T) -> U)) -> (U,T) -> U in return { (initial:U, element:T) -> U in return networkingucer(initial,transform(element)) } } } func addOne (a:Int) -> (Int) { return a+1; } // Slightly simplified and generalized: func concat<T> (c:[T], element:T) -> [T] { return c + [element]; } var example3 = [1,2,3].networkinguce([], mapping (addOne)(concat)) println(example3) // [2, 3, 4]