►
Description
Slides and more info: http://www.lambdadays.org/lambdadays2016/eduard-bopp
Functional reactive programming as pioneered by Conal Elliott is gaining wide-spread interest as the go-to abstraction for interactive applications. Many functional idioms rely on a high level of abstraction over details like memory layout.
But can this concept be translated to an application domain, where you cannot afford this luxury? Think of real-time systems like video game engines or embedded software, where you have a tight performance budget.
Rust is a new programming language developed as a community project supported by Mozilla. It brings a strong type system with compile-time memory safety and high-level abstractions to the world of low-level systems programming.
This talk tells the story of a library called Carboxyl, an implementation of functional reactive event streams and behaviours in Rust. Dealing with explicit memory management provides certain unique implementation challenges. However, Rust's static memory-safety guarantees were very helpful overcoming these. Furthermore, the talk will demonstrate typical architectural patterns for using FRP in practice.
A
Right
so
I'm
going
to
talk
about
in
the
rust
programming
language
I
show
how
many
of
you
have
been
at
the
previous
table,
but
I
saw
there's
always
lots
of
talk
going
on
about
function,
reactive
programming,
so
I
kind
of
hope
that
this
context
is
already
there.
The
rasp
roaring
language,
maybe
not
so
much
because
it's
good
kind
of
well,
it's
not
a
functional
programming
language
and
it's
also
kind
of
a
new
thing.
That's
getting
a
bit
of
popularity.
Now,
though,
okay,
so
there's
two
kind
of
angles
that
you
come
can
come
to
this
topic.
A
I
guess
the
first
one
which
I
kind
of
come
from
is
you're
doing
some
kind
of
systems
programming.
In
my
case,
that
was
game
development
and
you
have
a
lot
of
trouble
with
event
handling,
because
the
way
you
do
it
and
in
imperative
language
is
no
obviously
going
to
languages.
Usually
this
model-view-controller
pattern
that
has
a
lot
of
issues
that
that
can
get
troublesome
in
larger
applications
and
so
I
looked
into
FRP
as
an
alternative
and
found
that
solved
quite
a
lot
of
these
problems.
A
There
was
found
that
I
found
there's
also
another
angle
that
you
can
get
to
this
I
guess,
which
is
pretty
much
your
only
sold
on
f4p,
because
you
have
a
function,
programming,
background
or
whatever,
but
now
you
get
to
an
application
domain
where
you
maybe
can't
use
all
the
nice
things
like
Haskell
or
closure,
or
alexey
or
elm
or
whatever
you
want
to
use
and
so
yeah
you
look
for
other
alternatives
and
I.
Think
rust
is
an
interesting
alternative
solver.
What
I've
done
is
pretty
much
write.
A
A
So
it's
not
entirely
the
same
that
you
can
get
if
you
write,
C
or
R
or
assembler
or
something,
but
it's
pretty
close,
and
the
nice
thing
about
rust
as
compared
with
the
language
like
C,
though,
is
that
it
statically
prevents
all
these
kind
of
memory.
Corruption,
issues
that
you
get
when
doing
programming
in
these
languages,
and
it
does
this
using
a
static
type
system
to
figure
out
at
compile
time.
A
Like
has
first-class
functions.
It
uses
a
lot
of
generics
and
algebraic
data
types
which
are
really
nice
to
build
functional
semantics
with
it.
Now,
let's
look
at
the
bar
for
us
code.
Is
the
obligatory
has
a
word
program?
Nothing
too
fancy
here,
I!
Guess
it's
just
a
main
function
that
prints
hello,
world.
A
Yeah,
this
is
what
let
bindings
look
like
in
rust.
Yeah.
You
just
have
this.
First
of
all,
everything
is
immutable
by
default,
which
is
pretty
nice
property
to
work
with,
and
you
declare
that
you
can
annotate
the
type
that
also
has
type
inference.
So
you
don't
need
to.
If
it
can
be
inferred
from
the
context,
you
can
also
it's
not
a
function,
programming
image,
so
you
can
just
declare
a
variable
as
mutable
and
assign
another
value
to
it,
but
you
have
to
explicitly
say
so,
and
there
are
some
limitations
on
when
you
make
something
mutable.
A
A
And
on
this
program,
you're
pretty
much
very
precise
about
what
kind
of
type
you
have
there,
and
if
you
want
to
calculate
the
sum
of
that
vector,
we
can
convert
that
into
an
iterator
and
fold
over
it.
So
we
have
kind
of
this.
Nice
function
API
with
a
little
bit
of
conversion
between
a
vector
and
iterate
over
there.
A
But
the
interesting
part
here
is
that
when
I
pass
the
vector
like
initialize
some
vector
with
one
two
three
in
it
and
pass
that
to
the
function,
it
will
compute
the
result,
but
afterwards
I
can't
use
that
anymore.
So
I.
If
I
wanted
to
do
anything
else
with
a
vector
I
couldn't
because
I've
consumed
the
vector
and
it's
gone
so
that's
kind
of
inconvenient.
But
this
is
how
just
make
sure
that
you
don't
share
certain
things
now,
of
course,
you
can't
really
work
with
something
I
just
works
like
that.
A
So
you
have
to
sort
of
introduce
a
way
of
sharing
things,
and
this
is
called
borrowing
and
rust.
So
you
pretty
much
can
just
instead
of
giving
ownership
of
the
vector
to
the
function,
you
can
just
borrow
it
by
giving
it
a
slice
of
the
vector
in
this
case,
and
then
you
use
this
funny
ampersand
symbol
to
indicate.
Okay,
I
have
a
reference
to
this
thing,
and
then
you
can
use
the
vector
afterwards
because
after
the
function
is
done
computing,
the
sum
it
sort
of
returns
or
gives
the
ownership
leases
ownership
of
that
value.
A
So
the
surrounding
scope
has
ownership
of
it
again.
So
right
there
are
also
mutable
boroughs,
so
these
are
boroughs
into
resources
where
you
can
actually
mutate
the
contents.
So
this
is
how
you
yeah
just
define
some
variable
and
then
in
a
scope
that
I
note
by
these
curly
braces,
you
can
take
a
mutable
borrow
and
modify
that
you
can
also
think
doing
this
in
a
function
too.
But
this
thing
so
for
a
given
resource
you
can
only
ever
have
one
mutable
borrow.
A
You
can't
create
multiple
of
them
and
the
otherwise
the
compiler
will
yell
at
you.
This
is
to
ensure
these
single
writer
principle,
okay,
just
a
bit
more.
Of
course,
we
have
structs
and
enums
in
amps
were
pretty
much
like
algebraic
data
types
and
starts
are
the
same
thing
as
in
C.
So
these
are
the
fundamental
building
about
how
you
build
more
complicated
types
in
rust
and
they
have
very
efficient
the
representation.
A
A
Right,
that's
set,
FRP
comes
in
a
million
different
flavors
and
amelia
is
probably
a
bit
too
much,
but
there
are
a
lot
of
varieties,
and
this
is
where
I
was
sort
of
want
to
talk
a
little
bit.
What
carboxyls
are
my
library's
flavor
particular
is
of
function,
active
programming,
so
in
contrast
to
what
many
popular
4p
libraries
do
at
the
moment,
cabassa
listing,
which
is
two
different
types,
so
the
first
type
is
a
stream,
and
this
is
just
a
sequence
of
discrete
events.
So
this
is
really.
This
does
not
contain
any
state
whatsoever.
A
A
For
that
you
have
a
signal,
and
that
is
a
value
that
varies
continuously
over
time,
so
it
might
be
just
an
event
stream
held.
Essentially,
so
you
just
persist
the
state
of
a
given
event
stream
and
just
take
the
last
one.
So
you
have
a
stepwise
function
so
from
5
to
7
o'clock
ima
and
from
7
to
1/2,
+,
7
MB
and
after
that
I'm
C,
but
it
could
also
be
something
that
really
changes
continuously
like
a
sine
wave
or
some
cubic
interpolation
between
two
values.
A
That
being
said,
time
in
carboxyl
is
also
implicit
rather
than
explicit,
which
means
that
yeah,
you
don't
really
write
down
these
functions
as
functions
of
time,
but
you
just
evaluate
something
at
a
certain
point
and
that
it
will
be
the
value
that
is
the
current
value
of
it.
So
if
you
want,
you
can
of
course
use
some
library
to
bring
in
explicit
time,
but
the
implementation
doesn't
really
deal
with
that.
A
This
is
what
it
looks
like
to
just
old
streams
and
signals
so
because
we
are
in
an
imperative
language,
we
sort
of
have
to
somehow
tie
the
concept
of
a
stream
to
or
a
signal
to,
the
surrounding
context
and
all
these
imperative
calls
and
to
do
that.
First
of
all,
you
have
something
called
a
sink,
which
is
basically
just
a
place
to
dump
events
into.
A
So
you
can
have
some
kind
of
driver
that
reads
from
a
network
resource
or
something
that
fetches
keyboard
events
from
your
windowing
library,
and
then
you
can
create
a
stream
from
that
that
pretty
much
has
this
definition.
Okay,
I
contain
all
the
events
that
somebody
at
some
point
dumps
into
the
sink
and.
A
With
this,
you
can
pretty
much
work
and
just
do
the
all
the
function
transformations
a
signal.
Then
you
can,
for
instance,
create
from
a
stream
by
holding
the
stream
and
giving
it
some
initial
value,
and
then
it
will
change
from
that
initial
value
that,
whenever
an
event
occurs,
you
can
also
create
I'm
showing
this
here
yet
single
from
just
a
function
that
you
might
might
take.
A
A
If
we
don't
want
to
do
that
much,
but
I'm
just
going
to
show
the
framework
in
which
this
ties
into
the
rest
of
the
language.
Okay,
you
can
also
iterate
over
a
stream,
so
R
Us
has
mutable
iterators
that
carry
the
state
of
in
this
case.
What
kind
of
event
are
mapped
and
then
I
can
just
call
next
and
go
to
the
next
event
if
there
is
one
there's
kind
of
another
way
to
just
directly
communicants
treatment,
instead
of
sampling,
a
signal
which
might
be
interesting
in
some
cases.
A
A
There
are
a
couple
of
different
ways
of
doing
that
using
rust,
optional
type,
so
you
can
either
just
use
a
bully
and
predicate
and
filter
everything
out
that
doesn't
satisfy
the
predicate
or
you
can
return
the
an
option
type
and
if
yeah
so
only
take
the
some
values
and
open
non
values
or
you
can
just
directly
operate
on
the
option
stream.
So
just
different
kinds
of
filtering.
A
You
can
merge
two
streams
and
get
a
stream
that
contains
all
the
events
from
both
you
can
fold
over
a
stream
and
get
a
signal
that
contains
so
so
it
contains
a
state.
It
has
some
initial
state
and
whenever
you
send
an
event
into
it
will
call
the
function
with
current
state
and
whatever
event
you
get
in
and
should
get
out
a
new
state
essentially.
A
So
this
is
very,
very
important
to
sort
of
persist,
application
state
in
some
way
right,
then,
a
snapshot
is
pretty
interesting
because
it
takes
a
signal
and
a
stream
and
combines
these
with
a
function.
So
in
this
example,
I
have
a
function
that
takes
the
time
and
some
events,
some
value
of
a
particular
event
type
and
gets
out
some
new
thing
whatever
that
is,
and
so
this
pretty
much
takes.
A
A
Right,
another
useful
thing
is
also
that
you
can
sort
of
lift
an
ordinary
function
to
a
function
on
signals
and
then
get
a
new
signal
out
of
that.
That
sort
of
just
combines
what
you've
got
by
using
that
function.
This
yeah
works
for
arity
up
to
four
can't
do
this
generically
in
rust
entirely
because
macros
are
not
quite
powerful
enough.
A
For
instance,
I
have
also
dynamic
switching
of
streams
and
signals
which
is
kind
of
debatable
because
it
isn't
entirely
referentially
transparent.
So
this
is
a
complex
discussion.
I'm
kind
of
thinking
about
switch
is
throwing
it
out
actually
because
you
might
get
along
without
it
and
there's
also
a
way
to
coalesce
events
that
occur
in
the
same
transaction.
A
So
if
one
thing
that
you
send
in
will
result
in
two
events
that
simultaneous
there
are
simultaneous
and
are
merged
at
a
certain
point,
you
may
not
want
to
merge
them
right
away,
because
then
you
have
no
control
over
what
the
sequences.
So,
instead
you
have
some
function
that
takes
care
of
getting
rid
of
that
ambiguity
right
so
far
about
the
know.
What
Jerry
looks
like
now:
I
won't
talk
about
how
to
actually
build
applications
with
it,
and
there
are
a
lot
of
libraries
available
in
the
rust
ecosystem.
A
A
great
ecosystem
so
created
Russ
is
just
a
library
basically,
and
there
are
a
few
that
belong
to
carboxyl
directly-
that
I
sort
of
made
into
separate
modules
to
sort
of
keep
these
separate.
These
concerns
separate
that
help
you
interface
using
a
streaming
API
for
command
line
interface
and
for
system
time
and
also
for
windowing.
A
That's
the
Piston
game
engine
which
is
primordial
R
and
there
are
GFX
and
clean
for
doing
3d,
graphics
and
there's
gluten,
which
provides
a
purist
implementation
of
a
windowing
context.
So
that's
a
lot
and
I'm,
probably
mentioning
of
this
I'm,
not
mentioning
half
of
things
that
are
actually
worth
mentioning
here.
A
Side-Effect
phone
calls
based
on
your
purely
functional
description,
but
in
principle,
there's
a
lot
to
work
with
it's
just
a
bit:
tricky
to
integrate
yeah
so
demo
times
little
slightly
problematic,
because
we
have
some
technical
issues.
So
I
can't
actually
show
this
right
now,
which
is
a
bit
annoying,
but
it
wasn't
this
much
of
an
application.
So
the
application
that
I
wanted
to
show
pretty
much
was
really
just
a
button
that
you
would
click
and
it
would
change
its
color
so
effectively
a
toggle
button.
A
A
So
in
my
case,
I'm
talking
about
the
entire
application
I'm
starting
out
with
a
window
which
contains
all
these
events
that
yeah
that
describe
what
your
keyboard,
what
you
user
does
essentially,
and
there
are
two
aspects
that
I
were
several
aspects
that
I
can
derive
from
that.
First
of
all,
get
something
that
I
call
context.
It's
pretty
much!
This
signal
part
of
the
input,
so
the
continuous
part.
So
this
is
like-
where
is
the
mouse
currently
or
yeah
I?
A
Don't
know
what
is
the
current
size
of
my
window,
these
things
and,
in
my
case,
I
model
this
context,
just
as
something?
Okay?
Am
I
hovering
my
button
or
am
I
not
doing
that
which
yeah,
which
pretty
much
describes
what
you
want
from
my
context.
Now
you
have
to
sort
of
derive
that
from
the
window
that
you
get
so
yeah.
There
are
a
couple
of
functions
that
that
I
can
delegate
this
to,
but
essentially
I
take
the
window
size
and
the
current
position
of
the
mouse
cursor
and
determine
okay.
A
Is
this
make
some
coordinate
transformation
based
on
the
window
size
and
then
say?
Okay?
Does
that
hover
over
my
button
and
if
so
I'm
in
the
hovering
context,
otherwise
I'm
free
of
the
cursor?
That's
pretty
much.
It
then
there's
also
a
discrete
part
to
the
input.
The
part
that
we
are
interested
in
in
this
case
pretty
much
only
clicks
with,
say
the
left
mouse
button,
and
so
we
filter
out
everything
with
a
function
that
gives
the
raw
event
that
contains
all
possible
things
that
could
happen
to
an
optional
event
that
yeah.
A
That
only
contains
one
variant
here.
Right
know
that
we
have
these
two
things
we
can
sort
of
think
about
interpreting,
and
so
the
next
step
would
be
to
think
about.
Okay.
What
was
the
intention
behind
all
this
input
that
I've
seen
and
so
and
interpret
the
events
that
the
input
events
that
come
in
in
a
given
context
and
it
figure
out?
Okay
did
I
want
to
do
anything
with
that,
like
what
did
what
I
want
to
achieve
or
did
use
I
want
to
achieve
anything
with
that,
and
in
this
case
the
implementation
is
pretty
trivial.
A
So
we
just
say:
okay,
if
I'm
hovering
currently
and
an
event
occurs,
which
in
our
case
can
only
be
that
one
click
that
we
defined
then
I
want
to
toggle
the
button.
Otherwise
I'm
not
going
to
do
anything
because
a
click
outside
the
button
doesn't
do
anything
right
and
if
we
look
again
back
to
the
original
wrapper
function,
that
put
all
the
logic
together,
we'll
see
that
how
this
ties
together
is
that
we
take
the
context
and
snapshot
it
with
events
and
the
intent
function
and
what
they
get
out
of
is.
A
A
What's
the
initial
state
before
anything
has
happened,
which
is
in
this
case
false
I
mean
just
monitors
as
a
boolean
and
then
there's
also
an
update
function,
which
pretty
much
tells
you
okay,
given
the
current
state
when
an
action
occurs,
I
want
to
change
my
state
to
that
new
state.
In
our
case,
there's
only
one
action
that
can
occur
and
when
it
occurs,
we
went
just
to
negate
our
current
state
and
that's
it,
and
this
is
where
fold
comes
in
I
talked
about
earlier,
so
we
just
yeah
full
the
action
stream.
A
With
these
two
items
that
pretty
much
satisfy
the
type
signature
of
fold.
Okay,
then
we
have
a
stream
of
states.
Now
we
just
want
to
transform
our
state
stream
into
a
view,
and
we
also
do
this
given
a
certain
context,
because
in
this
case
the
view
depends
on
the
context,
because
I
want,
when
I
hover
I
also
want
it
to
be
a
little
bit
highlighted
so
I'm,
seeing
okay,
I'm
hovering
and
the
state
and
so
I
just
map
these
things
accordingly.
A
So
when
it's
hovering,
it
is
a
light
blue
or
light
orange,
and
when
it's
not
it's
either.
Blue
or
orange
blue
and
orange
sort
of
represents
they've
cut
off
the
button.
That's
really
sad
that
I
couldn't
show
you
okay
right
and
the
way
how
we
transform
this
to
the
stream
level
again.
Is
that
the
output,
which
is
just
a
stream
of
views?
A
Essentially
it's
just
lifting
this
view-
function
over
the
input,
signals
of
context
and
the
state
they
go
right,
yeah,
that's
pretty
much
it
how
you
will
at
least
one
component
with
it
what's
missing
from
this
is
I
guess
how
to
compose
these
components
so
and
I
drew
a
lot
of
inspiration
from
both
the
EM
architecture
and
also
cycle
Jas.
That's
been
mentioned
in
this
context
before
so,
mostly
front,
end,
stuff
and
I.
A
Think
it's
pretty
easy
once
you
have
these
functions
to
just
compose
them
in
a
certain
way,
two
new
sets
of
functions
that
will
act
as
a
as
a
bigger
thing.
So
this
really
like
composed
pretty
nicely
and
another
part
that
you
also
should
think
about
when
doing
these
things
is
how
you
manage
the
effects.
So
effects
are
effectively,
so
we
can
say
in
some
sense
we
already
have
an
effect
by
having
a
signal
of
views,
so
that
affects
how
our
renderer
uses
OpenGL
and
the
window
it
contacts
and
everything
to
to
actually
show
us
something.
A
But
there
might
be
other
things
that
you
also
want
to
have
like
a
stream
of
network
messages
sent
or
something
like
that
right
now,
I
want
to
talk
a
little
bit
about
implementation,
details
of
the
library,
so
my
original
inspiration
for
this
was
the
sodium
set
of
library.
So
that's
pretty
much
a
an
implementation
of
FRP
that
is
done
in
variety
of
languages,
Java
and
c-sharp
and
originally
came
from
Haskell
I.
A
So
the
idea
behind
that
is
sort
of
so
the
current,
the
discrete
part
of
the
of
the
streams
pretty
much
pushed
through
the
system.
So
I
have
a
network
of
of
streams
in
a
way
and
when
something
occurs
somewhere,
it's
just
going
to
go
forward
to
through
this
network
of
streams
and
an
update,
whatever
state
might
be
affected
by
this
event
occurrence.
A
Whereas
when
you
have
something
continues,
such
as
an
transition
between
a
certain
state,
given
a
certain
interpolation
function,
it
kind
of
depends.
How
often
you
want
to
update
and
pretty
much
depends
on
how
many
frames
per
second
you
want.
So
if
so,
for
instance,
you
may
want
to
only
create
a
video
and
then
you
might
be
fine
with
either
30
or
60
FPS.
Whatever
format
you
use
are
you're
doing
something
with
some
virtual
reality.
A
However,
you
need
more
than
20
frames
per
second,
but
you
don't
really
want
your
application
code
to
depend
on
that,
and
so
it's
in
this
case
you
would
just
like
at
the
consuming
side.
So
when
you've,
given
it
you're,
given
a
signal,
you
will
just
pull
for
the
current
state
of
this
signal
inside
the
system
and
and
go
backwards
so
to
say,
and
that
way
you'd
pretty
much
like
how
often
you
need
to
evaluate
that
function
that
describes
the
signal
depends
really
on
how
much
demand
there
is.
A
In
that
particular
paper,
the
the
Boston
in
Haskell
originally-
and
it
was
a
very
nice
and
elegant
purely
functional
implementation.
I-
could
not
possibly
reproduce
that
in
rust,
because
there
was
strict
evaluation
and
there
was
also
the
point
with
resource
and
lifetimes,
and
it
was
just
getting
too
complicated
to
to
do
something
similar
to
that.
A
So
you
have
some
function
which
just
gives
you
the
system
time,
for
instance,
typical
system
call
they
can
see,
or
you
might
also
measure
analog
instruments
or
whatever
kind
of
kind
of
resource
you
want
to
pull
data
from,
and
you
can
just
create.
The
signals
from
that
that
is,
the
content
is
part
of
the
singles.
They
also
have
a
discrete
component
if
you
just
have
a
stepwise
thing
that
it
was
created
from
stream
right.
A
There
are
a
couple
of
yeah
problems
with
the
current
implementation,
so
while
it's
done
in
Ruston,
I
guess
I
pretty
much
had
to
do
this
with
our
garbage
collection,
which
which
work
pretty
nicely,
but
it
still
does
a
lot
of
atomic
reference,
counting
and
weak
references
and
also
a
lot
of
heap
allocation
pointer
interactions.
So
it's
not
as
fast
as
it
could
possibly
be
I
think
so
it's
probably
some
still
some
room
for
improvement
and
it's
probably
not
useful
yet
for
say,
I
use
in
embedded
systems
or
something
like
that
and
yeah.
A
Another
issue
is
also
that
transactions
are
pretty
dumb
so
far.
So
the
way
it's
done
is
essentially
there's
a
global
lock
on
the
entire
graph
of
events.
Whenever
you
want
to
do
something,
and
after
you're
done,
we
release
that
so
there's
not
really
any
parallelism.
They
have
been
thinking
about
ways
to
improve
that,
but
so
far
just
try
to
get
at
the
correct
semantics.
Okay,
yeah!
That's
pretty
much
it!
Thank
you
for
your
intention
and.
C
Hello
yeah,
you
started
out
with
an
example
where
you
put
something
into
a
sink
and
then
assert
that
something
comes
out
and
off
the
stream
mm-hmm.
But
this
implies
that
it's
single
threaded
and
you
said
it
was
thread
safe.
So
are
you
always
in
a
single
threat
or
can
you
do
give
the
stream
to
someone
in
another
threat
and
then
you
only
hear.
A
A
So
the
way
the
send
function
works
is
actually
synchronous,
but
it's
thread
safe.
So
if
you
were
to
you,
you
there's
also
an
asynchronous
variant
of
it,
so
you
could
put
in
a
thread
and
just
send
it
through
the
system.
The
way
it's
done
is
thread
safe,
but
in
this
example,
if
I
had
sent
the
event
and
asserted
afterwards,
I
wouldn't
even
sure
that
it
had
propagated
through
the
system
yet
so
this
is
just
why
I
made
it
synchronous
in
this
case.
A
Did
look
at
that
I
think
it
actually
existed
longer
than
my
implementation,
but
what
I
found
was
there
was
not
well.
First
of
all
it,
it
was
written
at
a
time,
I
think
before
us
was
really
stable
and
wasn't
actively
maintained
and
looking
at
the
implementation,
ie
yeah,
it
was
really
pretty
complex
and
so
yeah
I
started
from
scratch.
Basically,
because
I
didn't
want
to
touch
an
existing
code
base
that
I
didn't
know
what
kind
of
problems
there
weren't
in
it,
but
I
think
it's
not
really
usable
at
the
moment.
As
far
as
I
know,.
D
A
The
next
function
is
really
just
a
matter
to
satisfy
rusts
iterator
semantics.
So
essentially,
what
happens
if
you,
if
you
attach
an
iterator
to
a
stream,
it
just
registers,
sort
of
a
callback
that
puts
something
into
a
channel
that
has
a
queue
and
if
you
have
the
iterator,
you
can
just
take
from
that
queue.
So
that's
just
a
intermediary
mechanism
to
to
have
something
like
a
rust
iterator,
but
it
doesn't
really
have
to
do
anything
with
how
the
stream
itself
is
implemented.
Yep.
D
A
B
A
A
That
being
said,
though,
I
mean
that
can't
be
enforced
by
Russ,
because
inherently
it's
still
an
imperative
language
and
while
it
has
so
I
can
enforce
immutability
formally,
it's
still
possible
for
you
to
in
a
given
function
to
construct
something
that
has
inner
mutability,
such
as
a
mutex
and
just
locally
produce
some
in
temporary
immutable
immutable
state
and
access
that.
So
it's
not
really
possible
to
to
constrain
that,
but
but
the
implantation
relies
on
it
entirely.
Yeah.