var key = R.prop('key')
var value = R.prop('value')
var window2 = R.aperture(2)
var nullary = R.nAry(0)

var __ = flyd
function Integer() {}
function Categorical() {}
function Color() {}
var defined = R.complement(R.isNil)

// lookup :: dByFunction -> array -> d -> array[d(dByFunction)]
var lookup = R.flip(R.useWith(R.compose, [R.flip(R.prop), R.call]))

_.tupleOf = _(R.unapply(R.identity))

var exitRemove = _(function(binding) {binding.exit().remove()})
var entered = _(function(binding) {return binding.entered})

function url(string) {
    return 'url(#' + string + ')'
}

function streamBind(stream, cssClass, element, data) {
    return __([stream], function() {
        return bind0(stream(), cssClass, element, data)
    })
}

function $(constant) {
    return _(R.always(constant))()
}

function bind(stream, cssClass, element, data) {
    return __([stream, data], function() {
        return bind0(stream(), cssClass, element, data())
    })
}

var streamsAttr = R.curry(function(stream, attrName, attrFunStream) {
    return _(function(stream, attrFunStream) {
        stream.attr(attrName, attrFunStream)
    })(stream, attrFunStream)
})

var easeCategories = ['elastic', 'cubic-out', 'cubic-in', 'cubic-in-out', 'linear', 'bounce']

var compose2 = R.curry(R.binary(R.compose))
var pipe2 = R.curry(R.binary(R.pipe))

// vectorAddMultiply :: [a] -> [b] -> m -> [a] * m + [b]
var vectorAddMultiply = R.curry(R.compose(compose2(R.map(R.apply(R.add))), R.apply(R.useWith(R.call, [R.compose(pipe2(R.zip), R.compose(pipe2, pipe2(R.multiply), R.flip(R.map))), R.identity])), R.pair))


var oldStreamsAttrs = R.compose(pipe2(R.toPairs), R.forEach, R.apply, streamsAttr)
var setAttributes = R.curry(function(binding, attrsObj) {
    oldStreamsAttrs(binding)(attrsObj)
})

var transitionAttribute = R.curry(function(durationStream, easeStream, stream, attrName, attrFunStream) {
    return _(function(stream, attrFun, duration, ease) {
        stream.entered.attr(attrName, attrFun)
        stream.transition().duration(duration).ease(ease).attr(attrName, attrFun)
    })(stream, attrFunStream, durationStream || $(250), easeStream || $('cubic-out'))
})

var setText = _(function(stream, attrFunStream) {
    stream.text(attrFunStream)
})

R.compose2 = compose2
var r = R.fromPairs(R.map(function(pair) {return [pair[0], R.curry(R.nAry(pair[1].length, _(pair[1])))]})(R.filter(function(pair) {return typeof pair[1] === 'function' && pair[1].length > 0})(R.toPairs(R))))

var of = $(R.of)

var makeScale = R.curry(function(scale, domain, range) {
    return scale.domain(domain).range(range)
})

function _(fun) {
    function streamify(fun) {
        return function(/* stream1, stream2, .. , streamN  */) {
            var streams = Array.prototype.slice.call(arguments)
            var i
            var values = []
            return __(streams, function () {
                for (i = 0; i < streams.length; i++) values[i] = streams[i]()
                return fun.apply(undefined, values)
            })
        }
    }
    var result = streamify(fun)
    return R.curry(result)
}

var rnorm = function(bias, pow) {
    // using a mu just to avoid the special case of 0 centering
    return bias + (Math.random() > 0.5 ? 1 : -1) * Math.pow(Math.abs(
                Math.random() + Math.random() + Math.random()
                + Math.random() + Math.random() + Math.random() - 3) / 3, pow)
}

function bind0(rootSelection, cssClass, element, dataFlow) {
    if(!cssClass) {throw Error('cssClass must be defined.')}
    element = element || 'g' // fixme switch from variadic to curried
    dataFlow = typeof dataFlow === 'function' ? dataFlow
        : (dataFlow === void(0) ? function(d) {return [d]} : R.always(dataFlow))
    var binding = rootSelection.selectAll('.' + cssClass).data(dataFlow, key)

    binding.entered = binding.enter().append(element)
    binding.entered.classed(cssClass, true)

    return binding
}

function translate(funX, funY) {
    return function(d, i) {
        var x = typeof funX === 'function' ? funX(d, i) : funX
        var y = typeof funY === 'function' ? funY(d, i) : funY
        if(isNaN(x)) throw Error('x is NaN')
        if(isNaN(y)) throw Error('y is NaN')
        return 'translate(' + x + ',' + y + ')'
    }
}

function translateX(funX) {
    return function(d, i) {
        return 'translate(' + (typeof funX === 'function' ? funX(d, i) : funX) + ', 0)'
    }
}

function translateY(funY) {
    return function(d, i) {
        return 'translate(0, ' + (typeof funY === 'function' ? funY(d, i) : funY) + ')'
    }
}

var toColor = _(function(a) {
    return R.type(a) === 'String' ? a : 'rgb(' + a.map(Math.round).join(',') + ')'
})