List transformations chaining maps can be optimized with a transducer, here an example in plain Javascript

transducer.js

var test = require('tape');

const double = n => n*2;
const addOne = n => n+1;
const excludeTen = n => n !== 10;
const listPush = (list, v) => {
    list.push(v);
    return list;
}
const mapReducer = mapFn =>
                    listHandler =>
                        (acc, v) => listHandler( acc, mapFn(v) )
const filterReducer = filterFn =>
                        listHandler =>    
                            (acc, v) => ( filterFn(v) ) ? listHandler( acc, v ) : acc;
                            
const pipeFns = (...fns) => 
    fns.reduce( (fnAcc, fnNext) =>  
        v => fnAcc( fnNext( v ) )
    )

const arr = [1,2,3,4];
const expected = [6,14,18];

console.log('should create the transformed array:');

test('mapping the list with each transformation function', function (t) {
    const res = arr
        .map(double)
        .map(addOne)
        .map(double)
        .filter(excludeTen)
    t.equal( res.toString(), expected.toString() );
    t.end()
});

test('reducing the list with each transformation function', function (t) {
    const res = arr
        .reduce( mapReducer( double )(listPush), [] )
        .reduce( mapReducer( addOne )(listPush), [] )
        .reduce( mapReducer( double )(listPush), [] )
        .reduce( filterReducer( excludeTen )(listPush), [] )
    t.equal(res.toString(),expected.toString());
    t.end()
});

test('reducing the list using a transducer', function (t) {
    const transducer = pipeFns( 
        mapReducer( double ), 
        mapReducer( addOne ), 
        mapReducer( double ), 
        filterReducer( excludeTen ) 
    ) 
    const res = arr
        .reduce( transducer(listPush) , [] )
    t.equal(res.toString(),expected.toString());
    t.end()
});