Q:

pointfree style for a conditional function

I would love some assistance in writing this in pointfree style.  
For context: The function takes an Array of Either types and returns a Task type.  The task type is rejected with any of the Either types that have the left set.   The task type is resolved if there are no Either types with the left set.  This is used in this manner: 
    Async.parallel(xs).              
        map(eachToEither).           
        chain(rejectAnyLefts).       
        fork(error, success)

Where in practice I would add another chain (just prior to the fork) to perform a perist.   But first I want make sure my code is idimatic as possible.   The function at hand is the rejectAnyLefts which I would like to write pointfree, but there are a couple of things throwing me to the loop.   

the if 
the need for storing the leftObjs value to be used in the IF and potentially the return value

const rejectAnyLefts = function(eitherArray){
    const leftObjs = r.filter(r.propEq("isLeft", true), eitherArray)

    const isEmpty = r.propEq('length', 0)
    return (isEmpty(leftObjs)) ? 
        Task.rejected(leftObjs) :
        Task.of(eitherArray)
}

A:

If you were only interested in capturing the first Left value then this could be defined using R.sequence which will convert a [Either a b] into an Either a [b]. 
R.pipe(R.sequence(Either.of), R.invoker(2, 'fold', Task.rejected, Task.of));

A Validation type could be used rather than Either which will instead combine all of the Failure values, however this would require the value in your Failure types to implement Semigroup to allow them to be combined. 
To capture and reject all Left values, we can model your existing implementation in a point-free form such as:
R.pipe(R.partition(R.prop('isLeft')),
       R.ifElse(R.pipe(R.head, R.isEmpty),
                R.pipe(R.last, Task.of),
                R.pipe(R.head, Task.rejected)));

Whether this becomes more or less readable than your existing implementation is largely subjective.