 <p>Here is one way to achieve this by folding within the <code>Iteratee</code> and an appropriate (kind-of) State accumulator (a tuple here)</p> <p>I go read the <code>routes</code> file, the first byte will be read as a <code>Char</code> and the other will be appended to a <code>String</code> as UTF-8 bytestrings.</p> <pre><code> def index = Action { /*let's do everything asyncly*/ Async { /*for comprehension for read-friendly*/ for ( i &lt;- read; /*read the file */ (r:(Option[Char], String)) &lt;- i.run /*"create" the related Promise and run it*/ ) yield Ok("first : " + r._1.get + "\n" + "rest" + r._2) /* map the Promised result in a correct Request's Result*/ } } def read = { //get the routes file in an Enumerator val file: Enumerator[Array[Byte]] = Enumerator.fromFile(Play.getFile("/conf/routes")) //apply the enumerator with an Iteratee that folds the data as wished file(Iteratee.fold((None, ""):(Option[Char], String)) { (acc, b) =&gt; acc._1 match { /*on the first chunk*/ case None =&gt; (Some(b(0).toChar), acc._2 + new String(b.tail, Charset.forName("utf-8"))) /*on other chunks*/ case x =&gt; (x, acc._2 + new String(b, Charset.forName("utf-8"))) } }) } </code></pre> <p><strong>EDIT</strong></p> <p>I found yet another way using <code>Enumeratee</code> but it needs to create 2 <code>Enumerator</code> s (one short lived). However is it a bit more elegant. We use a "kind-of" Enumeratee but the <code>Traversal</code> one which works at a finer level than Enumeratee (chunck level). We use <code>take</code> 1 that will take only 1 byte and then close the stream. On the other one, we use <code>drop</code> that simply drops the first byte (because we're using a Enumerator[Array[Byte]])</p> <p>Furthermore, now <code>read2</code> has a signature much more closer than what you wished, because it returns 2 enumerators (not so far from Promise, Enumerator)</p> <pre><code>def index = Action { Async { val (first, rest) = read2 val enee = Enumeratee.map[Array[Byte]] {bs =&gt; new String(bs, Charset.forName("utf-8"))} def useEnee(enumor:Enumerator[Array[Byte]]) = Iteratee.flatten(enumor &amp;&gt; enee |&gt;&gt; Iteratee.consume[String]()).run.asInstanceOf[Promise[String]] for { f &lt;- useEnee(first); r &lt;- useEnee(rest) } yield Ok("first : " + f + "\n" + "rest" + r) } } def read2 = { def create = Enumerator.fromFile(Play.getFile("/conf/routes")) val file: Enumerator[Array[Byte]] = create val file2: Enumerator[Array[Byte]] = create (file &amp;&gt; Traversable.take[Array[Byte]](1), file2 &amp;&gt; Traversable.drop[Array[Byte]](1)) } </code></pre>