►
Description
Tower is a library from the Tokio ecosystem, featuring reusable components and abstractions for building networking clients and servers. We look at some of its use-cases, learn how to read and write Service trait implementations, and discuss some of its downsides.
About Stefan
Stefan Baumgartner is a developer from Austria and co-organizer of the Rust Linz Meetup. He writes regularly for the "Ferris Talk" column at Heise and publishes technical guides and books for various publishers.
Resources:
https://fettblog.eu/slides/introduction-to-tower/
https://github.com/ddprrt/lambda-hyper-example-workspace
https://tokio.rs/blog/2021-05-14-inventing-the-service-trait
https://github.com/ddprrt/axum-tower-layer-services
Rust Linz: https://rust-linz.at
Speak at Rust Linz: https://sessionize.com/rust-linz
Twitter: https://twitter.com/rustlinz
A
Okie
dokie
yeah,
so
welcome
to
the
second
talk
of
today
to
introduction
to
Tower
it
kind
of
struck
me
after
I
proposed
this
and
said
to
Rana.
Hey
I,
do
a
talk!
If
you
don't
find
a
second
speak,
I
will
talk
about
how
because
I
play
around
with
Tower
a
lot
that
this
is
basically
the
sequel
to
my
other
two
talks
that
I
had
at
ruskins,
which
were
Tokyo
warp
and
web
circuits
and
the
other
one
was
serverless
rust
and
now
I'm
kind
of
combining
both
and
I'm.
A
Having
a
couple
of
things
from
the
toky
system,
I'm
going
to
show
you
a
couple
of
things
from
serverless
and
I'm,
giving
you
an
introduction
to
Tara,
which
is
a
quite
interesting
framework.
So
my
name
is
Stefan
I'm,
one
of
the
organizers
of
frost
links.
This
is
the
worst
Twitter
handle
in
the
entire
world.
It's
short
for
that
parrot.
A
Everything
I
learned
and
everything
that
I
collected
here.
What
was
tamper
me
so
I
did
a
lot
of
research.
I
read
a
lot
of
documentation
and
looked
in
a
lot
of
forums
to
see
what
was
going
on.
I
was
looking
in
some
GitHub
issues,
etc,
etc.
To
to
get
myself
an
image
that
works
for
me,
you
know,
and
it
might
work
for
you
as
well,
and
you
might
be
able
to
ship
great
software
afterwards,
but
it
might
be
that
I
get
a
couple
of
things
from
and
up
front
I'm.
A
Tower
is
part
of
the
Tokyo
stack.
So
we
have
spoken
about
Tokyo
a
couple
of
times
here
in
wrestling
so
already
and
I'm
pretty
sure.
If
you've,
if
you've
done
async
programming,
you
have
seen
Tokyo
and
you
have
done
something
with
Tokyo.
Tokyo
is
not
only
a
runtime
for
asynchronous
programming,
but
it's
also
an
entire
ecosystem
that
comes
for
with
tools
for
Network
applications
like
hyper,
which
is
a
complete
implementation
of
HTTP
one
and
two
for
the
client
and
for
the
server.
A
A
No,
it's
there's
a
lot
more
to
it,
but
the
core
of
it
is
an
abstraction
to
to
abstract
the
request
response
pattern,
and
not
only
for
service
but
also
for
clients,
so
that
they
got
get
rid
of
the
of
the
of
the
server
name
in
in
the
abstraction
in
college
service
into
what
you
can
think
about.
This
is
it's
basically
middleware.
A
She
was
taking
middlewares
on
top
of
it
and
you
can
reuse
them
throughout
your
applications,
depending
on
which
applications
that
you're,
writing
and
I
think
it's
called
tar,
because
you
have
a
tower
of
services
again.
This
is
just
me
trying
to
to
figure
out
how
things
work,
but
if
a
tower
of
services
that
you
stick
upon
each
other
and
when
the
request
comes
to
your
application,
it
first
goes
through
the
logger.
Then
you
log
out
some
stuff.
A
Then
you
check,
they
don't
have
a
timer
check,
so
your
request
doesn't
take
too
long.
Then
it's
being
transformed
into
an
actual
HTTP
requested
lens
in
your
function,
so
you
can
work
with
it.
You
can
do
something
with
it
and
then
using
the
response
back
and
there
you
go
again.
Tower
revolves
around
this
service
trait
and
it
kind
of
looks
like
this.
A
It
has
a
couple
of
associated
types
and
it
has
two
functions
that
need
to
be
implemented.
The
first
one
is
Paul
ready.
This
gives,
if
you're
familiar
with
async,
it
gives
you
a
poor
pending
or
a
pole,
Paul
ready,
that's
an
enum,
that's
being
used
in
async
programming,
which
tells
you
either
well.
The
service
can
be
used,
I'm,
ready
to
process
your
service
to
process
your
request,
or
it's
like
wait
for
a
second
I'm,
not
ready
yet
I
can
process
your
request
later
on.
This
is
great.
A
If
you
have
things
like
queuing
or
load,
balancing
or
load
shedding
that
you
want
to
implement
as
a
service,
you
can
do
it.
With
this
pull
ready
function,
you
can
see,
wait,
I'm
full!
My
buff
is
full
Place
rate
until
you
use
me
when
I'm,
ready
and
yeah.
This
is
the
same.
The
same
poll
that
that
you
get
from
from
pool
in
the
future,
the
other
one
is
called
and
with
crawl.
You
are
getting
the
request
object.
A
You
can
work
with
it
and
you
return
a
future
again
and
most
of
the
time
you're
returning
in
inner
future.
So
a
services
are
meant
to
be
wrapped
around
each
other,
like
an
onion
with
the
last
one
in
the
middle
and
usually
you
returning
to
Future
from
the
last
one
and
then
again
from
the
inner
one
from
the
inner
one
from
dinner,
one
until
you
reach
the
other
one.
A
Let's
look
at
the
very
simplified
local
service,
so
what
we
want
to
do,
we
are
writing
an
HTTP
application,
and
what
we
want
to
do
is
that
at
the
moment
the
request
comes
in
I
want
to
log
a
little
bit
information
about
this
request,
usually
I'm,
creating
a
struct
that
is
generic
with
an
inner
service.
So
this
is
the
wrapping.
You
know
that
this
is
how
you
build
up
your
Tower
just
services
within
services,
and
this
is
also
everything
that
that
logo
is
doing.
A
So
you
are
just
taking
another
service,
you
own
it
and
you
you
compose
it.
It
gets
interesting.
The
moment
you
have
the
service
trained.
So
here
we
have.
We
are
implementing
the
service
for
HTTP
requests
with
with
a
body
for
the
locker,
so
this
is.
This
is
how
we
implement
the
service
and
this
service
we're
implementing
it
for
other
services
that
can
handle
requests.
A
So
I'm
I'm
talking
a
little
bit
more
about
this
in
just
a
segment
since
we
get
request
in
and
push
requests
sound.
We
also
get
responses
up.
This
is
what's
happening
here
and
if
an
error
occurs,
we're
just
bubbling
up
the
error
from
the
other
service,
the
return
future
that
we
expect.
You
know
the
future
that
that's
being
called
afterwards
when
everything's
ripped
up
is
also
the
future
from
the
server
State
program.
So
so,
basically
we're
taking
everything
from
This
concerns.
A
The
polling
function
Post
in
the
service,
so
we
know
if
Dino
service
is
ready,
and
here
that's
everything
that
we
do
so
the
moment
this
service
is
called,
we
say:
well,
we
are
processing,
whatever
method,
add
whatever
URI
and
call
DNA
service.
You
see,
this
is
an
expression,
so
there's
no
semicolon
it,
which
means
the
inner
service
is
also
returning
your
future
and
there
you
go
everything
swept
up.
This
is
how
a
service
should
work
in
theory,
not
only
in
theory.
This
actually
WorkSource
in
production.
A
If,
if
you've
seen
my
talk,
serverless
rust,
I
talk
a
lot
about
how
those
different
serverless
architectures
work,
Lambda
is
is
very
special
in
how
it's
being
invoked
and
how
it
gets
its
tasks
and
Azure
functions,
which
is
very,
very
nice.
If
you
want
to
migrate.
Your
app
to
Azure
functions
is
basically
a
server
with
some
boilerplate
code.
A
What
I
have
here
is
I
have
a
Handler
function.
It
gets
in
an
event,
so
this
is.
This
is
the
the
payload
that
I
want
to
deal
with
I
I
ripped
I
I,
wrapped
this
throughout
the
value
inside
this
this
this
double
struct
I.
Don't
know
why
anymore
I
guess
you
just
can
pass
the
value
itself.
That
should
work
also,
but
I
call
it
event,
mainly
mainly
because
of
the
naming
yeah
I
expect
the
value
here.
A
A
I
have
an
error.
It's
a
boxed
error.
It's
you
know
that
I
can
consume
every
error
and
yeah.
It
has
one
dependency
on
3D.
That's
that's
everything.
It
is
and
I
happen
to
take
this
function
and
attach
it
to
AWS
Lambda
into
Azure
functions
for
Lambda,
I'm.
Writing
a
Lambda
event
parser,
which
is
a
service.
It
takes
an
inner
service
via
generic,
so
the
Constructor,
the
implementation
of
of
mystract,
looks
like
the
one
from
the
logo.
That's
basically
I
guess
you
can
create
the
macro
for
that.
That
should
work
as
well.
A
A
Let
us
go
through
a
couple
of
things:
there
first
I
implement
the
Tower
Service
for
Lambda
events
that
carry
a
certain
value.
So
this
is
one
generic
that
I
need
to
fill
out
I'm
implementing
the
service.
If
alarm
they
went
with
the
third
value
comes
in
then
this
implementation
is
valid,
and
this
is
what's
incoming,
and
this
is
what
I'm,
what's
outgoing.
So
if
you,
if
you
still
think
as
this
Tower
of
middlewares,
this
is
what's
coming
from
above
and
going
down
to
your
own
function.
So
I
want
to
convert
a
Lambda
event.
A
That
here
is
a
value
to
a
service
that
can
carry
an
event
and
this
event
type.
Is
this
one
type
that
I
defined
in
my
function?
You
know:
there's
one
thing
that
that
a
struct,
a
tuple
struct
with
the
salary
value
very
similar
to
the
Lambda
event,
but
with
less
fields
and
much
much
easier
and
none
of
the
plumberches.
A
So
that's
it
since
I'm
I'm,
working
with
values
here,
both
in
in
Lambda
and
in
my
service
I,
can
just
Bubble
Up
the
response
types
and
the
error
types
in
the
future.
That's
all
fine
I!
Don't
need
to
do
anything
here,
so
the
response
will
be
a
value.
A
certain
value
and
Lambda
can
work
with
study,
values,
great
and
also
the
arrow.
It's
it's.
The
any
error
anyway
bubble
it
up.
That's
fine!
A
Now
for
the
call
function,
it's
pretty
straightforward
as
well:
I
get
the
request:
I
split
it
into
parts,
that's
a
function
from
the
Lambda
event,
I'm
taking
this
value.
This
is
now
the
value
value
like
the
third
value,
wrap
it
into
the
event
and
call
it
in
the
service,
the
inner
service
Returns,
the
future.
This
is
the
future
node
that
we
defined
here.
A
The
type
future
as
colon
colon
future,
give
it
back
and
that's
how
we
integrated
our
function
to
Lambda
now
for
Azure
functions,
I'm
calling
I'm
writing
an
HTTP
parset,
because
it's
not
only
financial
functions
but
basically
for
every
HTTP
server,
which
is
nice
same
thing
again.
I
could
possibly
write
a
macro.
I
I
read
a
service
inside
the
HTTP
parser.
However,
it
gets
much
much
more
interesting
when
I
look
at
the
tabs
that
they
need
for
implementing
the
service,
so
I'm
implementing
a
service
for
an
HTTP
request
with
the
body.
A
So
this
is
this
is
all
from
from
hyper
from
the
hyper
crit
where
so.
This
is
again
incoming.
This
is
this:
is
all
Destin
HTTP
request
with
the
body
incoming
to
your
service?
Now
please
unwrap
it
and
I
want
to
send
it
this
line
to
again
a
service
that
swallows
my
events
that
takes
those
events
that
I
have
defined
within
the
app
which
is
Sun's
implementation.
Detail
I
need
to
define
a
couple
of
more
trade
bounds
because
heavy
and
an
HTTP
server
Futures
need
to
be
sent
across
multiple
threads.
A
Possibly
if,
if
you
are
sending
those
Futures
across
cross
threads,
then
maybe
you
want
to
have
static
Drive
times,
which
is
typically
for
HTTP
servers.
I
guess
kinda
mentioned
something
like
that
in
his
rocket
talk
from
a
couple
of
years
ago.
Actually
so
yeah
I
need
to
cut
needs
a
couple
of
trade
bonds
to
work,
but
but
that's
it,
you
you're
getting
lots
of
error
messages
if
you
don't
have
to
straight
bounce,
so
we'll
know
so
also
the
the
future
from
the
service
needs
to
be
sent
and
I
guess.
A
The
response
just
needs
to
have
debug
and
display,
because
we
have
a
couple
of
log
lines
in
there
that
I
want
to
use.
So
this
is
all
related
to
the
service
that
I
want
to
call
so
coming
from
the
HTTP
service.
This
is
the
next
one:
do
we
the
types
the
associated
types
are
also
very
different,
so
the
response
now
is
not
just
what
what
comes
from
from
from
my
own
function
from
my
own
Handler
function
since
I'm
in
HTTP
land
I
need
to
provide
an
HTTP
response
with
the
body
again.
A
So
this
is
a
tab
that
comes
now
from
hyper,
and
it's
my
duty
in
this
layer
that
I
read
what's
coming
from
this
service
to
produce
a
response
in
HTTP
response
with
the
body
there
is,
is
the
same
I
guess
in
this
implementation.
I
just
used
any
High
error.
Instead
of
writing
it
on
my
own,
but
I
can
use
the
same
error
and
here
I
have
a
future,
which
is
a
boxed
future
with
static
Lifetime
and
the
result
again.
So
this
is.
A
This
is
a
little
bit
long,
I'm
going
to
tell
you
in
a
second
why
I
need
the
Box
future,
because
I
I
want
to
do
a
couple
of
things
with
the
response
that
can't
be
done
as
easily
as
we've
seen
in
the
last
example,
so
I
need
the
Box
future
I'm
going
to
tell
you
in
just
a
second,
it's
very
important
to
get
those
types
right.
Those
types
will
make
or
break
your
entire
implementation
and
you
are
getting
error
messages
from
hell.
A
So
this
is
if,
if
you're
getting
one
trade
bound
wrong,
I
guess
here,
I
got
I.
I
forgot
the
send
trade,
the
center
trade
marker
to
add,
as
a
trade
Bond,
then
you're
getting
toward,
which
means
you're
getting
pages
of
error
messages
with
all
the
generic
JS
and
especially
if
you're
wrapping
things
into
each
other.
It's
generic
engineering,
generics,
engineerics
and
one
little
implementation
map
Network
boom.
That's
it
I.
I
hope
that
those
error
messages
will
get
a
lot
lot
better.
A
To
read
the
moment,
we
have
async
trades
within
the
language,
so
especially
all
the
boxing
and
pinning
I
guess
will
be
easier
because
we're
not
only
trying
to
return
Futures,
but
we
can
say
well.
This
is
an
async
function
that
returns
a
result
and
we
can
get
the
the
future
terminology
out
of
it
and
that
should
already
make
it
easier.
So
hopefully,
Nick
Cameron
was
a
trust.
Linson
spoke
about
that
then
I
asked
him
this
question.
A
He
said
yes,
yes,
that
should
be
easier,
hopefully
so
really
looking
forward
to
what
the
async
working
group
is
doing
already.
Let's
look
at
the
implementation
at
the
call
function.
Here
are
a
couple
of
things
that
are
very,
very
different.
What
we
want
to
do
is
we
want
to
call
the
service
somewhere
within
our
code,
take
the
result
and
then
produce
an
HTTP
response,
and
because
we
are
calling
this
asynchronous
function
somewhere
in
the
middle,
we
need
to
create
a
future
that
doesn't
move
in
memory
anymore.
This
is
what
the
box
pin
does.
A
This
is
I,
guess
a
talk
Italian
on
its
own
and
I
guess,
without
both
that
one
at
one
of
the
rust
comps,
which
you
can
find
in
the
rush
Channel
all
about
pinning
and
boxing
boxes-
we're
not
doing
this
here
today.
Just
now
we
are
doing
all
the
chess
and
having
boxed
Futures
and
box,
pin,
etc,
etc.
To
be
able
to
do
something
before
we
call
the
inner
service
and
to
do
something
after
recording
service.
This
is
why
we
are
doing
that.
A
First,
we
are
cloning
dinner
service.
Clones
are
pretty
cheap.
You
don't
clone
that
much
so
memory
wise.
It's
it's
not
the
big
of
an
operation,
but
the
problem
is:
is
that
your
async,
your
future,
might
already
be
pulled
when
the
Clone
is
not
ready.
Yet
this
is
something
that
I've
read
in
the
documentation
just
recently,
which
means
that
I
this
line
here
make
sure
that
your
clone
is
ready
by
replacing
the
Clone
with
or
the
the
actual
inner
service
with
the
Clone.
A
A
Then
we
are
pinning
so
we're
creating
an
async
block,
we're
pinning
it
in
memory,
so
it
does
yeah
it.
It
can't
move
anymore.
We
prepare
the
request.
So
this
is
the
request
object,
which
is
an
actual
HTTP
request.
What
this
function
does
is
that
it
extracts
all
the
information
that
you
need
and
puts
it
in
in
some
data,
which
is
a
certain
value
again,
then
we
call
the
inner
service
wrapping.
A
The
third
evaluate
in
our
event,
structure
again
await
that
and
once
you
get
the
result
either
if
the
result
is
okay,
I'm
going
to
return
an
HTTP
response
with
a
status
code,
okay
and
with
the
result,
the
string
otherwise
an
empty
button,
an
internal
survey
error.
So
if
you
can
have
two
different
responses
that
are
okay
but
carry
the
error
value
inside
the
response
and
not
with
the
rust
error,
sampling
data
and
that's
the
implementation
to
attach
my
function
to
an
HTTP
server
and
ultimately,
two
Azure
functions.
A
Okay,
test
implementation
of
a
service
we
can
use
the
service,
then
we
can
wrap
our
services
within
each
other.
That's
fine!
Well,
what's
much
much
nicer
is
to
create
layers
layers
are
data
structure
that
work
next
to
services
and
you
can
chain
them.
So
you
can
say
well
this
layout
and
this
layer,
then
this
layer,
then
this
layer,
just
like
you,
would
have
a
middleware
stick.
We
are
going
to
see
an
example
just
recently,
just
in
a
couple
of
seconds.
The
implementation
is
also
very
similar
to
all
the
others
here.
A
Here
we
are
creating
the
new
the
new
service
wrapped
in
the
one.
Via
these
layer
functions
you
just
need
to
implement
the
layer
function,
the
structs
can
be
can
be
empty,
so
it's
there's
nothing
much
to
it,
and
this
is
for
the
HTTP
parser.
This
is
for
the
Lambda
event,
pass
the
same
thing
different
names,
so
so
just
wrapping
your
service
in
the
land
event
passer.
A
Okay.
How
are
we
going
to
use
it?
This
has
been
used
in
Lambda.
They
just
updated
the
SDK.
They
now
provide
you
with
the
service
function,
which
means
that
you
can
take
your
function
and
wrap
it
into
into
a
tower
service.
So
now
it's
compatible
with
style
with
the
interfaces
that
you
defined.
This
is
a
very
nice
way
to
to
make
every
one
of
your
functions
Tower
already,
then
we
create
a
new
service.
Builder,
firstly,
is
the
timeout
layer.
A
I,
don't
want
my
function
to
run
longer
than
than
three
minutes
and
I'm
using
a
timeout
layer
here
and
the
timeout
service
here,
because
I
want
my
implementations
on
Azure
functions
and
Lambda
2
work
similar
and
then
Lambda
I
can
configure
a
timeout
invocation
and
I
guess:
I
can't
do
that
with
an
HTTP
server
in
Azure
functions,
I
want
them
to
work
similar.
This
is
why
I
create
I
use
the
timer
clear
here
then
I
have
my
Lambda
event
layer
and
then
I
have
my
function
and
I
run
it.
That's
it.
A
This
is
how
we
are
doing
International
functions.
We
are
creating
an
HTTP
server
I'm
using
here
hyper
I'm.
Not
using
a
framework
just
happens,
it
is
I.
Have
a
port
key.
The
function
is
custom
handle
Port,
I
I,
let
it
listen
on
localhost.
So
this
is
the
you.
You
have
to
listen
to
this
port
if
you
want
to
attach
situation
functions.
A
So
the
cool
thing
is
everything:
here:
is
the
service
Builder
and
my
service
function?
That's
all
the
same
thing,
no
matter
if
I'm
on
Azure
functions
or
a
Time
on
the
AWS
Lambda,
the
only
thing
that
I
need
to
change
is
the
HTTP
parser
layer
for
Azure
functions
in
the
Lambda
layer
for
AWS
Lambda,
and
then
my
app
works
on
both
serverless
architectures
fantastic.
This
is
what
I
wanted
to
achieve
cool,
and-
and
that's
that's
that
so
what's
in
the
box
with
Tower
Services,
it's
not
only
the
trade.
A
It's
not
only
the
service
trade
that
you
can
Implement.
There
are
a
couple
of
things
in
there
that
are
really
really
important
if
you
want
to
create
networking
applications,
especially
if
you
think
about
kubernetes
and
kubernetes
clusters,
I
guess
the
istio
service
mesh,
if
I'm
not
mistaken,
use
this
tire
a
lot
to
implement
all
the
networking
connections
that
go
between
your
community
Sports,
and
you
can
do
things.
A
As
for
the
ecosystem,
hyper
is
based
on
Tower,
so
I
guess
even
the
whole
Tower
concept
originated
from
hype
from
that.
If
I'm
not
mistaken,
because
I
could
see
things
like
the
make
service
function
in
the
service
function
first
in
hyper,
then
in
Tower,
so
now
you're
using
Tara,
directly
and
and
yeah.
If
you
spin
up
a
hyper
server
or
hyper
client,
you
are
creating
services
that
are
based
on
power.
So,
since
hyper
is
based
on
us
with
every
web
framework
that
is
based
on
hyper
guess.
A
A
If,
if
you're
saying
hyper
applications
or
hyper-based
applications,
you're,
basically
saying
Tower
anyway,
which
means,
if
you
have
a
set
of
really
nice
reusable
Services,
which
are
probably
very
generic,
then
you
are
good
to
go
for
every
hyper
application.
That
you're
doing
a
couple
of
things
to
read.
I
have
a
couple
of
examples
that
that
you
can
find
on
GitHub.
A
I
would
also
invite
you
to
read
the
Tokyo
blog
about
inventing
the
service
to
it.
This
is
a
Blog
article
that
was
released
last
year,
which
really
shows
why
the
service
rate
is
important
and
why
it
is
like
it
is,
and
you
can
find
all
the
stats
and
all
the
information
that
you
see
here
today
tomorrow,
on
my
blog
or
if
you're,
if
you're,
watching
the
video
on
the
last
channel,
it's
already
there
so
I'm,
definitely
putting
up
the
slides
before
I'm
putting
up
the
videos.
A
A
I'm
super
sorry.
I
have
I,
have
seven
vs
code
windows
open
so
and
don't
look,
look
Rusty!
It's
that
one.
It
should
be
that
one!
Oh
okay,
yeah,
okay,
now
I
need
I
need
to
find
it
here.
Okay,
let's
make
it
a
little
bit
bigger.
So
what
I
it
here,
I
created
I
created
an
excellent
server.
I,
don't
know
if
we've
done
Exxon
on
this
channel
already,
but
but
we
should
so
it's
it's
a
fantastic
new
framework.
I
think.
A
A
This
is
this
Handler?
The
timeout
I'm
taking
this
timeout
variable
and
it
goes
into
the
timer,
and
the
idea
is
that
I
have
where's
the
timeout
Handler.
It's
here
that
I
sleep
for
the
number
of
milliseconds
that
I
get
in.
So
if
I'm
saying
localhost,
Slash,
1000,
I'm,
waiting,
1000,
milliseconds,
local,
slash,
100,
I'm,
meeting,
100
milliseconds,
or
something
like
that,
and
if,
if
this
number
of
milliseconds
is
lower
than
my
timeout
limit,
then
I'm
writing
out.
I
made
it.
A
But
here
I
have
you
know
those
are
my
routes
and
then
I'm
having
a
local
layer
again,
I
want
to
lock
my
stuff
into
having
a
timeout
layer
that
waits
for
300
milliseconds,
which
means
after
300
milliseconds.
This
future
results
this
future.
This
future
is
in
pull
ready,
which
means
that
the
entire
service
is
import
ready,
which
means
that
the
actual
the
actual
future
from
the
timeout
path
is
being
canceled,
and
so,
if
I
curl
it
with.
A
A
A
A
It
has
a
the
errors.
This
is
nice,
you
can.
You
can
use
any
error
that
you
like,
as
long
as
it
can
be
converted
into
the
box
Arrow
from
this
trade.
This
is
a
very
nice
pattern,
so
this
makes
compatibly
pretty
great.
If
you
say,
the
only
thing
that
I
that
I
need
to
that
I
need
to
provide
is
something
that
can
be
converted
into
the
actual
error.
A
If
I
have
an
error,
it's
being
mapped
and
here's
the
chord
so
I
have
two
Futures.
One
is
the
response:
if
I
call
Inner
the
other
one
is
the
Sleep
Future
and
then
I'm
putting
both
into
the
response
future
going
into
the
response
future.
If
I'm
looking
at
Paul,
the
only
thing
that
it
does
is
well,
let's
see
if
the
actual
future
is
ready.
If
the
actual
request
is
ready,
then
check
the
sleep
function
and
yeah.