Skip to content
/ fs2 Public
forked from typelevel/fs2

Compositional, streaming I/O library for Scala

License

Notifications You must be signed in to change notification settings

vilu/fs2

 
 

Repository files navigation

FS2: Functional Streams for Scala (previously 'Scalaz-Stream')

Build Status Gitter Chat Latest version

Quick links:

About the library

FS2 is a streaming I/O library. The design goals are compositionality, expressiveness, resource safety, and speed. Here's a simple example of its use:

import cats.effect.{IO, Sync}
import fs2.{io, text}
import java.nio.file.Paths

def fahrenheitToCelsius(f: Double): Double =
  (f - 32.0) * (5.0/9.0)

def converter[F[_]](implicit F: Sync[F]): F[Unit] =
  io.file.readAll[F](Paths.get("testdata/fahrenheit.txt"), 4096)
    .through(text.utf8Decode)
    .through(text.lines)
    .filter(s => !s.trim.isEmpty && !s.startsWith("//"))
    .map(line => fahrenheitToCelsius(line.toDouble).toString)
    .intersperse("\n")
    .through(text.utf8Encode)
    .through(io.file.writeAll(Paths.get("testdata/celsius.txt")))
    .run

// at the end of the universe...
val u: Unit = converter[IO].unsafeRunSync()

This will construct a F[Unit], converter, which reads lines incrementally from testdata/fahrenheit.txt, skipping blanklines and commented lines. It then parses temperatures in degrees Fahrenheit, converts these to Celsius, UTF-8 encodes the output, and writes incrementally to testdata/celsius.txt, using constant memory. The input and output files will be closed upon normal termination or if exceptions occur.

At the end it's saying that the effect F will be of type cats.effect.IO and then it's possible to invoke unsafeRunSync(). You can choose a different effect type or your own as long as it implements cats.effect.Sync for this case. In some other cases the constraints might require to implement interfaces like cats.effect.MonadError[?, Throwable], cats.effect.Async and / or cats.effect.Effect.

The library supports a number of other interesting use cases:

  • Zipping and merging of streams: A streaming computation may read from multiple sources in a streaming fashion, zipping or merging their elements using an arbitrary Tee. In general, clients have a great deal of flexibility in what sort of topologies they can define--source, sink, and effectful channels are all first-class concepts in the library.
  • Dynamic resource allocation: A streaming computation may allocate resources dynamically (for instance, reading a list of files to process from a stream built off a network socket), and the library will ensure these resources get released upon normal termination or if exceptions occur.
  • Nondeterministic and concurrent processing: A computation may read from multiple input streams simultaneously, using whichever result comes back first, and a pipeline of transformations can allow for nondeterminism and queueing at each stage.

Documentation and getting help

Blog posts and other external resources are listed on the Additional Resources page.

Where to get the latest version

The 0.9 release is out and we recommend upgrading. You may want to first read the migration guide if you are upgrading from 0.8 or earlier. To get 0.9, add the following to your SBT build:

// available for Scala 2.11.8, 2.12.0
libraryDependencies += "co.fs2" %% "fs2-core" % "0.9.6"

// optional I/O library
libraryDependencies += "co.fs2" %% "fs2-io" % "0.9.6"

The fs2-core library is also supported on Scala.js:

// available for Scala 2.11.8, 2.12.0
libraryDependencies += "co.fs2" %%% "fs2-core" % "0.9.6"

API docs:

The previous stable release is 0.8.4 (source).

Projects using FS2

If you have a project you'd like to include in this list, either open a PR or let us know in the gitter channel and we'll add a link to it here.

  • doobie: Pure functional JDBC built on fs2.
  • fs2-http: Http server and client library implemented in fs2.
  • http4s: Minimal, idiomatic Scala interface for HTTP services using fs2.
  • fs2-kafka: Simple client for Apache Kafka.
  • fs2-rabbit: Stream-based client for RabbitMQ built on top of Fs2.
  • scodec-stream: A library for streaming binary decoding and encoding, built using fs2 and scodec.
  • streamz: A library that supports the conversion of Akka Stream Sources, Flows and Sinks to and from FS2 Streams, Pipes and Sinks, respectively. It also supports the usage of Apache Camel endpoints in FS2 Streams and Akka Stream Sources, Flows and SubFlows.
  • fs2-zk: Simple Apache Zookeeper bindings for fs2.
  • fs2-reactive-streams: A reactive streams implementation for fs2.

Related projects

FS2 has evolved from earlier work on streaming APIs in Scala and Haskell and in Scala. Some influences:

Presentations, Blogs, etc.

See Additional resources.

Acknowledgments

YourKit

Special thanks to YourKit for supporting this project's ongoing performance tuning efforts with licenses to their excellent product.

About

Compositional, streaming I/O library for Scala

Resources

License

Stars

Watchers

Forks

Packages

No packages published

Languages

  • Scala 96.0%
  • Shell 4.0%