Async and Concurrent Error Handling & Cancellation

All programs contain side effects. They load data from network, persist to a database, log to console, and display information on screen. In this talk, we will learn how side effects break determinism, and how that smashes our ability to reason about our programs.

Then, we will move onto how we can keep those effects under control using the powers of IO, and how to use the DSL ArrowFx provides to write any pure functional program with a simple syntax.

This presentation was given by Jorge Castillo as part of the 47 Degrees Academy. You can watch the talk in full here: https://www.youtube.com/watch?v=UkcEXUlycC8

1. Programs All
programs
have
a
happy
path
vs
an
error
path. A
path
we
want
to
follow,
vs
an
"alternative"
one
3. Railway
oriented programming

4. Railway
oriented
programming By
Scott
Wlaschin
from
11
May
2013 
Post
 
 
Talk
video
+
slides
 
 fsharpforfunandpro t.com/posts/recipe-part2/ fsharpforfunandpro t.com/rop/
7. Code
representation Either<A,
B>
models
this
scenario. Note
how
Nothing
is
used Biased
towards
the
Right
case
 sealed
class
Either<out
A,
out
B>
{
 

data
class
Left<out
A>(val
a:
A)
:
Either<A,
Nothing>()
 

data
class
Right<out
B>(val
b:
B)
:
Either<Nothing,
B>()
 }
8. Our
program
-
Success Target
platform:
JVM Running
on
Arrow
v.
0.10.5 Running
on
Kotlin
v.
1.3.50 fun
loadSpeaker(id:
SpeakerId):
Either<SpeakerNotFound,
Speaker>
=
 



Speaker(id,
"SomeName",
listOf("talk1",
"talk2",
"talk3")) 







.right() fun
main():
Unit
{ 

val
speaker
=
loadSpeaker("SomeId") 

println(speaker) }

9. Our
program
-
Error Target
platform:
JVM Running
on
Arrow
v.
0.10.5 Running
on
Kotlin
v.
1.3.50 fun
loadSpeaker(id:
SpeakerId):
Either<SpeakerNotFound,
Speaker>
=
 



SpeakerNotFound.left() fun
main():
Unit
{ 

val
speaker
=
loadSpeaker("SomeId") 

println(speaker) }

10. Our
program
-
chain
ops Target
platform:
JVM Running
on
Arrow
v.
0.10.5 Running
on
Kotlin
v.
1.3.50 fun
loadTalks(ids:
List<TalkId>):
Either<InvalidSpeakerId,
List<Talk>>
= 



listOf( 





Talk(45,
"Some
talk
script"), 





Talk(50,
"Another
talk
script")).right() fun
main()
{ 

val
talks
=
loadSpeaker("SomeId") 








.flatMap
{
loadTalks(it.talkIds)
} 

println(talks) }

11. Chain
ops
-
binding Target
platform:
JVM Running
on
Arrow
v.
0.10.5 Running
on
Kotlin
v.
1.3.50 fun
main()
{ 

val
talks
=
Either.fx<Error,
List<Talk>>
{ 



val
speaker
=
!loadSpeaker("SomeId") 



val
talks
=
!loadTalks(speaker.talks) 



talks 

} 

println(talks) }
12. Fail
fast First
operation
fails
 
short
circuit Target
platform:
JVM Running
on
Arrow
v.
0.10.5 Running
on
Kotlin
v.
1.3.50 fun
main()
{ 

val
events
=
Either.fx<Error,
List<Event>>
{ 



val
speaker
=
!loadSpeaker("SomeId") 



val
talks
=
!loadTalks(speaker.talkIds) 



val
events
=
talks.map
{
!loadEvent(it.event)
} 



events 

} 

println(events) }
13. Error
accumulation? Interested
in
all
errors
occurring,
not
a
single
one. Only
in
the
context
of
independent
computations.
16. Validated
&
ValidatedNel Note
how
Nothing
is
used Biased
towards
the
Valid
case
 sealed
class
Validated<out
E,
out
A>
{
 

data
class
Valid<out
A>(val
a:
A)
:
Validated<Nothing,
A>()
 

data
class
Invalid<out
E>(val
e:
E)
:
Validated<E,
Nothing>()
 }
 
 typealias
ValidatedNel<E,
A>
=
Validated<NonEmptyList<E>,
A>
17. Validated
&
ValidatedNel Target
platform:
JVM Running
on
Arrow
v.
0.10.5 Running
on
Kotlin
v.
1.3.50 fun
validateTalk(talk:
Talk):
ValidatedNel<Error,
Talk>
= 



if
(talk.script.length
<
25)
{ 







Error.ScriptTooShort.invalidNel() 



}
else
if
(talk.script.contains("ugly
words"))
{ 







Error.ViolatesCodeOfConduct.invalidNel() 



}
else
if
(talk.duration
>
45)
{ 







Error.TalkTooLong.invalidNel() 



}
else
{ 







talk.validNel() 



} val
res1
=
validateTalk(Talk(45,
"Some
too
short
script",
"EventId1")) val
res2
=
validateTalk(Talk(45,
"This
is
a
long
enough
script
but
with
ugly
words",
"EventId2")) val
res3
=
validateTalk(Talk(60,
"This
is
a
long
enough
script",
"EventId3"))
18. Background
computation
19. Either
limitations Often
used
in
the
context
of
a
background
computation. The
data
type
cannot
express
that
by
itself,
so
you
depend
on the
surrounding
context. Same
limitations
for
Validated.
20. Either
within
executor
thread val
speakerService
=
SpeakerService() val
executor
=
Executors.newFixedThreadPool(4) val
callback:
(Either<Error,
Speaker>)
->
Unit
=
{
either
-> 



either.fold( 







ifLeft
=
{
error
->
println(error)
}, 







ifRight
=
{
speaker
->
println(speaker)
} 



) } executor.execute
{ 



val
speaker
=
speakerService.loadSpeaker("SomeId") 



callback(speaker) }
21. Either
within
executor
thread Far
from
ideal
 
 
 
wiring
results
with
a
callback. Mixing
sync
and
async
programming.
22. Either
within
stdlib
coroutine Better,
but
cancellation?
 KotlinX
Coroutines
required,
or
an
alternative
runtime library. Target
platform:
JVM Running
on
Arrow
v.
0.10.5 Running
on
Kotlin
v.
1.3.50 suspend
fun
main()
{
//
kotlin
suspend
main 

val
speakerService
=
SpeakerService() 

val
speaker
=
speakerService.loadSpeaker("SomeId") 

speaker.fold( 



ifLeft
=
{
println(it)
}, 



ifRight
=
{
println(it)
} 

) }
23. Either
within
IO disposable()
for
cancellation. Target
platform:
JVM Running
on
Arrow
v.
0.10.5 Running
on
Kotlin
v.
1.3.50 fun
main()
{ 

val
speakerService
=
SpeakerService() 

val
speaker
=
IO
{
speakerService.loadSpeaker("SomeId")
} 

val
disposable
=
speaker.unsafeRunAsyncCancellable
{ 



it.fold( 





ifLeft
=
{
error
->
println(error)
}, 





ifRight
=
{
speaker
->
println(speaker)
} 



) 

} }
24. IO<Either<A,
B>> 
Defers
computation
 
declarative
stack
you
can
compose on,
pass
around. 
Supports
cancellation. ✅
Safety
environment
(side
e ects). 
Re-runnable
(retry,
repeat). 
We
keep
the
railways. 
Nesting
25. Why
not
IO<A>? Only
supports
Throwable
errors. No
strongly
typed
errors. sealed
class
Error
:
Throwable()
{ 

object
SpeakerNotFound
:
Error() 

object
InvalidSpeakerId
:
Error() 

object
InvalidEventId
:
Error() } IO
{
speakerService.loadSpeaker("SomeId")
} 

.handleError
{ 



when
(it
as
Error)
{
//
 
unsafe
casting 





SpeakerNotFound
->
TODO() 





InvalidSpeakerId
->
TODO() 





Error.InvalidEventId
->
TODO() 

} }
30. An
equivalence
relation IO<Either<E,
A>>

 ↕
 

 suspend
()
->
Either<E,
A> The
latter
for
a
more
idiomatic
style. The
latter
for
eliminating
wrappers. But
cancellation
support
 ⚠

31. Arrow
Fx
Coroutines

32. 
 Arrow
Fx
Coroutines Fully- edged
concurrency
framework. suspend
DSL
-
same
API
than
IO. Functional
impl
of
Kotlin
suspend. Cancellation
system
 ✅ Removes
the
need
for
noisy
wrappers
 Simpli es
Arrow
extremely
 ✨
33. IO<A>
 suspend
()
->
A A
program
written
for
IO. suspend
fun
getThreadName():
String
= 

Thread.currentThread().name suspend
fun
main():
Unit
=
IO.fx
{ 

val
t1
=
!effect
{
getThreadName()
}.evalOn(Computation)
 

val
t2
=
!effect
{
getThreadName()
}.evalOn(BlockingIO) 

val
t3
=
!effect
{
getThreadName()
}.evalOn(UI) 

!effect
{
println("$t1
~>
$t2
~>
$t3")
} }
34. IO<A>
 suspend
()
->
A Using
with
suspend
()
->
A
instead. suspend
fun
getThreadName():
String
= 

Thread.currentThread().name suspend
fun
main():
Unit
{ 

val
t1
=
evalOn(Computation)
{
getThreadName()
}
 

val
t2
=
evalOn(BlockingIO)
{
getThreadName()
} 

val
t3
=
evalOn(UI)
{
getThreadName()
} 

println("$t1
~>
$t2
~>
$t3") }
35. IO<Either<A,
B>>
 

 suspend
()
->
Either<A,
B> A
program
written
for
IO. suspend
fun
fetchUser():
Either<PersistenceError,
User>
=
TODO() suspend
fun
User.process():
Either<PersistenceError,
ProcessedUser>
=
TODO() fun
program():
IO<Either<PersistenceError,
ProcessedUser>>
= 
IO.fx
{ 


val
user
=
!IO.effect
{
fetchUser()
} 


!user.fold({
error
-> 




IO.just(Either.Left(error)) 


},
{
user
-> 




IO.effect
{
user.process()
} 


}) 
}
36. IO<Either<A,
B>>
 

 suspend
()
->
Either<A,
B> Using
suspend
instead. suspend
fun
fetchUser():
Either<PersistenceError,
User>
=
TODO() suspend
fun
User.process():
Either<PersistenceError,
ProcessedUser>
=
TODO() suspend
fun
program():
Either<PersistenceError,
ProcessedUser>
= 

Either.fx
{ 



val
user
=
!fetchUser() 



val
processed
=
!user.process() 



processed 

}
37. Guarantees
stay Performance
improves
 
no
extra
wrapper
allocations
/ runtime
loop. Side
e ects
under
control
 
suspend. suspend
is
the
Kotlin
stdlib
mechanism
to
ensure
an
e ectful
computation
runs
under a
safe
environment.
38. Guarantees
stay Error
handling
and
recovery
by
Either. Either#catch
{},
Either#fold
{}, Either#conditionally
{}... IO
error
handling
is
gone. suspend
fun
program()
{ 

val
maybeSpeakers
=
Either.catch
{
service.loadSpeakers()
} 

val
maybeAge
=
Either.conditionally({speaker.age
is
PositiveInt},
{
"InvalidAge"
},
{
it.age
}) 

maybeAge.fold( 



ifLeft
=
{
/*...*/
}, 



ifRight
=
{
/*...*/
} 

) }
39. Guarantees
stay Use
Either#catch
{}
to
strongly
type
domain
errors. Target
platform:
JVM Running
on
Arrow
v.
0.10.5 Running
on
Kotlin
v.
1.3.50 suspend
fun
main()
{ 

val
service
=
SpeakerService() 

val
res
=
Either.catch
{
service.loadSpeaker("SomeId")
} 

















.mapLeft
{
it.toDomain()
} 

println(res) }
40. Guarantees
stay IO#map
and
IO#flatMap
not
needed. You
are
computing
over
the
inner
value
already.
Sequencing
and
mapping
is
flatMap and
map
over
Either
while
you
stay
within
the
safe
context.
41. Guarantees
stay IO#map
and
IO#flatMap
not
needed. suspend
fun
program():
Either<PersistenceError,
ProcessedUser>
= 

Either.fx
{ 



val
user
=
!fetchUser() 



val
processed
=
!user.process() 



processed 

} //
or suspend
fun
program():
Either<PersistenceError,
ProcessedUser>
= 

fetchUser().flatMap
{
it.process()
}
42. Cancellation Cancellation
stays
 
all
operators
in
Arrow
Fx
Coroutines
check for
it.
43. Cancellation À
la
carte
cancellation
by
cancelBoundary() suspend
fun
loop():
Unit
{ 

while(true)
{
 



cancelBoundary()
//
 
cancellable
computation
loop 



println("I
am
getting
dizzy...") 

} }
44. Concurrent
cancellation ForkConnected
 
launch
coroutine
with
cancellation
linked to
parent. Cancelling
parent
cancels
child. suspend
fun
main()
{
 



val
parent
=
ForkAndForget
{
 





ForkConnected
{
service.loadSpeaker(id)
}
 



}
 
 



parent.cancel()
//
cancels
child
 
 }
45. Concurrent
cancellation forkScoped
 
launch
coroutine
with
arbitrary
cancellation lambda. suspend
fun
main()
{
 



val
interrupt
=
Promise<Unit>()
 
 



val
fiber
=
service.loadSpeaker(id).forkScoped
{

 







interrupt::get

 



}
 
 



interrupt.complete(Unit)
//
will
cancel
fiber
 }
46. parMapN Run
N
parallel
ops. Cancelling
parent
 
cancels
all
children. Child
failure
 
cancels
other
children. suspend
fun
main()
{
 



val
op1
=
suspend
{
loadSpeakers()
}
 



val
op2
=
suspend
{
loadRooms()
}
 



val
op3
=
suspend
{
loadVenues()
}
 
 



val
program
=
parMapN(op1,
op2,
op3)
{
(speakers,
rooms,
venues)
->

 







Event(speakers,
rooms,
venues)
 



}
 
 



program.cancel()
//
cancels
all
child
ops.
 }
47. parTupledN Same
without
callback
style. suspend
computation
 
returns
a
tuple
of
all
the
results. suspend
fun
main()
{
 



val
op1
=
suspend
{
loadSpeakers()
}
 



val
op2
=
suspend
{
loadRooms()
}
 



val
op3
=
suspend
{
loadVenues()
}
 
 



val
res:
Triple<List<Speakers>,
List<Rooms>,
List<Venues>>
=

 







parTupledN(op1,
op2,
op3)
 
 



Event(res.first,
res.second,
res.third)
 }
48. parTraverse Traverse
a
series
of
elements
of
the
same
type
parallelly. Applies
a
mapping
function
for
each. Cancelling
parent
 
cancels
all
children. Child
failure
 
cancels
other
children. suspend
fun
loadEvents()
{
 



val
eventIds
=
listOf(1,
2,
3)
 
 



return
eventIds.parTraverse(IOPool)
{
id
->
 





eventService.loadEvent(id)
 



}
 }
49. parSequence Same
thing
without
the
mapping
function. Cancelling
parent
 
cancels
all
children. Child
failure
 
cancels
other
children. suspend
fun
main()
{
 



val
ops
=
listOf(
 







suspend
{
service.loadTalks(eventId1)
},

 







suspend
{
service.loadTalks(eventId2)
},

 







suspend
{
service.loadTalks(eventId3)
})
 
 



ops.parSequence()
 }
50. raceN Racing
computations
parallelly. Returns
the
winner,
cancels
losers. Cancelling
parent
 
cancels
all
children. Child
failure
 
cancels
other
children. suspend
fun
main()
{
 



val
op1
=
suspend
{
loadSpeakers()
}
 



val
op2
=
suspend
{
loadRooms()
}
 



val
op3
=
suspend
{
loadVenues()
}
 
 



val
res
=
raceN(op1,
op2,
op3)
 



res.fold(
 





ifA
=
{},
 





ifB
=
{},
 





ifC
=
{}
 



)
 }
51. Retrying
/
repeating fun
<A>
complexPolicy()
=

 



Schedule.exponential<A>(10.milliseconds)
 







.whileOutput
{
it.seconds
<
60.seconds
}
 







.andThen(spaced<A>(60.seconds)
and
recurs(100))
 
 suspend
fun
loadTalk(id:
TalkId):
List<Talks>
=
 



retry(complexPolicy())
{
 







fetchTalk(id)
 



}
52. Resource listOf(
 

Resource({
openFile("path1")
},
File::close),
 

Resource({
openFile("path2")
},
File::close),
 

Resource({
openFile("path3")
},
File::close)
 )
 
 val
fileContents:
List<String>
=
resources.parTraverse(IOPool)
{
files
->
 

files.use
{
file
->
file.toString()
}
 }
53. Error
handling? suspend
is
equivalent
to
IO<A>.
You
stay
safe
until
you unsafely
run
it. At
that
point,
you
can
attach
your
error
handling
strategy. Same
for
all
operators
in
Arrow
Fx
Coroutines.
54. Error
handling? suspend
fun
getTalks()
{
 



val
ops
=
listOf(
 







suspend
{
service.loadTalks(eventId1)
},

 







suspend
{
service.loadTalks(eventId2)
},

 







suspend
{
service.loadTalks(eventId3)
})
 
 



ops.parSequence()
 }
 
 suspend
fun
main()
{
 



val
res
=
Either.catch
{
getTalks()
}
 



res.fold(
 







ifLeft
=
{
/*...*/
},
 







ifRight
=
{
/*...*/
}
 



)

55. Much
more
 Stream RacePair/RaceTriple CircuitBreaker
(prevent
cascading) ConcurrentVar
/
Atomic
/
Semaphore guaranteeCase
/
bracketCase evalOn
(threading) ...
56. 
Talk
-
Arrow
Fx
Coroutines @Kotliners https://www.youtube.com/watch?v=Jh3Cfzo8l70
57. 
 
In-depth
course https://www.47deg.com/trainings/
58. 
 
 
In-depth
course https://www.47deg.com/trainings/