Examples

//> using toolkit typelevel:0.1.25

import cats.effect._
import io.circe.Decoder
import fs2.Stream
import fs2.io.file._
import org.http4s.ember.client._
import org.http4s._
import org.http4s.implicits._
import org.http4s.circe._

object Main extends IOApp.Simple {
  case class Data(value: String)
  implicit val json: Decoder[Data]          = Decoder.forProduct1("data")(Data.apply)
  implicit val enc: EntityDecoder[IO, Data] = jsonOf[IO, Data]

  def run = EmberClientBuilder.default[IO].build.use { client =>
    val request: Request[IO] =
      Request(Method.POST, uri"https://httpbin.org/anything")
        .withEntity("file.txt bunchofdata")

    client
      .expect[Data](request)
      .map(_.value.split(" "))
      .flatMap { case Array(fileName, content) =>
        IO.println(s"Writing data to $fileName") *>
          Stream(content)
            .through(fs2.text.utf8.encode)
            .through(Files[IO].writeAll(Path(fileName)))
            .compile
            .drain
      }
  }
}

//> using toolkit typelevel:0.1.25

import cats.effect._
import cats.syntax.all._
import com.monovore.decline._
import com.monovore.decline.effect._
import fs2._
import fs2.io._

// inspired by list.mkString
object Main extends CommandIOApp("mkString", "Concatenates strings from stdin") {
  val prefix    = Opts.option[String]("prefix", "").withDefault("")
  val delimiter = Opts.option[String]("delimiter", "", "d").withDefault(",")
  val suffix    = Opts.option[String]("suffix", "The suffix").withDefault("")

  val stringStream: Stream[IO, String] = stdinUtf8[IO](1024 * 1024 * 10)
    .repartition(s => Chunk.array(s.split("\n", -1)))
    .filter(_.nonEmpty)

  def main = (prefix, delimiter, suffix).mapN { (pre, delim, post) =>
    val stream = Stream(pre) ++ stringStream.intersperse(delim) ++ Stream(post)
    stream.foreach(IO.print).compile.drain.as(ExitCode.Success)
  }
}

//> using toolkit typelevel:0.1.25

import cats.effect._
import fs2.text
import fs2.data.csv._
import fs2.data.csv.generic.semiauto._
import fs2.io.file.{Path, Flags, Files}
import cats.data.NonEmptyList

case class Passenger(
    id: Long,
    firstName: String,
    age: Either[String, Int],
    flightNumber: String,
    destination: String
)

object Passenger {
  // Here we define a manual decoder for each row in our CSV
  implicit val csvRowDecoder: CsvRowDecoder[Passenger, String] =
    new CsvRowDecoder[Passenger, String] {
      def apply(row: CsvRow[String]): DecoderResult[Passenger] =
        for {
          id <- row.as[Long]("id")
          firstName <- row.as[String]("First Name")
          ageOpt <- row.asOptional[Int]("Age")
          flightNumber <- row.as[String]("flight number")
          destination <- row.as[String]("destination")
        } yield {
          val age = ageOpt.toRight[String]("N/A")
          Passenger(id, firstName, age, flightNumber, destination)
        }
    }

  // Here we define a manual encoder for encoding Passenger classes to a CSV
  implicit val csvRowEncoder: CsvRowEncoder[Passenger, String] =
    new CsvRowEncoder[Passenger, String] {
      def apply(p: Passenger): CsvRow[String] =
        CsvRow.fromNelHeaders(
          NonEmptyList.of(
            (p.firstName, "first_name"),
            (p.age.toString(), "age"),
            (p.flightNumber, "flight_number"),
            (p.destination, "destination")
          )
        )
    }
}

object CSVPrinter extends IOApp.Simple {
  val input = Files[IO]
    .readAll(Path("./example.csv"), 1024, Flags.Read)
    .through(text.utf8.decode)
    .through(decodeUsingHeaders[Passenger]())


  /** First we'll do some logging for each row,
    * and then calculate and print the mean age */
  val run =
    input
      .evalTap(p =>
        IO.println(
          s"${p.firstName} is taking flight: ${p.flightNumber} to ${p.destination}"
        )
      )
      .collect({ case Passenger(_, _, Right(age), _, _) => age })
      .foldMap(age => (age, 1))
      .compile
      .lastOrError
      .flatMap({ case (sum, count) =>
        IO.println(s"The mean age of the passengers is ${sum / count}")
      })
}

//> using toolkit typelevel:0.1.25

import cats.effect.{IO, IOApp}
import fs2.{Stream, text}
import fs2.io.file.{Files, Path}

object PerftConverter extends IOApp.Simple {

  val converter: Stream[IO, Unit] = {
    def raw2Perft(id: Long, raw: String): String = {
      val list = raw.split(";").zipWithIndex.map {
        case (epd, 0) => s"epd ${epd}"
        case (s, i)   => s"perft $i ${s.split(" ")(1)}"
      }
      list.mkString(s"id $id\n", "\n", "\n")
    }

    Files[IO]
      .readUtf8Lines(Path("fischer.epd"))
      .filter(s => !s.trim.isEmpty)
      .zipWithIndex
      .map { case (x, i) => raw2Perft(i, x) }
      .intersperse("\n")
      .through(text.utf8.encode)
      .through(Files[IO].writeAll(Path("chess960.perft")))
  }

  def run: IO[Unit] = converter.compile.drain
}

case class YourCaseClass(n: String, i: Int)
implicit val csvRowEncoder: CsvRowEncoder[YourCaseClass, String] = deriveCsvRowEncoder

object Helpers {
  // Writes a case class as a csv given a path.
  def writeCaseClassToCsv[A](
    path: Path
  )(implicit encoder: CsvRowEncoder[A, String]): Pipe[IO, A, Nothing] =
    _.through(encodeUsingFirstHeaders(fullRows = true))
      .through(fs2.text.utf8.encode)
      .through(Files[IO].writeAll(path))
}

//> using toolkit typelevel:0.1.25

import fs2.data.csv._
import fs2.data.csv.generic.semiauto._
import fs2.io.file.{Files, Path}
import cats.effect.{IO, IOApp}
import fs2.{Pipe, Stream}

object Helpers {
  def writeCaseClassToCsv[A](
      path: Path
  )(implicit encoder: CsvRowEncoder[A, String]): Pipe[IO, A, Nothing] =
    _.through(encodeUsingFirstHeaders(fullRows = true))
      .through(fs2.text.utf8.encode)
      .through(Files[IO].writeAll(path))
}

object WriteBooksToCsv extends IOApp.Simple {
  case class Book(id: Long, name: String, isbn: String)
  implicit val csvRowEncoder: CsvRowEncoder[Book, String] = deriveCsvRowEncoder

  val input = Seq(
    Book(1, "Programming in Scala", "9780997148008"),
    Book(2, "Hands-on Scala Programming", "9798387677205"),
    Book(3, "Functional Programming in Scala", "9781617299582")
  )

  def run: IO[Unit] =
    Stream
      .emits(input)
      .through(Helpers.writeCaseClassToCsv(Path("books.csv")))
      .compile
      .drain *> IO.println("Finished writing books to books.csv.")
}