Source وFlow وSink

Akka Streams models a data pipeline as a graph of processing stages. The three core linear stages are Source (produces elements), Flow (transforms them), and Sink (consumes them).

A Source has one output, a Sink has one input, and a Flow has exactly one input and one output. Wiring them together describes what should happen, not when.

A Source[Out, Mat] emits elements of type Out and exposes a materialized value of type Mat. The simplest sources come from in-memory collections or ranges.

Until the stream is run, a Source is just an immutable blueprint that can be reused freely.

A Sink[In, Mat] consumes elements of type In. The materialized value often captures the result of consumption, such as a Future that completes when the stream finishes.

Sink.foreach runs a side effect per element; Sink.fold accumulates a single result.

A Flow[In, Out, Mat] sits between a Source and a Sink, transforming each element. Flows are reusable on their own and can be composed before being attached to any endpoint.

Here a Flow doubles integers and converts them to strings.

The via operator attaches a Flow to a Source, and to attaches a Sink. Connecting a Source directly to a Sink with to produces a RunnableGraph: a closed, runnable blueprint.

No elements move yet; this only describes the topology.

Use via to splice a Flow into the pipeline. A Source.via(flow) yields a new Source whose output type matches the Flow's output.

Chaining via calls lets you build long transformation pipelines from small, testable Flow pieces.

The compiler enforces that the output type of each stage matches the input type of the next. A Source[Int] cannot connect to a Sink[String] without an intervening Flow that converts the type.

This static checking catches pipeline wiring mistakes before runtime.

Each blueprint carries a materialized value: a handle produced when the stream runs. A Sink.fold materializes a Future of the result. By default, combining stages keeps the leftmost materialized value (NotUsed for plain sources).

Use toMat and Keep to select which side's value you want.

Because Sources, Flows, and Sinks are immutable values, you can define them once and reuse them across many pipelines. This encourages a library of small, named processing stages.

A Flow defined for parsing can be inserted into both a file pipeline and an HTTP pipeline.

Akka Streams ships many Source factories: Source.single, Source.repeat, Source.tick for timed emission, Source.future from a Future, and Source.empty.

Choosing the right constructor makes the intent of a data producer explicit.

Likewise, sinks include Sink.head (first element as a Future), Sink.seq (collect all into a Seq), Sink.ignore (drain and discard), and Sink.last.

For pipelines that feed a result back to your code, Sink.seq and Sink.fold are the most common.

Test your understanding of the linear stage types.

You learned the three linear building blocks: Source produces, Flow transforms, and Sink consumes. They are immutable, reusable blueprints connected with via and to.

Connecting a Source to a Sink yields a RunnableGraph that carries a materialized value but does not move any data until run. Next you will transform streams with richer operators.