mattroberts297

git clone [email protected]:akka/akka.git
cd akka
sbt ";project akka-docs; paradox"
open akka-docs/target/paradox/site/main/index.html

mattroberts297

git clone git clone https://github.com/akka/akka-http.git
cd akka-http
sbt ";project docs; paradox"
open docs/target/paradox/site/main/index.html

mattroberts297

package object types {
  type Or[+A, +B] = Either[A, B]

  object Or {
    import cats.syntax.either._
    import cats.Traverse

    def left[A, B](a: A): A Or B = Either.left(a)
    def right[A, B](b: B): A Or B = Either.right(b)

mattroberts297

For comprehensions don't do a good job with type inference when exploding tuples. Instead they pattern match. See https://stackoverflow.com/questions/30401942/why-does-a-for-comprehension-expand-to-a-withfilter/45768795#45768795

mattroberts297

package com.example.syntax

import scala.concurrent.{ExecutionContext, Future}

object FutureExample {
  import future._
  def foobar(implicit ec: ExecutionContext): Future[String] = Future.recover {
    for {
      f <- Future.failed(new RuntimeException("Foo"))
    } yield {

mattroberts297

import scala.concurrent.{ExecutionContext, Future}

object AlternativeFutureExample {
  def foobar(implicit ec: ExecutionContext): Future[String] = {
    for {
      f <- Future.failed(new RuntimeException("Foo"))
    } yield {
      f
    }
  } recover {

mattroberts297

import scala.concurrent.ExecutionContext
import scala.concurrent.Future

object EvenHarderExample {
  import Types._

  trait FooRepo {
    def foo()(implicit ec: ExecutionContext): Future[Error Or Foo]
  }

mattroberts297

def signup
    (request: HttpRequest): Future[HttpResponse] =
  for {
    r <- parse(request)
   _ = info(“Parsed body”)
    s <- salt(512)
   _ = info(“Created salt”)
    h <- hash(r.p, s, 10000)
   _ = info(“Created hash”)
    u =  User(r.e, h, s)

mattroberts297

case class WriteLog(log: Log)
  extends SignupA[LogError Or Success]

case object LogError extends SignupError
type LogError = LogError.type

def log(l: Log):
Signup[LogError Or Success] =
  liftS(WriteLog(l))

mattroberts297

def signupImpl
    [F[_], A: IsParseable[F, ?], B: HasCodes]
    (a: A): Signup[SignupError Or B] =
  OrT.value {
    for {
      r <- parse(a)                     |> OrT.lift
      _ <- log(info("Parsed body"))     |> OrT.lift
      s <- salt(512)                    |> OrT.lift
      _ <- log(info("Created salt"))    |> OrT.lift
      h <- hash(r.p, s, 10000)          |> OrT.lift