►
Description
Developers who approach Rust from the viewpoint of other OO languages like TypeScript, C#, or Java frequently misinterpret Rust's traits as interfaces. That might be true to a certain extent, but on closer examination traits are much more powerful than you might think. In this demo-only session, Rainer Stropek starts by introducing you to the fundamentals of traits. You will see how to create your own ones, how to manually implement system traits, and how to auto-implement them. Once we covered those basics, Rainer dives deeper into unique features of traits. We will look at default implementations, trait parameters, trait objects, and trait bounds for generics.
Rainer on Twitter: https://twitter.com/rstropek
Rust Linz on Twitter: https://twitter.com/rustlinz
A
A
I
hope
the
summer
will
be
long
and
we
will
be
able
to
do
more
in-person
meetups
here
at
the
sundeck
of
the
of
the
garage,
but
now,
let's
get
into
our
second
talk,
let
me
quickly
introduce
myself
before
I
go
right
into
the
topic,
so
let
me
switch
it
up
here
and
here
and
now
it
is
like
it
should
be.
Okay,
I
think
a
good
idea
is
to
introduce
oneself.
Let
me
quickly
introduce
myself
to
you.
My
name
is
rhinostropic.
A
Together
with
stefan,
I
founded
the
rust
lens
meetup.
Personally,
I
am
a
passionate
software
developer.
I
have
been
writing
code
for
more
than
25
years,
and
I
always
say
every
day
where
I
can
write
code
is
a
good
day.
Unfortunately,
I
can't
write
code
every
single
day,
because
if
you
work
in
it
for
a
few
years,
you
have
some
management
to
do.
A
You
have
project
management
to
do
you
have
to
do
some,
some
some
sales,
stuff
and
so
on,
but
many
days
are,
for
my
personal
life
are
coding
days
and
I
really
enjoy
that
for
more
than
25
years,
I'm
a
microsoft,
mvp
and
regional
director.
That
does
not
mean
that
I'm
on
the
payroll
of
microsoft,
not
at
all.
That
means
that
I
do
just
a
lot
of
work
with
the
community
and
if
you
do
that,
you
are
promoted
to
a
most
valuable,
professional
or
original
director.
A
That's
all
so
to
make
a
long
story
short
beside
my
professional
work.
I
do
a
lot
of
trainings.
I
am
a
part-time
teacher,
I'm
a
mentor
in
the
community,
I'm
chairman
of
the
coding
club
linds.
We
run
the
local
code
of
jalen's,
which
is
the
programming
club
for
kids
here
in
linz
and,
of
course,
the
rust
links
meetup.
A
That's
essentially
me
and
if
you
would
like
to
get
in
touch
with
me
on
the
right
bottom
side
of
the
slide,
you
see
my
digital
business
card,
just
click
on
the
link
or
type
it
in
it's
not
that
complicated
and
on
the
right
lower
bottom.
You
find
links
to
linkedin,
twitter,
facebook,
my
youtube
channel
and
so
on
and
so
on.
So
I
invite
you
to
get
in
touch
with
me
enough
introduction.
A
Let's
take
a
look,
what
we
are
going
to
do.
We
are
going
to
play
tic-tac-toe,
I
I
said
I
love
writing
code
and
I
learn
most
when
I
write
code
and
one
of
the
traditional
thing
that
you
build
in
a
new
language
is
a
tic-tac-toe
game,
and
today
we
are
going
to
build
tic-tac-toe.
Well,
it
will
be
more
of
a
code
walkthrough
because
so
many
things
are
here
live
here
outdoor
and
so
on.
So
I
wasn't.
A
I
I
wasn't
brave
enough
to
type
the
code
live,
so
it
will
be
a
code
walkthrough,
and
I
will
show
you
my
points
with
existing
code
and
of
course
I
will
over
engineer
the
tic-tac-toe
game
a
little
bit
because
then,
with
an
over-engineered
tic-tac-toe
game,
you
can
learn
a
lot
on
the
way
of
building
this
tic-tac-toe
game.
We
will
learn
some
things
about
traits.
If
you
want
to
take
a
look
at
my
code
in
detail,
I
cannot
talk
about
every
single
line
in
just
an
hour.
A
A
Let
me
quickly
go
to
slides.com
here
and
have
where
is
my
this
one
and
let's
share
this
one?
This
is
the
link
you
see.
This
is
the
link
and
I
will
can
I
quickly
copy
that
into
the
into
the
chat.
I
think
so.
I
think
I
can
do
that
live,
and
here
is
the
link
it's
in
the
youtube
chat
now.
So
if
you
would
like
to
follow
the
slides
directly
online,
you
can
now
take
a
look
at
the
youtube
chat
and
there
you
find
the
link
to
my
slides
good.
A
Please
slide
go
to
yes.
Next
slide.
Okay.
Internet
is
a
little
bit
slow
here.
So
you
don't
see
this
funny
gif
here,
that's
one
of
my
favorite
games.
When
I
was
too
too
fast
too
fast
too
fast,
don't
do
the
spoilers
here
just
one.
This
is
one
of
my
has
been
one
of
my
favorite
games.
When
I
was
a
kid
anybody
know
this
game,
prince
of
persia
is
exactly,
and
you
see
this
one
is
really
the
basic
stuff
we
are
just
entering
the
first
level.
A
We
are
opening
a
first
door,
and
that
is
a
good
thing
to
get
started
to
talk
a
little
bit
about
traits.
Okay,
what
is
a
trait?
Let
me
quickly
copy
this
one
to
show
it
to
you
life.
This
is
a
very
very
simple
example,
and
in
order
for
you
to
follow
along
is
more
easily.
I
will
go
to
the
rost
playground.
A
A
Whatever
that
self
is
self
sounds
like
this,
and
this
arrow
with
u8
means
we
are
returning,
probably
a
byte,
something
like
this.
This
looks
very
much
like
an
interface.
I
know
that
in
c
sharp
I
would
build
a
struct
or
a
class.
I
would
create
an
interface
something
like
this.
This
could
be
a
struct.
You
could
ask
yourself
why
a
struct
without
members-
yes,
that's
possible.
That's
definitely
possible
in
rust.
That
is
called
a
unit
struct
and
then
you
can
implement.
As
you
can
see
it
here,
you
can
implement
a
trait
for
a
certain
struct.
A
It
looks
a
little
bit
different
than
in
typescript
or
in
c
sharp.
It
looks
pretty
similar
kind
of
with
go,
but
it
yeah.
It
feels
like
an
interface.
It
sounds
like
an
interface,
it
smells
like
an
interface.
I
think
I
understood
that
that
is
fine
and,
as
you
can
see
it
here,
I
can
instantiate
deep
thought
and
I
can
ask
deep
thought
for
the
ultimate
answer,
and
probably,
if
I
run
this,
I
will
get
42.
Of
course
that's
a
very
simple
getting
started.
A
That
was
my
first
introduction
to
traits,
but
when
I
got
more
when
I
got
more
interested
in
the
details,
let
me
try.
If
I
can
zoom
in
a
little
bit,
I
was
asking
myself
okay,
what
happens
behind
the
scenes
and
if
we
take
a
look
at
the
generated
assembler
code-
and
I
have
copied
it
out
here-
I
used
the
type
the
rust
playground
to
generate
the
assembler
code.
What
I
essentially
saw
is
that
this
interface
was
nearly
gone.
It's
not
visible.
A
Well,
it
is
kind
of
visible
a
little
bit
only
in
the
in
the
in
the
names
of
the
generated
jump
labels
here,
but
essentially
it
is
gone.
If
we
call
this
method
get
answer
which
is
a
method
from
a
trait,
then
we
essentially
get
a
call
assembler
statement
directly
a
call
assembler
statement
with
a
static
dispatch
of
this
method,
really
really
simple.
So
I
think
this
is
what
many
rust
developers
means
when
they
say:
zero
trust,
abstractions,
zero
cost
abstractions,
I'm
very
sorry.
They
are
trusted.
A
A
Let's
take
a
look
at
one
of
my
first
things
that
I
implemented
here.
Let
me
quickly
look
for
the
code
that
I
would
like
to
show
you.
Where
is
it?
Where
is
it
I'm
going
to
find
it?
And
it's
here,
let
me
zoom
in
a
little
bit,
so
you
see
it
pretty
good
close
here.
You
see
a
trait
and
in
this
case,
for
demo
purposes,
I
created
a
structure
which
is
called
board
content.
It
will
hold
the
data
for
my
tic-tac-toe
game.
A
Okay,
it
contains
essentially
a
three
by
three,
so
nine
elements
of
size,
u8
array,
so
eight
nine
bytes,
four
three
by
three
elements
for
our
tic
tac
toe
game,
and
in
this
case
I
wanted
to
build
an
abstraction
which
I
called
to
compact
string,
which
does
nothing
else
than
taking
all
these
nine
elements
and
turning
them
into
a
string
very,
very
obvious
code.
Even
if
you
have
not
written
a
lot
of
rust
before,
you
will
probably
be
able
to
understand
this
code
from
the
context.
A
A
Okay,
that
should
be
pretty
obvious
any
questions
to
this
code.
Maybe
those
of
you
who
have
not
written
a
lot
of
rust
code.
I
know
there
are
some
people
here
in
the
audience
who
have
not
written
rust
code.
Some
of
the
beautiful
things.
Do
you
see
the
missing
return
statement?
Yes,
I
don't
need
a
return
statement.
You
see,
I
just
write
result
without
the
semicolon
at
the
end
and
that's
the
res.
That's
the
return.
A
You
know
what,
since
I
mix
rust
and
c
sharp,
I'm
I'm,
I
think
people
think
I'm
stupid
whenever
I
give
c
sharp
talks,
because
I
always
forget
the
return
statement.
I
am,
I
call
myself
a
c-sharp
trainer
and
I
don't
know
how
to
write
the
return
statement.
So
if
you
see
that,
if
you
see
me
doing
that
on
stage
now,
you
know
why
I
do
that
because
maybe
in
the
morning
I
wrote
rust
in
the
afternoon,
I
write
c-sharp
and
I
always
mix
it
up.
So
this
is
rust.
This
is
interface.
A
This
is
traits,
and
this
is
the
first
step.
Let's
go
back
to
the
slides
and
let's
take
a
look
at
my
second
note.
Yes,
let's
take
a
look
at
a
little
bit
more
advanced
example,
let's
fold
that
one
and
let's
take
a
look
at
this
one,
let's
make
the
font
a
little
bit
larger,
so
everybody
can
see
it
properly.
A
Here
you
see
this
one,
a
square
content,
it's
an
enum.
Many
of
you
know
enums
from
many
different
languages
and
rust
has
enums
too.
This
is
a
so-called
fieldless
enum.
That
means
we
don't
have
any
additional
data,
because
in
rust
we
could
give
additional
fields
to
certain
elements
of
the
enum.
If
we
want
to
so,
we
could
say
well
in
the
case
of
an
x,
I
want
to
have
additional
data
like
a8
or
a
whole
struct
or
whatever
it
could
add
additional
data,
but
I'm
not
doing
that.
A
The
first
thing
that
you
have
to
see
and
recognize
here
and
that
is
pretty
awesome,
see
that
one
we
can
implement
traits
in
this
case.
This
is
a
system
trait
the
default
trait
that
allows
rust
to
understand
what
the
default
value
of
a
type
is.
I
didn't
define
this
trade.
This
is
this
trait
is
system
defined,
but
I
can
define
traits
on
enums.
A
Additionally,
you
might
recognize
that
up
here
I
have
this
strange
thing:
hash
derive
with
debug
and
copy
and
clone
and
partial,
equal
and
equal
guess
what
all
these
things,
diva
copy,
clone
and
so
on
are
traits.
And
what
you
see
here
in
line
four
is
the
so-called
auto
implementing.
We
can
just
ask
ask
rust
to
auto
implement
all
these
interfaces.
For
us,
this
is
a
macro,
so
rust
comes
with
macros
and
these
macros
can
auto
implement
trades
for
us.
A
If
they
are
pretty
simple,
for
instance,
there
is
a
trait
here
copy,
which
just
says
I
can
copy
this
data
type
by
copying
the
underlying
bits
this
can
be
auto
generated.
There
is
no
reason
why
I
have
to
write
code
for
that,
and
this
is
the
derive
macro
that
you
see
here
by
the
way.
If
you
want
to
know
what's
going
on
behind
the
scenes,
you
can
always
copy
this
stuff
go
back
to
our
good
friend,
the
rust
playground
paste
it
in
and
then
somewhere.
I
think
it
is
here
yes,
expand.
A
Macros
takes
a
second
takes
a
second,
and
here
we
are
see.
This
is
the
code
that
is
generated.
No,
I
will
not
walk
you
through
this
code.
You
can
do
that
experiment
on
your
own,
but
that's
essentially,
what's
going
on
behind
the
scenes
auto-generating
traits
for
your
data
types
whenever
they
are
pretty
simple
and
when
they
can
be
auto-generated,
that's
going
on
the
first
few
lines
of
code
here,
so
you
see
a
little
bit
more
than
just
interfaces.
Isn't
it
let's
go
further?
A
The
next
thing
here
is
another
system
trait
that
I
implement.
Here
you
see
square
content.
Is
again
our
enum
and
this
time
I'm
implementing
the
from
trait
from
is
typecasting.
If
we
want
to
have
typecasting,
we
implement
the
from
trait.
So
in
this
case
I'm
saying
I
want
to
be
able
to
generate
a
square
content
from
an
unsight
unsigned
byte
from
eight
bits,
and
then
I
use
the
match
statement
of
rust
in
order
to
turn
the
values
of
the
unsigned
eight
into
square
content
fields.
If
the
value
is
not
available,
then
we
just
panic.
A
A
So
what
you
can
say
you
could
say
implement
into
for
u8,
for
an
eight
by
eight
bit,
unsigned
eight
bit
unsigned
byte
to
turn
it
into
a
square
content,
so
we
have
from
in
one
direction
and
into
in
the
other
direction
so
which
one
should
you
implement
and
now
comes
the
beautiful
thing,
something
again
new
for
those
of
you
who
haven't
looked
so
deeply
into
rust.
You
get
it
for
free
if
you
implement
from
you
get
into
in
the
other
direction.
A
Automatically
without
writing
a
single
line
of
code,
if
you
are
not
an
if
you
are
not
an
experienced
rust
developer,
you
can
now
ask
yourself:
how
could
that
be?
How
is
that
implement?
Is
that
magic
built
into
the
rust
compiler?
No,
it
isn't.
I
will
show
you
the
source
code
in
the
rust
library
in
a
few
minutes
where
you
will
see
how
this
magic
is
done,
how
this
works
and
guess
what
the
magic
is
traits
again
tricks.
A
Oh
very
good
question:
I
will
repeat
this
question
question:
could
I
implement
into
and
get
from
for
free?
Yes,
you
would
do
that,
but
it
is.
It
is
recommended
that
you
always
implement
from
and
not
into
that's
a
kind
of
yeah.
That's
a
kind
of
convention
if
you
want
in
the
standard,
yes
into,
is
also
for
all
yeah
exactly.
That
is
what
I
meant
with
you.
Get
it
for
free.
A
I'm
pretty
sure,
I'm
pretty
sure,
I'm
pretty
sure
I'm
not
100
sure,
but
I
think
I
have
to
check
it.
It's
a
good
thing.
I
have
to
check
it,
but
if
you
implement
from
what
I
said,
you
get
definitely
into
okay
and
just
implement
from
that's
the
convention.
Thank
you,
stefan
for
pointing
that
out.
If
I'm
wrong,
I'm
very
sorry
for
that
I
always
implement
from
so
maybe
I
forgot
something
you
see.
A
I
wrote
some
type
conversions
and
let
me
quickly
go
down
here
for
those
of
you
who
have
not
written
so
many
lines
of
rust
code.
These
are
unit
tests.
You
see
line
63
64.
These
are
unit
tests
for
the
code
that
you
have
seen
above
and
now
we
can
take
a
look
at
how
these
traits
are
applied.
You
see,
for
instance,
take
a
look
at
this
line
of
code
here.
This
one
line
71
here
I'm
saying
default
default
default
is
the
name
of
the
trait
I
can
call
here.
A
A
Here
you
see
the
from
and
the
into
part.
Let
me
quickly
draw
a
little
bit
here
here.
You
see
the
from
code,
where
I
convert
a
one
byte
into
the
square
content
and
again
rust
is
pretty
pretty
smart,
even
with
the
even
with
the
traits.
If
I
hover
over
the
one
here,
it
recognizes
automatically
that
this
has
to
be
an
u8,
because
the
front
rate
into
the
square
content
is
implemented
only
for
u8.
So,
therefore
I
don't
need
to
specify
that
this
is
a
byte
value.
I
could
do
that,
but
I
don't
need
to.
A
A
There
is
a
short
internet
glitch
here.
I
hate
that
when
that
happens,
yes,
my
wi-fi
is
suddenly
gone.
Luckily,
we
are
projecting
from
a
different
computer
which,
which
still
has
wi-fi.
So
let
me
quickly
switch
to
our
second
wi-fi.
I
hope
it
will
work.
We
have
three
wi-fi's
here
just
to
make
sure
okay.
A
A
This
is
what
I
meant.
You
see
it.
Oh
it's
a
little
bit
slower
here.
It's
it's
fine
here!
You
see!
This
is
what
I
meant.
I
don't
need
to
add.
U8
rust
is
analyzing
the
traits
automatically
and
it
finds
out
that
this
u8
is
not
necessary
because
it
understands
that
the
from
trait
is
available
for
u8
into
square
content,
and
it
does
all
the
magic
automatically.
A
A
A
A
Next
one
is
string.
I
did
the
same
for
a
character
as
you
can
see
it
here
and
just
to
to
to
add
a
little
bit
of
extra
for
those
people
here
in
the
audience
who
have
not
written
so
much
rust
code.
This
is
how
you
would
write
a
unit
test
which
is
expected
to
panic.
It
has
nothing
to
do
with
the
trait,
but
I
decided
to
just
let
it
in
here,
so
you
see
it
and
maybe
it's
interesting
for
you.
I
see
some
people
nodding
their
heads.
A
I
know
you
are
c-sharp
guys
and
typescript
guys
and
so
on.
So
you
have
probably
seen
a
little
bit
of
frost,
but
not
so
much
so
this
is
how
it
looks
like
so
this
was
again
a
little
bit
of
basics,
and
with
that
I
go
back
to
my
slide
deck.
This
is
the
wrong
one.
This
is
the
right
one
here
we
are,
we
saw
from
into
default
everything's
fine.
A
Now,
let's
go
one
step
further
and
take
a
look
at
the
board
index
class
that
I
created,
not
class,
of
course
a
struct
because
we
are
talking
about
rust
here.
What
is
the
board
index?
The
board
index
is
a
struct
here.
You
see
it
which
contains
behind
the
scenes.
Just
a
u-size
value,
a
u-size
value
is
just
an
indexer
in
an
array,
and
the
size
depends
on
the
machine
machines
register
sizes.
In
my
case,
it's
a
64-bit
machine.
So
it's
a
64-bit
value
that
you
see
here.
A
That's
use
size
essentially,
and
what
I
want
to
build
is
I
want
to
build
a
secure
way
of
indexing
in
our
three
by
three
board.
So
I
want
to
build
an
abstraction
on
top
of
view
size
that
can
only
contain
valid
values
between
zero
and
eight
nothing
else,
and
then
I
would
like
to
build
an
index
logic
in
our
board,
where
I
can
specify
indexing
a
custom
indexer
with
our
own
type.
Okay.
So
let's
take
a
look
at
that
one
here
you
see
this
is
our
board
index
type?
A
The
implementation
is
not
that
interesting
because
we
want
to
focus
on
traits.
Okay,
the
implementation
on
of
board
index
is
not
so
relevant
for
traits.
So
I
will
quickly
go
through
that
and
go
down
down
down
here
where
we
start
to
see
again
some
of
the
traits
the
first
traits
are
pretty
obvious
because
you
already
learned
about
them.
I
built
a
type
converter
from
you
size
to
the
board
index.
A
Okay,
sorry,
the
other
way
around.
This
is
what
sorry
I
was
confused
this
time,
I'm
implementing
an
interface
on
a
standard
type
you
size
to
be
able
to
convert
you
size,
sorry,
the
board
index
into
you
size.
Now
I
have
it
correctly.
Sorry,
I
was
a
little
bit
confused,
so
I'm
telling
the
system
whenever
you
have
a
board
index,
I'm
clicking
too
much,
and
it's
too
slow
here.
So
here
we
are.
A
Whenever
you
have
a
board
index
and
you
need
to
have
a
u
size,
you
can
directly
take
the
inner
value
of
the
board
index
and
return
it.
So
this
is
another
takeaway
that
you
can
get
a
get
from
this
talk.
You
can
easily
implement
traits
on
top
of
system
data
types
in
this
case,
I'm
implementing
a
trait
for
new
size,
a
type
which
I
definitely
did
not
implement
on
my
own.
A
A
The
other
way
around
is
just
calling
a
method.
This
method
method
checks
whether
the
value
is
between
0
and
8.
That's
fine
and
I
also
do
some
parsing.
How
does
parsing
work
ix
is
a
string
and
now
suddenly
rust
knows
that
parse
has
to
parse
a
value
and
turn
it
into
a
board
index.
How
does
it
know
that
I
invented
the
logic
that
a
board
index
is
represented
by
a
string
combination
like
a1
or
a3
or
c2?
A
A
So
if
you
implement
the
from
string
trait
for
a
data
type
in
this
case,
a
static
string,
I
just
implemented
here
for
a
static
string,
and
then
I
can
write
some
parsing
logic,
and
here
you
see
I
will
not
go
into
the
details,
because
this
is
just
rust
and
if
you
you're
not
familiar
with
rust,
you
can
take
a
look
at
the
code
afterwards.
The
essential
thing
that
I
want
to
tell
you
here
is
that
this
again
is
a
trait
and
by
implementing
this
system
trait,
I
get
the
parse
statement
for
free.
A
Some
of
you
might
have
a
little
bit
of
problems
here,
because
you,
you
might
ask
yourself
here
what
is
this
result
all
about?
That's
essentially
a
data
type
in
rust,
where
I
can
specify
that
the
result
can
be
either
self
in
this
case,
the
board
index.
So
I
successfully
created
the
board
index
from
the
string
or
I
create
an
error.
Type
result
is
an
enum,
and
this
enum
has
two
possible
values.
A
Okay
and
error,
okay,
would
be
that
one
and
if
I
scroll
down
a
little
bit,
you
see
this
is
the
happy
case,
and
this
is
the
second
one.
This
is
the
error
case.
This
is
where
you
have
something
like
this,
so
this
is
how
the
from
string,
the
from
stir
trade
works.
You
just
return
either
the
okay
happy
part
or
the
error,
depending
whether
you
could
parse
the
value
and
everything
is
built.
On
top
of
this
trait.
A
A
sip
here
and
wait
whether
we
have
some
questions
matthias
asks
any
reasons
why
you
didn't
use
rust
stock.
Three
slashes
here
in
this
case
it's
not
really
matthias.
It's
not
really
a
documentation
for
this
trait.
It's
just
notes
for
me
to
remember
what
I
want
to
tell
you.
So
matthias
is
perfectly
right,
rust,
stock.
The
correct
way
of
writing
documentation
in
rust
is
with
three
slashes
and
not
two
slashes,
but
these
are
just
my
personal
notes,
not
documentation.
A
We
have
a
video,
I
think,
stefan
in
our
library,
where
we
had
a
full
hour
talk
about
how
to
create
awesome,
rust
documentation.
So
if
you
are
now
confused
by
me
doing
it
not
right,
take
a
look
at
this
video.
We,
this
video
is
awesome.
You
will
really
learn
a
lot
in
this
video
check
out
rustlings80.
You
will
find
it
there,
but
thank
you
matthias
for
pointing
that
out,
let's
scroll
down
a
little
bit-
and
we
have
a
new
trait,
of
course,
straight
straight
straight-
the
display
trait.
A
A
Do
I
have
a
unit
test
for
that?
Yes,
I
have
a
unit
test
for
that.
You
see
this
one.
This
is
the
using
of
the
display
trait
whenever
you
use
the
print
line
macro
or
the
format
macro,
to
turn
a
board
index
into
a
string,
and
you
use
this
curly
braces
opening
close
thing
here.
Rust
knows
that
it
has
to
call
the
display
trait
in
order
to
turn
the
board
index
into
a
proper
string
in
our
case
a1
b2
c3.
Something
like
this.
A
There
is
another
trait
with
this,
which
is
important
in
that
regards
it's
the
debug
trait
you
can
auto
implement
it
or
you
can
implement
it
by
hand,
and
this
is
used
whenever
you
use
the
colon
question
mark
syntax
to
to
print
the
debug
output
of
your
value.
Okay,
that
is
a
different
trait,
but
in
this
case
we
are
talking
about
the
display
trait.
This
is
another
important
one
that
we
have
in
this
example
display
trade.
A
Last
but
not
least,
we
have
two
interesting
ones,
add
and
sub
again,
two
system
traits
and
these
system
traits
power.
What
what
do
you
think,
plus
and
minus
they
are
powering
operator
overloading,
so
you
have
to
implement
a
trait
and
in
order
to
be
able
to
use
the
plus
and
minus
operator,
so
in
this
case
I'm
implementing,
add
and
sub
on
the
board
index
so
that
I
can
add
and
subtract
board
indexes
from
each
other.
A
Let
me
scroll
down
a
little
bit
and
see
whether
I
can
find
whether
I
can
find
the
prop
yeah
here
you
have
it.
You
see
here.
In
this
case
I
am
taking
a
board
index
and
I'm
adding,
let's
hover
over
it
use
size
on
top
of
it
and
the
result
will
be
another
board
index,
and
here
I
can
subtract
from
something
from
my
board
index
in
order
to
reduce
my
board
index
and
the
result
is
again
another
board
index.
A
So
if
you
want
to
have
operator
overloading
in
rust,
implement
system
trades
and
then
you
get
support
for
the
plus
and
minus
operator
out
of
the
box,
so
you
can
already
see
that
tr
that
that
traits
are
very,
very
deep
into
the
ecosystem
of
of
rust.
Whenever
you
write
rust
code,
you
have
to
deal
a
lot
with
traits
other
languages,
like
c
sharp,
a
language
that
I
know
for
more
than
20
years.
I
think
they
are
doing
it
completely
different.
A
They
are
having,
for
instance,
static
members
on
types
where
you
can
do
operator
overloading
completely
different
address
like
rust.
Does
it
here
by
the
way,
if
you
ask
yourself,
hey
rhino,
what
is
this
stuff?
This
has
nothing
to
do
with
traits.
This
is
a
very
interesting
crate.
It's
a
kind
of
library
which
is
called
rs
test.
Rs
is
not
my
name,
it's
not
rhinostropic!
A
I
have
not
written
it
yeah.
Somebody
else
has
written
it
and
it's
essentially
data-driven
unit
testing.
You
can
easily
write
data-driven
tests
like
this
in
rust,
it
works
like
a
charm.
I
really
like
to
use
it
and
I
think
even
those
of
you
who
have
not
written
so
much
lines
of
code
in
rust,
you
will
guess
you
will
be
able
to
guess
from
the
context
what
this
stuff
is
all
about
nice.
A
So,
let's
go
back
to
our
slides
and
let
me
check
yeah.
I
promised
you
that
we
will
take
a
look
into
why
we
get
this
into
for
free
if
we
implement
from
and
what
I
did
is
I
looked
up
the
relevant
code
piece
in
the
rust
library
in
github,
and
here
you
see
what
the
magic,
what
the
magic
does
take
a
look
at
that
one
and
that
is
pretty
awesome
and
pretty
different
to
many
other
languages
latest
here.
A
At
that
point
in
time,
you
should
understand
that
traits
are
way
more
than
the
usual
interfaces
you
might
know
from
other
languages.
Take
a
look
at
this
type.
This
is
an
implementation
of
the
into
trait
for
any
type
t
line
45
here,
where
sorry
for
any
type?
U
where?
U
implements
from
so
essentially
into,
is
auto
implemented
for
any
type
offering
from
by
just
calling
from
in
the
other
direction,
so
you
can
implement
traits
on
top
of
other
traits.
A
A
A
Boards
content
showed
you
that
we
have
a
trait
there,
which
is
called
two
compact
string.
Let
me
go
back
to
the
board
content
here.
It
is
I
implemented
to
compact
string
and
I
implemented
it
on
top
of
board
content,
but
I
asked
myself:
what
can
I
show
you
more?
How
can
I
show
you
what
we
are
capable
of
doing
in
terms
of
doing
more
powerful
abstractions?
A
And
here
I
have
added
a
second
trait
board
it
to
compact
string,
which
is
very
similar
to
the
two
compact
string
trait,
but
this
time
I
am
it's
the
same.
Signation
you
see
it.
I
can
copy
it
to.
I
can
turn
it
into
a
compact
string
representation,
but
this
time
I'm
implementing
it.
On
top
of
you
see
it
here,
an
iterator
over
an
array,
so
I'm
no
longer
implementing
the
trait
for
a
concrete
type
like
the
board
content
struct.
A
But
I
know
I
know
that
my
board
content
internally
has
a
static
sized
array.
Nine
elements.
Therefore,
it
is
very
simple
to
implement
an
iterator.
Essentially,
the
array
already
implements
an
iterator
and
if
I
have
an
iterator,
I
can
abstract
my
trait
board
into
the
compact
string
away
from
the
board
content
and
build
it
on
top
of
the
iterator
over
the
array
and
therefore
my
trait
implementation
is
now
more
flexible.
It
works
works
with
any
iterator
over
any
nine
element
array.
Here.
It
doesn't
need
to
be
my
board
content.
A
It
can
be
your
board
content
as
long
as
you
can
provide
an
static,
iterator
array,
sorry
a
static
iterator
over
an
array.
You
are
fine,
my
implementation
will
work
for
you,
so
this
is
the
application
of
this
building,
a
trait
on
top
of
a
trait
now,
not
in
the
standard
library,
but
in
my
own
application
I
can
make
my
implementations
more
flexible.
A
I
can
make
it
more
widely
usable,
that's
the
idea
here,
it's
just
a
demo.
So
don't
ask
for
the.
Why
is
this
really
a
good
idea?
Is
this
the
best
design?
Probably
not,
but
I
want
to
showcase
some
of
the
features
what
you
can
do
with
traits?
Okay,
that's
my
point
here.
So
let
me
take
a
sip
of
water
here
and
wait
for
any
possible
questions.
A
Okay,
good,
no
questions
currently,
so
I
think
you
want
to
know
more
good.
I
just
opened
pandora's
box
of
the
entourage.
No,
it's
not
pandora's
box.
It's
a
it's
a
huge
cake,
a
huge,
a
huge
playground.
Iterators
are
awesome
in
rust.
I
come
from
a
world
of
I
mentioned
that
before
c
sharp
and
in
c
sharp
we
have
an
awesome
functionality
which
is
called
link.
I
love
it.
Language
integrated
query,
it's
so
awesome
mapreduce.
A
If
you
are
a
javascript
developer
and
in
rust
it's
iterators
on
top
of
iterators,
you
can
do
all
the
crazy
stuff
like
mapping
and
filtering
and
summing
and
all
this
stuff
is
built
on
top
of
iterators.
So
let
me
quickly
show
you
how
we
can
turn
our
board
content
into
an
iterator.
That's
pretty
simple.
A
We
can,
for
instance,
implement
the
trait
into
iterator
for
our
board
content,
and
then
this
into
iterator
trait
has
something
unique,
which
is
again
very
special
for
rust,
and
I
don't
know
this
feature
from
other
interfaces
from
other
implementations
of
interfaces
in
other
languages.
In
this
case
we
have.
Let
me
draw
a
little
bit
here.
A
We
have
parameters
for
traits,
so
the
into
iterator
trait
demands
two
parameters.
You
have
to
tell
it:
okay,
what
is
the
type
that
we
will
get
back
item
by
item
and,
secondly,
you
need
to
specify
and
a
structure
that
you
will
use
as
your
iterator,
because
the
iterator
is
represented
by
a
structure
by
a
data
type.
A
So
I'm
using
the
array
into
it
and
I'm
just
asking
my
internal
array
for
its
iterator
and
I'm
just
returning
it,
and
with
that
I
offer
the
array
iterator.
On
top
of
my
board
content
in
a
second,
you
will
see
that
we
can
build
completely
custom
iterators
which
come
with
with
complete
custom,
iterated
types.
A
Understood:
okay
sounds
like
one
sounds
like
haskell
was
the
comment.
I
have
no
idea
because
I've
never
written
a
single
line
of
haskell.
I
believe
you,
I
absolutely
believe
you.
Let
me
show
you
what
we
can
do
with
that.
If
we
take
that
one
step
further,
I
have
implemented
here
here.
You
see
it
a
bunch
of
types
in
order
to
be
able
to
show
you
how
you
can
build
a
completely
different
iterator.
In
my
case,
I
want
to
implement
an
iterator
which
allows
me
to
iterate
over
the
rows
of
my
board.
A
Remember
I
don't
have
a
two-dimensional
array.
I
have
a
single
dimensional
array
which,
with
just
nine
elements
in
it,
and
I
want
to
build
an
iterator,
a
virtual
iterator,
which
iterates
over
rows,
which
do
not
really
exist.
There
is
no
data
structure
internally.
That
has
rows.
So
how
can
I
do
that?
First,
I
implement
the
structure
which
is
called
row.
This
is
a
small
data
type
which
holds
a
reference,
a
pointer
to
the
underlying
board
content
and
the
row
index
a
pointer
and
an
index.
A
You
might
ask
yourself
what
this
funny
thing
is
like
this
is
the
so-called
lifetime
is
that
it
has
nothing
to
do
with
traits.
It
is
a
different
topic
for
a
different
talk.
Just
so
much.
You
need
the
lifetime
here,
because
rust
needs
to
understand
that
the
row
can
never
outlive
the
board
content
that
it
cannot
happen
that
you
have
a
board
in
your
hand,
and
you
already
destroyed
the
underlying
board
content
in
c
sharp.
A
I
could
do
that
and
if
I
do
that,
and
I
try
to
access
the
underlying
content,
things
would
go
horribly
wrong
in
rust.
The
compiler
is
smart
in
rust.
The
compiler
has
these
lifetime
annotations
and
with
that
it
doesn't
need
a
garbage
collector
and
it
can
still
prove
mathematically
proof
that
it
will
never
happen
that
you
have
a
role
that
outlived
the
underlying
data
type.
This
is
what
lifetimes
are
all
about.
You
can
use
lifetimes
in
traits.
A
Definitely
I
will
not
go
into
the
details
here,
but
I
just
want
you
to
be
able
to
follow
what
I
show
here.
So
if
you
ask
yourself
what
is
this,
this
is
a
lifetime
annotation,
I'm
binding
the
lifetimes
of
these
two
things
together
now
I
have
a
bunch
of
implementations.
That
is
not
that
interesting.
I
will
go
down
here
because,
because
now
it's
starting
to
become
very
interesting
now
I
start
to
implement
the
rows
iterator.
A
This
is
how
iterators
work.
In
the
background,
the
system
which
will
just
call
next
over
and
over
again-
and
I
can
write
my
own
custom
business
logic
and
what
I
have
to
return
is
an
instance
that
will
get
that
I
will
get
back
from
this
iterator.
So
if
I
run
through
the
rows
iterator,
I
will
get
one
row.
Instance,
you
saw
it
before
one
after
each
other,
I'm
just
maintaining
a
counter
here
and
I'm
adding
one
to
the
counter.
Whenever
I
call
next,
if
I'm
at
the
end,
I
just
return
none.
A
If
you
are
new
to
rust,
none
is
rust's
null.
There
is
no
null
in
rust.
Rust
has
the
option
type
and
the
option
means
either.
I
have
something
for
you
or
I
have
none.
There
is
no
possibility
for
null
null
is
not
supported,
at
least
in
a
safe
rust
context,
and
we
are
not
going
to
talk
about
this
ugly,
unsafe
stuff,
which
we
are
no.
We
are
not
going
to
talk
about
that.
That's
a
completely
different
talk,
so
you
see
you
can
easily
implement
these
iterators
now.
What
does
this
give
me?
A
A
But
I
hope
you
understood
now
that
this
is
pretty
awesome
and
by
having
this
iterator
support,
I
get
really
really
strange
things.
I
can,
for
instance,
say
see
that
one
hey
give
me
the
nth
row
inside
my
board.
This
is
a
feature.
This
is
a
functionality
that
I
get
out
of
rust's
awesome,
iterator
logic
you
could
do
give
me
skip
some
elements
or
take
some
elements
or
filter
some
elements
or
map
some
elements,
and
in
this
case
I
just
use
the
nth
operator.
This
will
give
me
the
first
in
this
case
it
starts
by
zero.
A
So
the
second
row,
by
just
calling
my
next
method
two
times
and
give
me
the
second
row
so
by
implementing
this
iterator
trade,
I
open
the
whole
possibility
that
rust
brings,
which,
with
its
iterator
library,
okay-
and
this
is
a
completely
custom,
implemented
iterator,
nothing
but
nothing
standard,
iterator
stuff,
it's
completely
written
from
scratch.
With
my
rose
any
questions
so
far,
good.
A
Indexing
is
here:
let's
do
that
way.
Okay,
this
one
and
this
one.
These
are
two
additional
traits
that
I
want
to
talk
a
little
bit
about
the
index.
Trait
enables
us
to
access
our
data
structure
with
the
square
bracket
syntax.
It
allows
us
to
build
a
custom
indexer,
the
first
one
you
see
it
here
receives
a
reference
to
self
to
board
content,
because
this
is
the
data
type
that
I
want
to
be
able
to
index
and
because
it
just
says,
is
a
reference
to
self.
It's
a
read-only
reference.
A
If
you
take
a
look
at
the
index
mutable
down
here,
this
is
the
second
trait
I
would
like
to
mention.
You
just
write
reference
mutable
self,
and
that
means
I
can
write
into
self
into
my
own
data
structures,
and
this
is
a
deep
immutable.
That's
not
a
shallow
immutable,
but
if
I
have
a
immutable
reference,
I
cannot
manipulate
whatever
I
have
and
whatever
whatever
is
inside
of
my
my
own
again,
there
is,
there
is
rust
magic
with
which
you
can
allow
certain
things,
but
the
default
behavior
is
exactly
like
that.
A
It's
a
immutable
version
of
myself
and
I
cannot
manipulate
myself,
so
I
can
only
return
as
you
can
see
it
here.
I
can
return
an
element
from
myself,
but
if
I
take
a
look
at
the
index
mutable
here,
I
can
return
a
mutable
reference
to
an
element
of
myself.
Don't
get
me
wrong?
The
index
mutable
is
kind
of
interesting.
It
doesn't
do
the
writing.
A
A
That
is
what
index
mutable
is
all
about,
and
if
you
ask
yourself,
oh
rhino,
what
can
that
happen
with
with
parallel
oops?
Then
what
can
happen
with
parallel
programming?
Do
I
need
to
worry
about
some
some
some
some
race
conditions
and
things
like
that?
No
you
don't,
because
the
ownership
and
borrowing
system
of
rust
protects
you
from
shooting
yourself
into
the
knee
yeah.
The
ownership.
Borrowing
concept
is
again
a
very
good
topic
for
another
day
for
another
rustlings
meetup,
I'm
not
going
to
talk
about
it,
but
just
trust
me
and
believe
me.
A
If
you
build
safe,
rust,
not
unsafe
rust,
you
don't
need
to
worry
about
parallel
programming
and
about
data
races
and
things
like
that.
These
things
are
gone.
They
are
no
longer
present
without
the
garbage
collector
and
without
without
a
heavy
weight.
Runtime.
That's
the
awesome
thing
of
rust.
That's
the
magic
of
the
of
the
rust
compiler,
okay,
so
index
mutable
goods
yeah.
That
is
not
that
interesting.
I
had
some
indexer
and
that's
good,
and
last
but
not
least
before
we
go
into
the
last
few
minutes,
I
think
I
have.
A
I
know
10
minutes
left
or
so
and
then
I'm
done.
Let's
take
a
look
at
game.
Game
is
another
interesting
thing.
Maybe
it's
interesting,
I'm
not
sure.
I
hope
it
will
be
interesting
for
you.
What
I
did
here
is
I
had
another
idea
for
something
that
I
can
show
you
try
to
concentrate
for
the
last
few
minutes
here
you
see
I
invented
here.
You
see
it
a
trait
which
is
called
square
assessor.
A
It
allows
me
to
access
a
square
inside
of
a
tic-tac-toe
board
and
I
implement
two
different
methods
get
and
set.
I
think
it's
pretty
obvious
what
this
thing
does
right,
pretty
clear,
not
very
difficult
for
those
of
you
who
are
quick
and
who
take
a
close
look
at
my
code.
You
will
probably
already
have
recognized
something
up
here,
see
that
one
mock
all
auto
mock.
A
Does
that
ring
a
bell
to
you?
Of
course
we
can
use
traits
for
mock
objects
for
unit
testing,
and
I
will
show
you
that
in
a
second.
This
is
why
I
implemented
this
trait.
This
trait
is
mockable,
and
this
nice
little
crate
crate,
is
something
different
than
a
trait
okay.
For
those
who
are
new
to
rust,
the
crate
is
like
in
c-sharp
a
nougat
package
or
in
javascript
an
npm
package
or
in
java.
Oh,
my
god.
I
have
no
idea
from
java.
A
Let's
not
talk
about
java
nougat,
an
npm,
I'm
sure
about
that
a
crate
is
the
same
in
rust
and
mock
all
is
a
crate,
a
nice
crate
for
mocking,
and
here
I'm
telling
this
mock
all
crate
to
auto,
implement
a
mock
object
for
my
trait,
which
I
can
later
on
use
for
unit
testing.
Okay,
you
will
see
that
in
a
second,
but
the
second
important
thing
here
you
will
see
that
here
is
this
line.
I
now
implement
the
square
assessor,
not
on
top
of
my
board
content,
because
I
don't
need
a
board
content
for
that.
A
I
implement
it
on
top
of
any
data
type
that
supports
indexing
via
a
board
index.
This
was
the
save
index
that
we
built
together
and
that
returns
a
square
content.
So
if
you
want
to
build
a
data
structure
with
a
backing
vector
for
your
tic-tac-toe
game
feel
free
to
do
so.
As
long
as
you
allow
me
to
index
with
my
board
index
and
you
return
square
content,
I
am
fine.
My
game
controller
will
still
work
on
top
of
it.
So
again,
an
application
where
I
implement
the
trait
on
top
of
another
trait.
A
A
This
checks,
a
method
which
is
called
is
valid.
It
just
checks
whether
it
can
never
happen
that
we
have
two
x's
and
no
o's,
so
a
player
has
set
two
times
and
the
other
one
has
never
set
something
like
this
is
discovered
with
this
valid.
But
in
this
case
I
would
like
to
implement
to
test
this
logic
of
is
valid
without
having
a
real
board
content,
I'm
using
the
mock
version
of
my
square
assessor.
You
see
it
here.
A
This
struct
mock
square
assessor
was
not
created
by
me.
This
is
the
result
of
the
auto
mock
macro
that
you
have
seen
before
it
took
my
trait
my
ssr,
my
square
esseso
trait
and
created
the
structure
which
is
called
mock
square
assessor,
and
I
can
then
mock,
for
instance,
the
get
method
and
implement
some
lambda
function
here,
which
is
called
whenever
the
get
method
is
called,
and
in
this
case
I'm
just
returning
x,
then
o
then
x,
then
o.
So
this
will
be
a
valid
board,
so
I
can
assert
down
here.
A
That
is
valid,
really
returns,
true.
That
is
my
unit
test
and
if
we
take
a
look
at
the
second
test
here,
this
is
the
error
case.
In
this
case,
I
make
sure
that
this
board
is
not
considered
to
be
valid,
because
in
this
case,
I'm
returning
a
given
value,
x
or
o
two
times
and
all
other
elements
are
empty
and
that's
not
allowed
because
then
x
has
shot
two
times
or
o
has
shot
two
times
and
the
other
one
has
never
shot,
and
that
is
not
a
valid
tic-tac-toe
board.
A
A
Yes,
that's
also
possible,
so
auto
mock
allows
you
to
build
mock
structs
on
top
of
other
structs,
that's
possible,
and
in
some
cases
you
really
need
that,
for
instance,
I
do
some
work
with
a
rocket
framework
which
is
a
framework
for
building
web
apis
in
rust.
I
really
like
it:
I've
done
a
talk
at
the
roslins
meetup
about
it
and
whenever
I
have
to
do
unit
testing
with
mock
objects,
for
instance,
to
mock
away
my
database
or
backend
micro
services,
I
need
to
apply
auto
mock
on
top
of
structs
awesome
good.
A
A
A
Let
me
go
up
here
a
little
bit
and
then
it
should
be
readable.
Hopefully
it
will
be
yeah.
I
think
you
can
read
it
properly.
Is
that
okay?
I
think
it's
it's!
Okay,
please
jack!
That
here
I
have
implemented
two
structs
cat
and
dog,
and
I
have
implemented
the
trait
the
trait
animal
now
here
I
have
implemented
a
function
which
takes
an
animal
and
please
recognize
the
impul
keyword
here
I
essentially
say
the
print
sound
method
should
be
applicable
to
any
animal.
A
A
The
process
here
is
called
monomorphization,
so
it
duplicates
the
necessary
functionality
in
assembler
language
so
that
we
don't
have
to
pay
with
a
dynamically
dispatched
indirect
function.
Call
we
get
a
static,
dispatched
function.
Call
one
version
calls
the
dog.
One
version
calls
the
cat
and
of
course,
aesthetically
dispatched
call
is
really
really
fast.
A
So
by
calling
you
see
it
down
here
again
by
calling
print
sound
with
cat
and
dog,
you
see
it
on
the
left
lower
corner.
Here
I
do
monomorphization
and
duplicate
the
code,
so
I
get
better
performance,
but
I
get
a
little
bit
larger
code
base.
This
is
what's
happening
when
you
use
this
input
keyword.
You
cannot
use
input,
always
in
some
cases
it's
not
possible
and
then
you
need
the
second
keyword,
and
that
will
be
really
the
last
keyword
of
my
presentation
today
and
that
is
the
dun
key
word
dynamic
dispatch.
A
That's
essentially
exactly
the
same
code
that
you
have
seen
before.
The
only
difference
here
is
that
now
I'm
using
here
the
din
keyword,
what
I
get
from
the
dun
keyword
is
a
so-called
trait
object.
Technically
I
get
a
kind
of
v
table
a
table
with
virtual
function,
pointers
and
the
method
dispatching
is
done
through
the
b
table.
So
in
this
case
again
I
call
print
sound
for
two
animals,
cat
and
dog,
but
see
it
up
here.
A
It
calls
the
print
sound
method
in
assembler
language
and
the
print
sound
method
in
assembler
language
up
here
I
copied
it
out
here.
I
don't
have
two
print
sound
methods
here.
I
just
have
one
print
sound
method
here
and
this
print
sound
method
makes
an
indirect
function
call
through
the
v
table
and
of
course
that
is
slower,
but
I
don't
need
a
duplication
of
the
methods
here.
A
I
don't
have
monomorphites
monomorphizations,
there
are
a
lot
of
situations
where
you
need
this
trait
objects,
and
I
cannot
go
into
the
details
here,
because
this
is
not
a
training.
This
is
just
talk
and
I
limit
myself
to
one
hour,
so
I'm
just
can
give
you
the
facts,
and
you
have
to
read
up
the
details
when
you
have
to
use
trade
objects
and
when
you
can
use
the
impul
keyword,
the
compiler
will
tell
it
to
you.
A
So
if
you
try
to
use
impul
where
it
doesn't
work,
it
will
tell
you
used
in
and
if
you
use
dun
and
you
use
it
in
the
wrong
way,
for
instance,
if
you
need
to
create
it
a
box
and
put
the
den
in
it
trust
the
rust
compiler.
The
rust
compiler
will
lead
your
way.
You
will
love
it.
Hopefully,
maybe
you
will
hate
it
sometimes,
but
the
rust
compiler
is
always
right.
It
will
guide
you
away.
That's
the
beauty
of
the
rust
compiler,
okay.
A
A
A
You
get
zero
cost
abstractions
through
monomorphization
or
if
you
don't
need
monomorphization
the
trades,
you
don't
have
to
pay
for
the
trades
at
run
time.
Yes,
dispatching
dynamic
dispatching
is
possible
with
the
keyboard,
but
it's
not
a
must.
It
depends
on
the
situation
and
on
your
code.
I
hope
you
found
this
one
our
interesting.
I
hope
you
enjoyed
today's
rust
lintz
meetup.
We
will
be
pretty
at
the.
We
are
now
pretty
at
the
end
of
our
rust
meetup,
it's
getting
dark
now.