In this course, we will go through the concept of transducers and build them up from basic principles. We will go over the problems with regular composed transformations, and show how we end up with unnecessary data and intermediate collections. We go on to learn how we can use transducers for performance gains when operating on large data sets, as well as how they’re an excellent fit for processing other iterable data, like generators. Not just arrays.

Chaining operations like `map` and `filter` on an array can have performance issues as we have to iterate through the whole array for every operation.

In this lesson we explore this problem by doing some basic array transformations and measuring their performance.

 We’ve got two utility function to help us with this:
* `arrayOfRandoms` is a higher order function which helps us create a range of random numbers
* `timeIt` will help us measure how long functions take to execute

It's important to understand this problem and why it occurs before we move on to how transducers handle it differently.

Understand why Transducers can Improve Performance

Now that we understand the problem transducers can help us with, it's time to define what they actually are.
A Transducer is a combination of two concepts, a *transform*, and a *reducer*. **Trans-Ducer**.
In this lesson we'll give a general overview of the *reducer* part of the puzzle. 


Write Reducers for Different Data Types


The next transducer building block we need to explore is a **transformer**. A transformer is a function that takes a value and returns a transformed version of it.

In this lesson, we cover some examples of transformer functions and use them with some basic composition. We'll follow the functional style of creating new values, avoiding mutations. Even though they're trivial functions, it's important to understand how they work, as soon we’ll be combining them with reducers to create transducers. 

Understand Transformer Functions

Two of the most useful operators when working with collections are `.map()` and `.filter()`. We want our **transducers** to be able to combine these operations in a single pass when iterating through our collections. To do this we need to find a commonality between the two, so we can treat them the same. To achieve this common ground, we'll create `map()` and `filter()` functions which use the built in `.reduce()` function under the hood instead, and we’ll start to combine the concepts of transforming and reducing.

Rewrite Map and Filter as Reducers

In our previous lesson, we created `map()` and `filter()` functions based on reduce, but we still couldn’t compose them together.

In this lesson, we’ll solve this by making these functions into transducers. This will let us compose the reducing behavior of `map()` and `filter()`, without coupling this composed transform to a data type.

Create Map and Filter Transducers

To make our composition more readable and easier to name we are going to ceate a `compose` function we can use to avoid having to manually nest our transducer calls. 

We'll also go over semantically naming your `compose` functions for extra readability. 


Improve Composition with the Compose Combinator

So far we've been transducing by manually calling `.reduce()` on arrays, but we want to be able to transduce over other collection types as well.

In this lesson we'll create a `transduce` function to support transducing over any data structure that implements the [es2015 iterable protocol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols). We’ll put it to the test by transducing over strings and maps, as well as going from one collection type as input to another as output.

Transduce over any Iteratable Collection

Our `transduce` function is powerful but requires a lot of boilerplate.
It would be nice if we had a way to transduce into arrays and objects without having to specify the inner reducer behaviour, i.e. how to build up values, since a given collection type will almost always have the same inner reducer.

In this lesson we'll being doing just that with an `into()` helper function that will know if an array or object collection is passed in and handle each case accordingly. 

Make an Into Helper to Remove Boilerplate and Simplify our Transduce API

We've seen how we can `transduce` from arrays or other iterables, but plain objects aren't iterable in Javascript.
In this lesson we'll modify our `transduce()` function so that it supports iterating from plain objects as well, treating each key value pair as an entry in the collection.

To do this we'll be using a **lodash** function called [entries](https://lodash.com/docs/4.17.4#toPairs). 

Transduce When the Collection Type is an Object

A frequent use case when transducing is to apply a transformation to items without changing the type of the collection.

In this lesson, we'll create a helper to do just that. `seq` will be similar to `into`, except the target type will be inferred from the source collection. For example, if transducing from an array, `seq` will create an array as the output collection as well.

`seq` is thus more restrictive and easier to consume than `into`.

Create a Sequence Helper to Transduce Without Changing Collection Types

Our helpers are now powerful enough to work with any data type as the source, but they can only build up arrays or objects as the target. For an arbitrary collection type, we thus have to fall back to our `transduce` function and manually specify the inner reducer behavior based on the API of our target collection. 

In this lesson, we'll add support for the transducer protocol, and see how it enables us to transduce into any collection type without having to fall back to using `transduce`. We'll use the `List` type from [Immutable.JS](https://facebook.github.io/immutable-js/) as our example.

Add the Transducer Protocol to Support Arbitrary Data Types as our Target Collections

Now that our transducer functions are functioning as expected, it’s time for another round of performance testing.
We’ll use the same `timeIt()` function from [Lesson One](https://egghead.io/lessons/javascript-understand-why-transducers-can-improve-performance) to see how our transducers compare to the Array built-in methods, an imperative solution, as well as the external transducer library [transducers.js](https://github.com/jlongster/transducers.js?files=1).


Measure the Performance of our Transducers

While it’s possible to use our transducers in production (after writing some tests!), I would recommend using a proven transducer library instead.

In this lesson, we’ll go through how to use [transducers.js](https://goo.gl/QpWAwT) from [James Long](https://goo.gl/e4Jtsr) instead of our functions. We’ll also cover some more advanced features which we didn't add support for ourselves, like short-circuiting iterations with the `take` transform as well as transducing lazily over iterables.

The aim is that you’ll be able to use these libraries with more confidence and better understanding since we’ve been through how things are working under the hood.

You can also check out [transducers-js](https://github.com/cognitect-labs/transducers-js) by [cognitect labs](https://github.com/cognitect-labs), which is very similar in its feature set to transducers.js.
And remember, you don’t have to rely solely on the transforms in the library, you can write your own as well, as long as you support the transducer protocol.

Quickly Transform Data with Transducers

Instructor

Course Content