Listable Error

trait BookmarkIterator extends Iterator[PDOutlineItem] {
  var node: Option[PDOutlineItem]
  def hasNext: Boolean = !node.isEmpty
  def next:PDOutlineItem =  {
    val item = node.get
    node = node.get.getNextSibling() match {
      case i:PDOutlineItem => i.some
      case _               => none
    }
    item
  }
}

object BookmarkIterator {
  def apply(i:PDOutlineItem) = new BookmarkIterator {
    var node = i.getFirstChild() match {
      case n:PDOutlineItem => n.some
      case _               => none
    }
  }
  def apply(o:PDDocumentOutline) = new BookmarkIterator {
    var node = o.getFirstChild() match {
      case i:PDOutlineItem => i.some
      case _               => none
    }
  }
  def apply(o:PDOutlineNode) = new BookmarkIterator {
    var node = o.getFirstChild() match {
      case i:PDOutlineItem => i.some
      case _               => none
    }
  }

  implicit def toOutlineIteratorA(o:PDOutlineNode):BookmarkIterator =
    BookmarkIterator(o)
  implicit def toOutlineIteratorB(i:PDOutlineItem):BookmarkIterator =
    BookmarkIterator(i)
  implicit def toOutlineIteratorC(d:PDDocumentOutline):BookmarkIterator =
    BookmarkIterator(d)
}

trait Listable[A] {
  def toList:List[A]
}

object ListablePimps {
  implicit def DocumentOutline(d:PDDocumentOutline)(implicit bi:BookmarkIterator) =
    new Listable[PDOutlineItem] {
      def toList = bi.toList
    }
  implicit def OutlineItemListable(o:PDOutlineItem)(implicit bi:BookmarkIterator) =
    new Listable[PDOutlineItem] {
      def toList = bi.toList
    }
}

trait BookmarkNode[+A]
case class BookmarkItem[A] (value:A) extends BookmarkNode[A]
case object BookmarkRoot extends BookmarkNode[Nothing]

object ToTree {
  import BookmarkIterator._

  def toTree[A](a:A)(implicit li:Listable[A]):Tree[BookmarkNode[A]] = {
    def toStream(l:List[A]):Stream[Tree[BookmarkNode[A]]] = l match {
      case Nil => Stream.empty
      case x :: xs => toTree(x)(li) #:: toStream(xs)
    }
    li.toList match {
      case Nil     => BookmarkItem(a).leaf
      case x :: xs => node(BookmarkItem(a), toTree(x) #:: toStream(xs))
    }
  }

  def toTree[A](l:List[A])(implicit li:Listable[A]):Tree[BookmarkNode[A]] =
    node(BookmarkRoot, (l ∘ ((a:A) =>
      toTree(a))).foldRight(Stream.empty[Tree[BookmarkNode[A]]])(_ #:: _))
}


object SPDF extends SPDFPimps {
  import BookmarkIterator._
  import ListablePimps._
  import ToTree._


  def test(vo:Option[BookmarkIterator]):Option[Tree[BookmarkNode[PDOutlineItem]]] =
    vo >>= ((bi:BookmarkIterator) => toTree(bi.toList))
}


[error] /home/eof/Projects/Circumflex/literoj/src/main/scala/models/SPDF.scala:184: could not find implicit value for parameter li: com.logikujo.spdf.Listable[org.apache.pdfbox.pdmodel.interactive.documentnavigation.outline.PDOutlineItem]
[error]     vo >>= ((bi:BookmarkIterator) => toTree(bi.toList))