I think this can be made simpler by getting rid of tailrec.  It looks like this will hit a max stack of log(items.size).

```
def parSumOption[T](items: TraversableOnce[T], blockSize: Int)
  (implicit sg: Semigroup[T], pool: FuturePool): Future[Option[T]] = {
  require(blockSize > 0, "block size must be positive")

  def helper(items: Iterator[T]): Future[Option[T]] = {
    val grouped = items.grouped(blockSize).buffered
    val head = grouped.head
    if (head.size < blockSize) {
      Future.value(sg.sumOption(items))
    }
    else {
      Future.collect(grouped.map { pool(sg.sumOption(_)) }) flatMap { iter: Iterator[Option[A]] => help(iter.flatten) }
    }

  if (items.isEmpty)
    Future.value(None)
  else {
    helper(items.iterator)
  }
}
```
or:
```
def parSumOption[T](items: Traversable[T])(implicit sg: Semigroup[T]): Option[T] =
  sumOption(items.par)
```
:trollface: