Expressions
by Jean-Rémi Desjardins
A need for Futures that "fail fast"
History
bind or flatMap cannot "fail-fast"
History
See my talk at PNWScala
Bind cannot "fail-fast"
trait Monad[F[_]] {
def bind[A,B](fa: F[A])(f : a => F[B]): F[B]
}
Expressions are an alternative to for-comprehensions that support failing fast among a few other things
Examples
Fails fast
val a: Future[A]
val b: Future[B]
val c: Future[C]
Fails fast
for {aa <- a
bb <- b
cc <- c} yield combine(a, b, c)
val a: Future[A]
val b: Future[B]
val c: Future[C]
Fails fast
for {aa <- a
bb <- b
cc <- c} yield combine(a, b, c)
Expression { combine(a,b,c) }
val a: Future[A]
val b: Future[B]
val c: Future[C]
Plays well with if and match
val a: Future[A]
val b: Future[B]
val c: Future[C]
Plays well with if and match
for {aa <- a
bb <- b
cc <- c} yield if (aa == something) polish(bb) else polish(cc)
val a: Future[A]
val b: Future[B]
val c: Future[C]
Plays well with if and match
for {aa <- a
bb <- b
cc <- c} yield if (aa == something) polish(bb) else polish(cc)
(for (aa <- a) yield
if (aa == something) for (bb <- b) yield polish(bb)
else for (cc <- c) yield polish(cc)).flatMap(identity)
val a: Future[A]
val b: Future[B]
val c: Future[C]
Plays well with if and match
for {aa <- a
bb <- b
cc <- c} yield if (aa == something) polish(bb) else polish(cc)
(for (aa <- a) yield
if (aa == something) for (bb <- b) yield polish(bb)
else for (cc <- c) yield polish(cc)).flatMap(identity)
val a: Future[A]
val b: Future[B]
val c: Future[C]
Expression { if(extract(a) == something) polish(b) else polish(c) }
Not a replacement for for-comprehensions
def time[A](task: Task[A]): Task[(Duration, A)] = for {
t1 <- Task.delay(System.currentTimeMillis)
a <- task
t2 <- Task.delay(System.currentTimeMillis)
} yield ((t2 - t1).milliseconds, a)
Example from Remotely
When to use them
Write Async code
val response: Future[HTML] = Expression {
val phone = extract(lookupPhone(phoneString))
val address = extract(lookupAddress(phone))
val rep = extract(lookupReputation(phone))
renderPage(phone, address, rep)
}
But what about a single unified notation
-
That supports:
-
Monad
-
Applicative Functor
-
Functor
-
conceivably others
-
Wouldn't that be nice Professor? One single elegant equation to explain everything?
Not only does that reduce cognitive overload, but it is more powerful
- Monad cannot support fail-fast for Futures
- The more expressive an abstraction, the less flexible it is in it's implementation
-
Our notation should use the least powerful abstraction that is required
- This allows maximum flexibility to implement behavior of combinators
Why Monad cannot fail fast
trait Monad[F[_]] {
def bind[A,B](m: F[T], f: A => F[B]): F[B]
}
What does it look like
val phoneString: String = ???
val lookupPhone: String => Future[Phone] = ???
val lookupAddress: Phone => Future[Address] = ???
val lookupReputation: Phone => Future[Score] = ???
val renderPage: (Phone, Address, Int) => HTML = ???
val response: Future[HTML] = Expr {
val phone = lookupPhone(phoneString)
val address = lookupAddress(phone)
val rep = lookupReputation(phone)
renderPage(phone, address, rep)
}
Uses Scala implicit resolution to mirror Idris behavior but can be made explicit
import com.github.jedeash.Expr
import com.github.jedesah.Expr.extract
val phoneString: String = ???
val lookupPhone: String => Future[Phone] = ???
val lookupAddress: Phone => Future[Address] = ???
val lookupReputation: Phone => Future[Score] = ???
val renderPage: (Phone, Address, Int) => HTML = ???
val response: Future[HTML] = Expr {
val phone = extract(lookupPhone(phoneString))
val address = lookupAddress(phone)
val rep = lookupReputation(phone)
renderPage(phone, extract(address), extract(rep))
}
Explicit
Implicit
import com.github.jedeash.Expr
import com.github.jedesah.Expr.auto.extract
val phoneString: String = ???
val lookupPhone: String => Future[Phone] = ???
val lookupAddress: Phone => Future[Address] = ???
val lookupReputation: Phone => Future[Score] = ???
val renderPage: (Phone, Address, Int) => HTML = ???
val response: Future[HTML] = Expr {
val phone = lookupPhone(phoneString)
val address = lookupAddress(phone)
val rep = lookupReputation(phone)
renderPage(phone, address, rep)
}
Prior Art
-
Effectful*
-
Replacement for for-comprehension
-
Generalizes Async/Await
-
Only supports Monad
-
-
Scala Workflow*
-
Supports everything I do and more
-
Uses untyped macros
-
Reimplements parts of scalac including scoping which leads to minimal coverage of the language
-
*https://github.com/pelotom/effectful
*https://github.com/aztek/scala-workflow/
Scala Computation Expressions
- https://github.com/jedesah/computation-expressions
- Releasing 0.1.0 today (version and date may change)
Thought: Towards automatic code parallelization
- One of the promises of purely functional programming
- Tried by Facebook with FXL
- Computation Expressions do a lot to bring us there
Thank you
Questions, comments?
Computation Expressions
By Jean-Rémi Desjardins
Computation Expressions
- 1,313