►
From YouTube: Ownership
Description
A
Hello
and
welcome
to
this
rust
tutorial
on
ownership.
My
name
is
Nicholas
misaki's,
let's
get
started
alright.
So
let's
talk
about
ownership.
I,
think
the
concept
of
ownership
will
be
familiar
to
you
from
your
daily
life
right.
So
imagine,
I
have
a
book
like
this
excellent
book
principles
with
compiler
design,
I
recommended
read
by
the
way
and
imagine
I
have
it
on
my
bookshelf
and
I'm
its
owner.
What
does
that
mean?
A
It
means
a
lot
of
things,
but
among
other
things,
it
means
that
if
someone
should
want
to
use
that
copy
of
the
book,
they
have
to
come
to
me
and
ask
for
it
right.
They
so
basically
I'm
kind
of
a
gatekeeper
for
the
book,
but
another
interesting
thing
about
owning
something
is
that
I
can
give
it
away.
A
So
I
could
say
to
my
friend:
hey
it's
your
birthday,
perhaps
you'd
like
to
read
principles
of
compiler
design
recommended
read
by
the
way,
and
they
might
say
thank
you
and
now
they're
the
owner
of
the
book,
and
that
means
a
couple
things,
but
one
of
them
is.
If
anyone
wants
to
read
that
copy
of
the
book,
they
have
to
go
through
the
new
owner
right,
and
that
includes
me
I'm,
not
special
anymore.
A
The
new
owner
is
special
and
another
thing
you
can
do
besides
giving
things
away
as
you
can
get
rid
of
them,
so
they
could
throw
it
away
right
and
or
recycle
it
now.
Data
structures
in
rust
work
pretty
much
the
same
way
as
books
in
the
real
world,
all
right.
So
when
I
here's
the
code,
we
had
from
our
from
our
from
the
Play
server
example-
and
you
can
see
in
this
first
line
when
I
create
a
string
what's
happening.
A
Is
that
I'm
allocating
some
resources,
like
I,
told
you
and
ownership
of
those
resources
is
going
to
be
transferred
to
the
Creator
the
main
function,
and
the
main
thing
about
rust
is
that
for
any
given
resource
that
you've
allocated
there's
always
an
owner
and
that
owner
the
resource
can
be
moved
from
owner
to
owner
and
eventually
one
of
those
owners
will
choose
to
drop
it
on
the
floor.
Perhaps
the
owner
will
be
a
function
that
returns
as
we'll
see
or
something
else,
and
that's
when
the
resource
gets
freed.
A
So
we
say
that
rust
sort
of
has
manual
memory
management,
but
it's
not
like
malloc
and
free.
If
we've
ever
used
C,
it's
not
something
you
do
explicitly.
Memory
management
just
falls
out
of
using
values
and
not
using
them.
So
let's
see
how
it
plays
out.
So
I've
allocated
a
string
and
I'm
the
owner
and
then
I
call
this
helper
function,
and
the
helpers
argument
is
of
type
string
right
when
rust.
A
When
you
have
an
argument
of
type
string
or
some
other
type
like
that
kind
of
the
default
is
you're
declaring
that
you
would
like
to
take
ownership
of
a
string,
and
so
helper
is
saying
when
you
call
me,
you
have
to
give
me
a
string
that
I
have
unique
access
to
and
that
I
control.
So,
okay,
we
have
a
string
that
we
just
allocated,
so
we
can
give
it
to
them.
So
we
call
them,
and
now
they
have
the
string
and
we
don't
have
it
anymore
and
they
can
execute
they
can
do
whatever
they
want.
A
With
this
string
like
print
it
out
to
the
screen,
and
then
they
leave
and
now
they
haven't,
given
the
string
away
again,
so
the
way
rust
works
is
when
a
function
returns.
All
of
the
data
that
it
owns
in
its
local
variables
and
its
parameters
and
so
forth,
gets
freed,
or
sometimes
we
say
it
gets
a
drop,
and
what
that
means
is
that
the
resources
will
get
returned
to
the
system.
More
concretely,
something
called
a
destructor
will
run,
which
is
basically
custom
code
that
you
can
have
to
do
anything
in
the
case
of
a
string.
A
It
frees
the
memory
and
we
come
back
right
and
watch
for
that
fire
animation
by
the
way.
That's
my
freeing
animation
so
then,
now
here,
if
I
try
to
call
helper
again,
this
is
where
we
got
the
error,
and
now
we
can
kind
of
see
why
right
we're
not
being
a
very
good,
very
good
giver
here,
we've
already
given
the
book
away,
we
can't
give
it
away
twice:
that's
not
how
it
works,
so
the
compiler
gets
mad.
Now
this
model,
it
might
seem
intuitive
I,
think
it's
quite
intuitive
when
it's
explained
this
way.
A
But
it's
really
radically
different
from
the
way
that
garbage
collected
languages
work
right
more
so
than
it
might
seem,
and
it's
actually
the
key
to
what
makes
rust
able
to
do
what
it
does.
So,
let's
see,
here's
here's
a
Java
program,
they've
allocated
a
vector
and
they're
going
to
come
along
and
you're,
going
to
call
a
helper
function,
and
so
far
the
code
looks
similar.
The
only
difference
is
I
used,
a
vector
type
I,
probably
should
have
used
string
buffer,
but
that
didn't
fit
on
the
slide.
A
So
I
chose
vector
anyway,
they've
allocated
a
resource,
and
the
kind
of
interesting
thing
is
until
this
point
once
we
when
we
allocate
something
in
Java,
we
know
we're
the
only
ones
with
access
to
it,
because
it's
freshly
constructed
right,
but
when
we
call
a
function,
something
different
happens
when
the
function
declares
that
it
takes
an
argument
of
type
vector,
what
they
don't
mean,
give
me
ownership
of
the
vector
they
mean,
give
me
access
to
a
vector
or
give
me
a
reference.
And
so
what
happens?
A
Is
that
the
first
function
main
and
the
new
function
helper
wind
up
kind
of
entangled
together
by
this
shared
state?
They
both
have
access
now
to
the
same
vector.
So
any
changes
that
helper
might
make
to
this
vector
like
pushing
new
elements
or
changing
elements.
That's
going
to
be
immediately
visible
to
the
to
the
main
function
when
it
returns
right
and
similarly,
you
saw
helper
returned,
but
we
didn't
free
any
memory.
Then
we
can't
free
the
memory
when
helper
returns,
because
we
don't
know
who
else
might
be
using
the
vector
right.
A
In
this
case
the
main
function
is
going
to
use
the
vector
and
it's
going
to
call
helper
again
and
and
then
it's
going
to
keep
executing
and
so
we're
already
starting
to
see
some
of
the
things
that
I
was
talking
about
about
problems
that
arise
from
this
model.
So
I
would
call
this
a
very
sharing
heavy
model.
Everything
is
shared
implicitly
right
and
the
problem
with
that
is
now.
Everything
is
entangled
implicitly.
So
if
helper
chooses
to
make
changes
to
the
vector,
those
changes
affect
main
and
maybe
main
didn't
expect
its
vector
to
change.
A
So
that
can
lead
to
bugs,
but
it
can
also
lead
to
somewhat
deeper
problems.
So
here
when
main
returns
now,
if
both
of
our
functions
have
returned-
and
you
might
think
we
could
free
the
vector
then,
but
we
actually
can't
free
it-
or
at
least
we
don't
know
if
we
can
not
just
from
the
source
code
right,
we
have
to
look
a
little
more
deeply.
So
I
didn't
show
you,
for
example,
anything
about
what
helper
does
imagine.
The
helper
actually
starts
a
thread.
In
that
case
the
vector
might
still
being
used
by
this
thread.
A
That's
running
along,
and
this
sum
means
we
can't
free
it
just
because
main
return,
because
the
thread
might
not
have
finished
running
I
serve
an
asynchronous
execution.
What's
worse,
that
thread
might
be
making
changes
to
the
vector
two,
in
which
case
those
changes
that
the
thread
is
making
would
appear
at
kind
of
random
times
with
respect
to
the
code
in
main-
and
this
is
exactly
why
databases
are
such
a
big
problem
in
a
garbage
collection
based
of
sharing
heavy
language,
so,
okay,
this
thread
will
run.
A
A
Okay,
so
we
see
the
Java
and
rust
have
very
different
models
and
we're
really
enthusiastic
about
ownership
right.
You
are
right,
you
feel
it
I'm
enthusiastic,
so
we
think
ownership
is
cool,
but
we
still
have
this
problem
on.
We
would
like
to
call
our
helper
function
twice
and
I
haven't
shown
you
how
to
do
it.
So
how
can
you
do
it?
Well?
A
B
A
The
right
way,
but
it's
the
easier
way
that
deals
well.
It
falls
fewer
concepts,
so
we're
going
to
start
here.
The
idea
is
one
simple
way:
to
avoid
giving
away
your
copy
of
a
resource
is
to
copy
that
resource
so
that
there
are
two
copies.
Then
you
can
give
away
the
second
one
and
keep
one
for
yourself
make
sense
right.
So
here,
if
I
have
a
string,
what
can
I
do?
I
can
call
the
helper
function
and
we
know
that
helper
wants
to
own
a
string,
but
we
don't
want
to
give
it
our
string.
A
So
I
can
call
this
method
called
clone.
Clone
is
a
method
offered
on
many
types.
It
does
a
deep
clone
of
an
object
and
basically
makes
a
fresh
second
copy.
So
when
I
do
this,
I
will
call
clone
it's
going
to
copy
this
string
into
a
new
string,
allocate
some
more
memory
and
pass
ownership
of
the
clone
over
to
the
helper
and
now
helper.
You
know
its
constraints
are
satisfied.
All
it
wanted
was
a
name
for
its
very
own,
and
it
has
one.
A
It
doesn't
happen
to
be
the
same
one
that
we
have,
and
now
we
can
run
and
use
that
and
when
it's
finished,
because
it's
its
name,
you
can
do
what
it
likes.
It'll
free
the
memory
and
return,
but
we
can
now
call
helper
twice
because
we
have
our
own
clone
of
the
string
or
we
have
the
original
I
should
say
the
original
string
that
we
had
before
and
this
time
we
don't
clone
it.
So
we
give
ownership,
we
don't
need
it
anymore
and
now
they
all
free
it
when
they
return
and
then
we're
done.
A
Ok,
so
that's
how
clone
works
and
clone
is
pretty
convenient
every
once
in
a
while.
You
do
really
want
to
clone
some
data,
but
one
thing
about
clone
is,
if
you
had
to
call
clone
every
time
for
every
variable
to
make
sure
that
you
don't
use
that
variable
twice.
That
would
be
kind
of
annoying.
So
we
have
this
notion
of
types
that
are
copy
types.
The
idea
of
a
copy
type
is
basically
is
an
automatic
clone.
Every
time
you
use
the
variable
instead
of
giving
away
ownership.
A
And
its
value,
if
the
variables
type
is
one
of
these
copy
types,
we
will
automatically
give
a
copy,
and
these
copy
types
are
always
really
simple
types.
Things
like
integers,
so
here
I
have
a
count.
It's
the
number
22
and
when
I
call
helper,
we
see
that
helper
takes
an
argument
of
type
I
32
by
32
is
a
32-bit
integer.
So
in
rust
your
integer
types
always
specify
how
many
bits
they
have
and
it's
a
signed.
Integer,
that's
the
I.
A
So
if
you
wanted
an
unsigned
integer
that
would
be
you
32
and
integers
are
copy
types.
So
that
means
that
when
I
call
helper,
I
am
going
to
give
ownership
of
an
integer
to
the
helper
function,
but
I'm
just
going
to
implicitly
copy
mine
right
and
the
reason
we
make
this
distinction
is
really
based
on
your
machine.
Essentially
copying
integers
is
free
for
your
computer,
there's
no
resource
that
you
have
to
allocate
for
that
purpose
and
there's
no
special
code.
You
have
to
run
so
examples
of
copy
types
are
basically
integers.
A
Floating-Point
types,
simple
things
like
that
right,
the
important
point
is
helper
has
its
integer.
It
can
use
it
and
when
it's
finished
it
just
kind
of
goes
away.
I
didn't
draw
the
fire
animation
here,
because
there's
really
no
action
that
gets
taken
when
you
finish
with
a
copy
type
you're
just
and
we
come
back,
and
now
we
could
call
helper
again
and
it's
a
copy
type.
So
we're
not
going
to.
We
still
have
ownership.
We
still
have
access
to
the
count,
of
course,
even
though
we
called
it
once
so.
A
That
gives
rise
to
a
kind
of
three-way
and
three
categories.
Let's
say
of
values
in
rust,
and
a
lot
of
things
in
rust,
come
in
threes
or,
and
values
are
one
of
them,
so
basically
the
first
category,
any
type
that
you
yourself
make
like.
If
you
declare
a
struct
we'll
get
to
that
in
a
later
tutorial,
it
falls
into
this
category
by
default.
These
are
non
copyable
types
things
that
there,
when
you
make
an
instance
of
it,
there's
only
one
right
and
it
always
moves
from
place
to
place.
It
can
never
be
cloned.
A
So
an
example
might
be
money
in
the
real
world.
You
usually
don't
want
to
allow
people
to
copy
money.
So
you
might
have
a
type
that
represents
money,
and
you
might
say
this
type
is
not
cloneable,
it
can't
be
copied,
it
has
to
be
moved.
Another
example
or
the
next
category
is
cloneable
things.
This
is
probably
most
types.
Actually
things
like
strings
that
we've
seen
vectors
or
cloneable,
at
least
if
their
elements
are
cloneable
and
so
on,
and
basically
a
cloneable
type
is
something
that
moves
from
place
to
place.
A
But
you
can
make
a
separate
copy
make
a
clone
if
you
need
to-
and
in
that
case
you
have
a
clone
method
and
the
clone
method
runs.
That's
the
key
point.
In
order
to
clone
one
of
these
values,
you
have
to
run
some
custom
code,
and
that
makes
this
value
into
a
kind
of
resource
which
will
be
that,
like
custom
code
might
do
memory,
allocation
or
other
things.
A
And
finally,
we
have
copy
types,
and
these
are
the
really
simple
types
like
integers
and
floating
points,
and
they
get
implicitly
copied
everywhere
and
the
key
point
is
you:
don't
never
need
to
run
custom
code
to
copy
a
copy
type.
You
can
just
copy
the
bytes
in
memory
from
one
place
to
another
right,
okay,
so
that's
enough
about
ownership.
For
now,
let's
do
an
exercise.
If
you
see
below
remember
that
we
saw
the
hello
world
exercise
this
time,
we're
going
to
do
the
ownership
exercise.
A
So
what
I'm
going
to
do
is
I'm
just
going
to
walk
you
through
the
code.
First,
then,
you
can
go
run
off
and
actually
do
the
problems
that
are
posed
there.
Okay,
a
lot
of
code
you're
a
lot
more
than
we
saw
before
and
there's
a
number
of
little
goals
right.
So
here's
one
goal,
number
one:
there's
goal
number
two
and
then
there's
an
extra-credit
idea,
so
I'm
going
to
walk
you
through
the
code
and
then
just
for
fun,
we'll
do
goal
number
one
together
and
I'll.
A
A
Two
words
actually
has
a
return
value,
which
is
something
we
didn't
see
before,
and
what
it's
returning
is
a
pair
of
strings.
So
this
is
kind
of
like
having
multiple
return,
multiple
return
values,
but
yet
you
should
have
to
pair
them
up,
so
you
can
think
of
it
as
I'm
returning
one
thing,
which
is
a
pair
or
I'm
returning,
two
things
as
you
choose.
Basically
we're
going
to
give
back
ownership
of
two
different
strings:
that's
the
important
part
and
inside
the
body
you
see
that
we,
the
body,
consists
of
just
a
single
expression.
A
Well
in
rust,
you
can
return
things
out
of
a
function.
This
way,
the
last
expression
in
a
function.
If
you
leave
off
the
semicolon
note
that
there
is
no
semicolon,
it
will
be
returned
from
the
function
without
having
to
use
the
return
keyword.
This
is
actually
the
preferred
way
to
return
things,
so
in
this
case
we're
making
up
a
pair
with
these
parentheses
of
two
strings.
The
first
one
will
be
fellow
and
the
second
one
will
be
rest
stations.
A
A
A
An
ownership
of
the
pair
comes
is
returned
from
two
words
over
to
here,
where
the
pair
is
broken
apart
and
assigned
into
two
variables,
so
adjectives
becomes
the
owner
of
this
fellow
here
and
name
becomes
the
owner
of
our
stations
right
so
now,
I
have
two
variables
adjectives
and
name
and
I
can
use
format
to
glue
them
together.
So
this
is
the
format
string
with
two
arguments,
totally
legal
and
so
now
I'm,
basically
going
to
glue
them
together
with
a
space
in
between
to
get
the
combined
string
name,
which
I'll
pass
to
print
out.
A
I
want
to
show
you
a
couple
other
minor
things,
while
I'm
here
here
I
broke
apart
this
pair
into
two
variables,
but
I
don't
have
to
do
that.
I
could
have
stored
it
into
one
variable
and
then
access
the
two
parts
individually
by
calling
0
&
1.
If
you
prefer
I
like
giving
them
names
and
then
anyway,
so
let's
go,
look
at
print
out,
come
down
to
print
out.
Print
out
is
a
function
which
takes
ownership
with
a
name
and
it
calls
this
remove
vowels
function
and
let's
skip
up.
A
It
says
you
know,
given
a
name
or
given
a
string,
returns
a
new
string
that
is
the
same
as
the
input
but
does
not
contain
any
vowels.
You
see
that
I
used
three
slashes,
that's
that's
a
kind
of
rust
doc
comment
that
will
be
processed
and
produced
if
we
generate
API
documentation
and
it's
often
nice.
These
are
actually
markdown
formatted.
It's
often
nice.
To
put
a
little
example.
You
know
something
like
on.
A
Let's
say
hll
right,
so
something
like
this
I
think
will
work.
The
basic
idea
is:
I've
got
nine
if
I
call
I'll
come
back
to
assert
for
a
second,
if
I
call
remove
vowels
on
hello,
I
will
get
back.
H,
ll
and
assert
is
just
a
macro
that
checks
that
the
tooth
that
this
expression
is
true
and
returns
an
error.
Otherwise
right,
you
might
actually
want
to
use
a
certain
EQ,
which
is
a
kind
of
somewhat
nicer
macro
that
takes
two
arguments
and
checks
that
they're
equal.
A
It's
just
nicer,
because
the
error
message
tells
you
what
the
values
were
in
the
case
where
it's
false.
Okay,
so
let's
go
we
seen
functions.
We
know
we
can
document
them
I'll
leave
it
in.
Why
not
so
I'll
leave
us?
Let's
not
look
at
remove
valves
for
a
second,
let's
just
say
what
happens.
We
get
this
string
back
that
has
no
vowels
in
it
and
then
I'm
going
to
print
it
out.
Okay,
that's
all
we
need
to
know
for
now.
So
let's
try
to
run
it.
A
We
get.
An
error
here
cannot
borrow
immutable.
Local
variable
is
mutable
on
line
31,
so
this
is
inside,
remove
vowels.
So
let's
look
at
this
function
and
actually
see
you
know:
what's
it
doing
so,
it's
given
a
string
as
its
input
which
it
takes
ownership
of,
and
then
it's
using
a
for
loop
and
it's
calling
name
cars.
So
we
saw
this
in
the
introduction
name:
dot.
Cars
returns
an
iterator
over
characters.
A
First
link,
that's
going
to
yield
up
one
character
at
a
time
and
then
a
for
loop
will
drive
that
iterator
and
for
each
character
that
we
get
out
we'll
call
it
C.
Okay,
so
now
we're
basically
taking
each
character
in
the
string.
These
are
unicode
characters
by
the
way
and
then
we'll
match
on
the
character.
Match
is
kind
of
like
switch
and
see
but
way
more
powerful.
But
here
we're
only
going
to
use
the
basic
functionality
and
you
see
we
have
a
series
of
arms
arms
are
basically
tests
and
then
code
that
runs.
A
A
That
means
we
can
put
things
new,
we
can
mutate,
it
update
it
and
we
can
put
things
in
place
and
if
it
gets
eventually,
we
may
have
to
allocate
more
memory
if
it's
too
small,
that's
okay,
so
that's
kind
of
part
of
the
API,
so
I'll
put
that
will
take
this
character
and
push
it
on
and
now
the
reason
that
we're
getting
a
compilation
error.
If
you
recall
it
was
exactly
at
this
point.
I'll
put
that
push
see.
A
A
That's
generally
the
case,
unless
you
say
otherwise
right,
so
it's
not
that
we're
against
mutation,
but
we
like
mutation
to
be
advertised,
so
here,
for
example,
I
declared
the
variable
as
immutable
and
I
signed
it
with
a
string
new,
which
is
just
an
empty
string
buffer,
and
so,
if
I
write
me
now,
I'm
saying
this
is
a
string
buffer.
That
I
intend
to
make
changes
to
right
and
in
fact
the
help
tells
us
exactly
what
to
do.
So.
A
If
I
run
this
code
now
I'm
actually
going
to
see,
removing
vowels
yields
fell
over
stations
as
we
expected
without
the
vowels
now
one
other
thing:
that's
kind
of
cool,
so
one
nice
side
effect
of
writing.
Let
mute
is
that
if
I
comment
out
output
pushed
see,
I've
now
declared
that
I
intend
to
mutate
the
variable
output
but
I've
never
actually
mutated
it
right.
So
maybe
I
forgot
this
line
or
something.
Well.
You
see
that
Ruskin
warned
us
about
that.
Says:
hey
you
wrote
mute,
but
you
didn't
actually
need
to
something
seems
fishy
right.
A
So
we
do
want
that.
Okay,
so
that's
goal
number
one.
We
did
it
all
right
now.
Let's
check
out
goal
number
two:
what
happens
when
you
uncomment
the
print
line
below
all
right?
Can
you
change
the
code
so
that
the
code
below
compiles
successfully
now
here
is
where
I
think
you
should
go
off
and
do
this
exercise
and
if
you
want,
take
a
shot
of
the
extra
credit
after
you've,
given
it
a
good
try,
say
about
10
minutes
or
so
hour,
less
or
more
as
you
choose,
come
back
and
I'll
work
through
the
solution.
A
A
Back
already,
that
was
quick.
All
right,
let's
go
over
the
solution,
all
right,
so
I
do
hope
that
this
time
you
went
off
to
the
exercise
site
and
actually
tried
it
for
yourself,
because
I
think
it's
really
useful.
But
now
what
I'd
like
to
do
is
go
over
the
solutions
together.
So
goal
number
two:
what
happens
if
we
uncommon
print
line
below?
Let's
give
it
a
try.
A
A
Okay,
so
this
makes
the
code
compile
and
that's
good.
Now
the
extra
credit
is.
Can
we
do
this?
Can
we
write
the
same
code
without
copying
or
cloning
any
data,
and
now
we're
going
to
learn
in
the
next
tutorial
on
sharing
how
how
I
actually
do
this?
But
it's
kind
of
interesting
to
think
about.
Excuse
me:
can
we
do
it
without
actually
using
references
just
using
ownership?
A
And
the
answer
is
yes,
you
can
it's
kind
of
a
cute
trick,
so
the
idea
is,
we
gave
ownership
of
name
to
the
remove
vowels
function
and
it's
giving
us
back
a
string.
But
if
you
look
all
it
does
with
name
here
is
just
iterate
through
it.
It
doesn't
really
mutate
it
or
change
it
in
any
way.
So
what
we
could
do
is
say
how
about
we
give
name
a
string
and
it's
going
to
give
us
back
two
strings.
A
First,
it's
going
to
give
us
the
output
that
it
always
gave
us,
and
it's
also
going
to
give
us
back
the
input
that
we
gave
to
it
and
now
down
here
and
remove
when
we
call
or
move
valves.
We
have
to
take
this
two
strings
and
match
them
up,
and
so
let
me
use
a
different
variable
name
to
start
now.
If
I
write
this
what's
happening,
I'm
taking
this
variable
I'm,
giving
it
to
remove
vowels.
A
A
So
in
this
case,
when
I
say
name
here,
I'm
referring
to
this
variable
name,
but
when
I
write
name
here,
I'm
referring
to
the
original
name,
the
one
that
came
in
as
a
parameter-
and
this
one
was
kind
of
has
effect,
takes
effect
in
this
portion
of
the
code
or
it
where
it
shadows
the
original
binding
all
right.
So.
A
I'm
going
to
get
the
same
result
and
the
reason
that
I
would
use
shadowing
here
is
because
these
variables
I'm
sort
of
declaring
to
the
reader.
These
are
the
same
name
here.
That's
why
I
use
the
same
variable
name
now.
I
just
want
to
say.
Thank
you
very
much
for
listening
to
this
tutorial
and
one
before
you
go.
I
want
to
have
one
reminder:
I'm,
always
looking
for
feedback
ways
to
improve.