Understanding Accumulator in Play Framework (Scala)

"🔹 What is an Accumulator? In Play, an Accumulator represents a streaming computation that consumes incoming request body chunks and eventually produces a result. Its type is: Accumulator[E, A] E: the type of incoming chunks (often ByteString) A: the final result once the stream completes (often a Result) Think of it as a pipe: It gathers chunks of request data → processes them asynchronously → produces a final response."

"🔹 Why Do We Need It? HTTP request bodies can be large: Big JSON payloads File uploads Streaming data Instead of loading everything into memory, Play processes the body incrementally (streaming). The Accumulator abstracts this mechanism so developers don't have to manage the low-level stream handling."

"🔹 Example 1: Counting Request Body Size import akka.util.ByteStringimport akka.stream.scaladsl.Sinkimport play.api.libs.streams.Accumulatorimport play.api.mvc._ val countAction: Action[ByteString] = Action { _ => acc val acc: Accumulator[ByteString, Result] =} Accumulator( Sink.fold(0)((count, chunk: ByteString) => count + chunk.length) ).map { totalBytes => Results.Ok(s"Request body size: $totalBytes bytes") } Here: Each ByteString chunk is counted. At the end, the total byte size is returned."

An Accumulator in Play is a streaming computation that consumes chunks of a request body and yields a final value. Its type is Accumulator[E, A], where E is the chunk type (often ByteString) and A is the final result (often Result). Accumulators enable incremental processing of large HTTP bodies such as big JSON payloads, file uploads, or streaming data to avoid loading everything into memory. Examples include folding incoming ByteString chunks to count total bytes and mapping the final count to an HTTP Result, or immediately returning a Result using Accumulator.done when the body is irrelevant.

Read at Medium