A transducer is a composable way of processing a series of values. Many basic transducers correspond to functions you may be familiar with for processing
Transducers can be used to combine processing operations in a way that allows processing to be done more efficiently.
List.map, it is more efficient to compose multiple functions and then map the list with the composed function than to map the list with each function independently because the list will only be traversed once. Similarly, transducers can be used to process
Lists more efficiently, but it is not limited to mapping operations.
drop, and any other transducer can be efficiently composed.
import List as L import Transducer as T exposing ((>>>)) slowMapChain = [1, 2, 3] |> L.map ((+) 10) |> L.map toString fastMapChain = [1, 2, 3] |> L.map ((+) 10 >> toString) slowChain = [1, 2, 3] |> L.filter ((/=) 2) |> L.map toString fastChain = [1, 2, 3] |> T.transduceList (T.filter ((/=) 2) >>> T.map toString)
Transducers can be reused with many different data types.
Dict are supported by this library, and you can define your own transducer processes to work with other data types.
You can also define transducer processes that convert between types (for example, transducing from a
List into a
import Maybe import String import Transducer as T exposing ((>>>)) import Result exposing (toMaybe) import Set exposing (Set) parseValidInts = T.map String.toInt >>> T.map toMaybe >>> T.filter ((/=) Nothing) >>> T.map (Maybe.withDefault 0) exampleList : List Int exampleList = T.transduceList parseValidInts [ "123", "-34", "35.0", "SDF", "7" ] exampleConvert : Set Int exampleConvert = T.transduce List.foldr Set.insert Set.empty parseValidInts [ "123", "-34", "35.0", "SDF", "7" ]
Reducertype to be
a -> r -> rinstead of
r -> a -> r