►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
Talking
about
our
language,
giving
you
some
foundation
for
the
rest
of
the
session
today
so,
and
also
just
the
you
know,
this
is
our
unofficial,
mascot
Paris,
you
know
we
we
love
them.
There
is
someone
who
has
a
t-shirt
with
Paris
on
it
as
yes,
you're
a
great
person
I
need
to
get
one
of
those
shirts.
They
were
sold
out
when
I
tried
to
get
them
so
anyway
to
begin
so
this
also,
you
know
I
want
to
say
that,
like
you
know,
this
is
our
third
event
of
this
style
in
the
world.
A
We're
calling
these
Ross
bridge
events
we've
had
one
in
in
the
in
Berlin
one
in
a
Pittsburgh
and
now
Mexico.
So
this
is
all
is
very
exciting.
But
to
keep
this
in
mind,
this
is
also
a
bit
experimental.
So
you
know
there
are
the
curriculum
that
we've
built
today
that
it
might
be
a
little
disorganized.
You
might
run
into
the
problem,
so
please
tell
us
if
you
run
into
problems
so
that
we
can
fix
this
in
the
future.
A
Also,
there
will
be
a
survey
at
the
end
to
ask
you
all
where
what
we
did
well,
what
we
did
poorly
anything
that
we
could
do
better
the
next
time
we
host
one
of
these
events
will
appreciate
any
any
input,
good
or
bad,
so
as
I'm
not
sure
what
Sebastian
said.
Oh
and
also
thank
you
so
much
Sebastian
for
inviting
me
down
here.
A
This
is
this-
is
really
fun,
so
I'm
part
of
the
thrust
court
team-
you
can
see
me
down
at
the
very
bottom-
is
my
little
drain
cover
picture
I'm
also
doing
by
Brian
Anderson
from
the
core
team
who's
over
there
with
a
wonderful
beard.
So
we've
been
working
on
rust
for
a
number
of
years.
We
also
are
a
part
of
our
core.
A
The
community
team
that
is
also
trying
to
help
encourage
events
like
this
around
the
world
run
our
survey,
which
you
may
or
may
not
have
seen
and
do
other
things
trying
to
like
get
our
community
engaged
and
trying
to
build
out
things
like
this.
Try
to
do
fun,
games
stuff,
like
that,
we've
also
been
around
for
a
really
long
time.
Someone
actually
asked
me
how
long
I've
been
doing
rust,
so
this
is
my
first
commit
that
I've
ever
done
to
rust,
which
is
was
on
May
17
2011,
which
I
think
is
only
about.
A
Like
you
know,
five
or
six
months
after
rust
was
was
publicly
announced,
so
I'm,
really
old,
so
and
Brian
actually
I
think
was
around
even
before
that.
But
you
know
it
was.
It
was
nice
back.
Then
you
could
actually
follow
what
was
happening
in
the
language,
and
you
know
the
the
moment
that
I
realized
that
rust
was
actually
going
to
be.
A
real
thing
was
when
I
couldn't
keep
up
with
what
the
community
was
doing
anymore.
A
As
a
really
nice
experience,
when
I
couldn't
read,
the
commits
I
couldn't
actually
see
what
was
going
on
and
but
like
it's
people
like
all
of
you
that
have
been
you
know,
kept
me
around,
like
it's
just
been
so
exciting,
seeing
all
the
encouragement
inside
the
the
environment
so
anyway
to
get
into
our
session
today.
So
this
is
a
bit
of
an
overview
I'm
going
to
talk
about.
You
know
a
high
level
of
why
rust.
Why
we
we
built
this
then
go
into
more
of
the
details
about
how
to
get
rust
setup.
A
A
You
know
safe
using
all
sorts
of
like
analysis
tools
in
order
to
improve
how
how
the
code
was
working,
sending
a
policies
in
order
to
do
safe
coding
at
just
you
know.
It
turned
out
that
it
was
just
are
too
easy
to
make
one
mistake
and
compromise.
You
know
everyone's
security,
so
here's
a
very
simple.
You
know
simple
example
of
like
one
of
the
common
problems,
if
you,
if
you've
ever
done
a
C
or
C++
programming,
that
you
know
this
is
called
use
after
free.
A
So
here
we
we,
you
know-
and
this
is
like
an
example
of
like
you
know,
one
of
the
bugs
that
the
Mozilla
was
running-
that
as
they
were
doing
web
audio,
that
they
would
download
some
sound
file
from
the
internet
and
they
would
play
and
the
browser
all
pretty
simple.
But
you
know
they
evaluated
all
the
security
bugs
that
happen
and
one
of
the
the
most
popular
security
bugs
was
things
like
this,
where
they
would,
they
would
allocate
some
memory
for
the
audio
file.
Then
you
know
some
code
paths.
A
That
Java
is,
is
really
fast
like
it's
a
good
strong
language,
but
because
it
has
a
garbage
collector
that
it's
still,
you
know
as
a
interactive
user
experience
that
the
the
interface
might
pause.
You
know
every
you
know
couple
seconds
for
50s
or
so
milliseconds,
so
not
horrible,
but
it
would
be.
It
wouldn't
be
a
good
user
experience
and
for
the.
A
Furthermore,
it
also
you
know
once
to
like,
if
you've
ever
done,
any
multi-threaded
programming
that
there's
a
lot
of
sharp
edges
to
a
multi-threaded
programming
like
there's,
there's
various
ways
that
you
can
make
simple
mistakes
and
run
into
these
non-deterministic
programming,
languages
or
sorry
non-deterministic,
bugs
where
things
might
work
98%
of
the
time
but
fail.
You
know
this
1%
of
time
and
cause
all
sorts
of
problems
which
results
in
people
not
actually
doing
a
lot
of
multi-threading
coding,
because
it's
hard
and
then
we
are
now
wasting
resources
on
these.
A
These
you
know
all
of
our
laptops
or
own.
That
could
give
a
more
pleasant
experience.
So
so
rust
is,
you
know
what
is
called
a
systems
programming
language,
so
does
anyone
here,
like
you
know,
have
a
good
definition
of
what
systems
programming
is
anyone?
Okay,
okay,
so
so
you
know
one
of
the
common
definitions
of
like
systems.
A
A
Languages
either
have
a
very
small,
runtime
or
no
runtime
at
all,
like
so,
if
you're,
if
you're
programming,
an
embedded
device
where
you
don't
even
have
an
operating
system
that
you
need
to,
you
know
systems
languages,
support
that,
whereas
other
non
systems,
languages
like
swift
or
go
or
Python,
they
have
a
lot
of
supporting
infrastructure.
In
order
to
to
support,
you
know
how
they
are
programming.
A
So
one
of
the
things,
though,
about
like
systems
programming,
is
that
there's
I
think
some
some
misconceptions
about.
You
know
what
it
means
to
do
systems
programming
that
it
doesn't
mean
that,
like
you
have
to
be,
you
know
an
expert
programmer
that
you
know
just
because
you
want
to
write
in
a
fast
language
doesn't
mean
that
you
have
to
be
familiar
with
all
these
really
archaic
tools
like
make
files
and
auto
calls.
A
You
know
doing
weird
like
flags
on
you
know,
GCC
or
clang,
or
all
these
other
things
or
I
have
to
like
really
conform
hard
to
the
environment.
That
you're
running
in
it
also
doesn't
mean
that
you
only
have
to
be
like
writing.
You
know
Windows
applications
or
databases.
There's
there's
lots
of
ways
that
you
can
do
systems
programming,
but
you
don't
necessarily
need
to
you
know,
have
a
PhD
and
in
databases
you
also
in
in
a
lot
of
like
the
system
languages.
A
You
typically
have
to
care
very
deeply
about
memory,
so
you
might
have
to
deal
with
like
pointers
and
male'
King
and
freeing
memory
and
doing
a
lot
of
like
manual
management
that
you
know
it's
not
necessarily
it's
not
building
a
website
and
just
like
being
able
to
you
know,
make
it
easier
for
people
to
buy
whatever
stuff
you're
using
like
you
know,
there's
it
doesn't
have
to
be
defined
by
that,
and
so
that's
that's
one
of
the
things.
The
rust
is
working
really
hard
on
trying
to
make
that
usable
and
is
everyone
understanding
me?
A
You
know
nice
simple
ways
of
walking
through
data
structures,
but
we
also
don't
like,
if
possible,
we
don't
want
you
to
have
to
pay
for
it
like
we
want
it
to
compile
down
into
essentially
the
same
code.
You
would
write
by
hand,
so
we
also
want
it
to
be
memory
safe,
so
that
you
don't
necessarily
like,
so
that
all
these
bugs
that
that
Mozilla
was
running
into
that,
it's
just
impossible
for
you
to
write
it
in
in
rust
that
that
will
just
fundamentally
make
everyone
saver,
but
without
without
having
to
to
you
know
pay.
A
You
know
any
real
cost
work.
We
also
want
to
have
like
really
good
air
handling
and
really
good
a
really
good
user
experience
like
so
that
you
don't
have
error
messages
that
are
just
rolls
of
text
that
you
can
occasionally
get
with
C++.
We
want
it.
We
want
to
make
it
approachable
and
easy
for
people
who
are
are,
you
know,
ultimately,
even
new
to
programming
easy
to
use
rust,
so
I
now
I'm
going
to
start
walking
through
just
getting
rust
set
up?
A
A
A
A
You
know
forcing
people
to
just
stay
on
like
stay
with
bugs
or
you
not
take
advantage
of
like
new
features
that
we
develop
that
are
stable,
so
Russ,
Russ
stuff
is
the
way
that
you
know
we
can
easily
roll
these
things
out
to
the
community
without
without
having
to
like
jump
through
a
lot
of
Hoops.
So
it's
pretty
simple
to
install,
so
you
can
just
you
know
you
can
just
run
this
command
in
order
to
get
it
set
up
and
it
will
install
rust.
So
so
does
everyone,
so
everyone
has
rust
installed.
A
If
not,
you
know
we
can
help
you
up.
This
is
also
like
this
is
an
interactive
section.
So
if
you
want
to
run
these
commands-
and
if
you
run
into
problems
just
raise
your
hand
and
we'll
will
help
you
out
so
okay,
so
we
also
have
a
number
of
other
installers
that
are,
you
know,
set
up
for
like
if
you're
on
Windows
it
just
has
a
standard,
Windows
installer
as
well,
likewise
with
Macs
and
Linux,
which
you
can
see
on
this
gyro
at
the
bottom
of
the
page.
A
So
the
next
thing
that
we
have
is
cargo,
which
is
our
package
manager,
so
for
those
of
you
that
come
out
of
like
the
Python
ecosystem,
so
cargo
is
very
similar,
it's
a
pip
or,
if
you're
in
Ruby,
it's
similar
to
Ruby
gems
or,
if
you're
in
Java,
that
there's
maven
and
Ivy
and
all
of
that
stuff.
So
this
is
our
our
simple
thing
to
do.
If
it
downloads
dependencies,
it
can
build
your
code,
it
can
run
tests
and
it
can
even
publish
to
our
central
a
package
management
system
called
crates
IO.
A
A
So
for
you
know,
for
the
purposes
of
this
talk
that
we're
going
to
be.
You
know
stepping,
through
a
little
bit
of
example,
that
you
can
walk
through
so
here,
I'll
just
do
cargo
new
bin,
which
will
create
a
binary
or
executable
that
that
you
can
run,
and
so,
if
you
you
know
just
do
cargo,
do
bin,
Rus
bridge
or
whatever
you
want,
and
then
CD
into
this
directory
and
if
you're,
using
a
version
control
that
we've
set
up
get
by
default.
A
Okay,
all
right,
so
the
files
that
cargo
new
will
generate
are
just
three
files.
So
there's
this
cargo
Tamil
file
that
describes
the
metadata
about
your
packages
about
any
dependencies
that
you
might
use.
We
have
a
GUID
ignore
we
actually
set
up
get
inside
this
environment,
for
you
just
as
a
convenient
and
then
finally,
this
source
/
main
dot
RS,
which
is
the
actual
rust
file
so
before
we
get
to
actually
doing
rust,
I'm
going
to
step
through
the
cargo
file,
which
is
very
simple,
so
just
is
the
name.
A
The
version-
and
you
know
who
is
like
setting
up
one
of
these
projects,
so
rust
or
cargo,
will
try
to
pull
out
this
metadata
from
like
if
you
have
get
set
up,
that
will
try
to
get
that
your
email
address
from
there
so
you're
welcome
to
change
this
to
whatever
you
want.
We
don't
have
any
dependencies
right
now,
so
this
this
will
be
blank.
So
the
now
here's
rust
this
is
a
hello
world
that
it
should
automatically
generate
for
you.
A
So
so,
if
you
haven't
done
any
rust
whatsoever
so
to
walk
through
what
the
code
is.
So
this
is
the
function,
so
we
denote
a
function
with
FN
and
then
we
have
the
function.
Name
main
and
main
is
a
special
function.
This
is
the
the
entry
point
into
the
executable.
So
when
you
execute
the
program,
we'll
execute
this,
so
here
we're
going
to
print
out
hello,
world
and
so
println.
This
is
actually
called
a
macro,
but
you
don't
have
to
actually
really
know
the
details
about
it.
A
A
A
Ok,
so
now
that
I've
gone
through
that
I'm
going
to
start
going
into
the
how
rust
is
like
similar
to
other
languages,
the
thing
won't
have
any
questions
right
now.
Okay,
so
first
off
comments:
surest
is
it
has
a
you
can
do
a
slash,
slash
which
is
like
you
know,
C
style
comments.
We
also
have
the
block
quotes.
So
your
if
you
want
you
can
try
commenting
out
things.
A
Slash
slash
will
just
comment
out
things
on
a
single
line,
whereas
block
quotes
will
comment
out
like
multiple
lines
of
code,
so
you're
welcome
to
to
play
around
with
this.
If
you
want,
there
is
also
a
few
other
kinds
of
comments
that
are,
you
know,
help
drive
the
documentation,
but
we
don't
have
to
go
into
that
now.
A
Next
is
variables,
so
variables
are
defined
by
using
the
keyword,
let
that
denotes
a
variable.
Then
you
have
a
variable
named
an
equal
sign
and
then
you
know
some
value.
So
here
we
have,
you
know
a
variable
name,
Eric,
a
variable
age
and
I'm
getting
old,
and
then
here
we're
just
going
to
print
out
the
the
these
variables.
So
here
just
to
step
through
the
string,
this
is
actually
kind
of
a
little
bit
of
a
magic
string.
A
A
Ok,
so
so
now
an
experiment,
so
we
have
a
variable.
So
we
we
have.
This
is
the
separators
a
little
bit
off
but
like
we're
we're
creating
a
number
of
apples.
So
we
we
say
that
we
have
a
hundred
apples
and
then
we
want
to
add
fifty
apples
to
it
and
then
we
try
to
print
it
out.
So
can
someone
try
running
this?
A
A
Yes,
so
you
should
probably
get
an
error
message
like
this,
so
this
is
surest
draws
a
lot
of
inspiration
from
functional
languages
if
you've
heard
of
them
that,
by
default,
all
of
the
Russ
variables
are
immutable,
which
means
that
you
know
it's
going
to
be
a
compile
time
error
if
you
try
to
change
them.
The
reason
why
we
do
this
is
that
you
know
a
lot
of
programming
bugs
actually
come
when
people
change
variables
out
from
under
you
and
you
aren't
expecting
it.
A
A
So
next
up
is
is
types
so
has
surest
is
strongly
typed
and
it
strongly
and
statically
typed.
So
this
means
that,
like
you
know,
so
that
when
you
assign
a
type
to
a
particular
value
that
it
is,
it
is
always
going
to
be
that
type.
So
it's
not
like,
if
you're
familiar
with
Python,
that
you
could,
you
could
have
a
variable.
That
is
a
string
at
one
moment
and
then
you
can
reassign
it
to
an
integer.
A
You
can't
do
that
in
rust,
so
we
have
a
number
of
different
types
like
we
have
a
lot
of
integer
types.
For
example,
we
have
unsigned
32-bit,
integers
I,
signed
32-bit,
integers
floating
point
numbers.
We
also
have
like
u8
in
order
to
define
a
an
8-bit
editor.
So
we
also
have
strings
so
strings,
unfortunately,
are
a
little
bit
complicated
rust,
so
we
have
a
string
and
this
ampersand
ster,
the
we
call
ampersand
stir
as
string
slice,
so
I'm
going
to
get
into
this
later,
because
it's
it's
always
like
a
point
of
confusion
in
the
language.
A
We
also
have
a
boolean,
so
other
things
that
you
might
have
noticed
is
that
when
we
were
playing
with
variables
that
we
actually
didn't
specify
the
type,
so
this
is
because
rust
has
type
inference.
So
this
means
that
the
hip,
the
compiler,
can
automatically
figure
out
the
type
of
a
variable
that
you
don't
have
to
do
the
work
so
as
opposed
to
Java
and
C,
where
you
have
to
explicitly
say
that
you
know
I
want
to
do.
Int
2
equals
5
that
rest
will
save
that
work
for
you.
A
Sometimes,
though,
rust
is
not
able
to
figure
out
the
type.
So
then
you
have
to
explicitly
specify
the
type
so
and
you
express
a
type
like
so
here
we
have
a
variable
age,
and
then
you
do
some,
you
do
colon,
then
the
type
name
equals
30
and
then
one
thing,
though,
with
rust
is
that
the
place
where
you
always,
you
always
have
to
specify
types
on
functions.
A
A
Okay,
so
functions
so
I
mentioned.
You
know
the
main
function
before
but
like
we
also
have
other
functions
that
you
can
define.
It's
defined
the
same
way
that
you
have
FN
and
then
the
function
name
and
then
an
argument.
So
here
we
have,
you
have
parentheses,
then
the
argument
name
colon
the
argument
type
and
then
you
can
have
like
multiple
argument,
types
that
are
comma
separated
the
output
type.
Is
you
know
after
this
arrow
and
the
i30
too?
So
then
like
here?
A
A
So
here
we
want
to
do
you
know
this
is
a
movie
rating
I'm,
not
sure
how
they
do
movie
ratings
and
in
Mexico,
but
in
the
United
States
we
have
a
few
different
ratings
of
like
G
and
PG
for
kids,
but
then
you
know
we
have
our
rating,
for
you
know
if
you're
older
than
you
know,
17
for
you
know
other.
You
know
more
older
movies.
So
so
here
we
define
our
variable
and
then
you
just
do.
If
you
know
n
is
less
than
13,
so
this
is
very
similar
to
other
languages.
A
A
We
also
have
match
statements
which,
if
you
are
familiar
with
switch
statements
or
case
statements
and
other
languages,
this
is
pretty
similar
to
that.
But
ours
are
actually
like
a
lot
better
than
a
lot
of
other
languages.
So
here
you
know
we
could
have
written
the
other
exam
I'm.
Like
you
know
what
what
kind
of
what
rating
a
movie
someone
could
see
by
doing
match
than
the
variable
name,
and
then
here
we
have
a
few
different
options.
A
So
here
we
say
like
between
0
and
12,
you
can
you
may
CG
or
PG
movies.
So
the
way
that
this
is
written
is
like
here
we
have
this
range
expression,
so
we're
saying
like
0.12,
that
that
is
just
saying
that,
like
you
know
in
between
these
two
integer
values
that
you
know
it
will
match
this
argument,
and
then
we
have
what
we
in
the
community
called
the
rocket
or
the
equals
arrow.
A
That
has
the
expression
that
we're
trying
to
run,
and
then
it
just
needs
to
be
comma
separated
for
the
next
one.
Then
down
here
is
the
like.
You
know
we
have
underscore
which
you
know
if
you're
doing
a
match
statement.
This
is
this
is
going
to
match
all
of
the
values
like.
So
if
it's
outside
of
this
range,
it's
always
going
to
come
down
here
if
you're
familiar
with
switch
statements
from
C,
this
is
analogous
to
the
default.
A
A
So
next
is
arrays,
so
arrays
are
similar
to
other
languages,
but
like
they're,
actually
a
like
a
little
bit
more
complicated
in
rust
that
we'll
get
into
a
little
bit
later.
So
here,
if
you
want,
you
can
update
the
little
example
to
say
you
know
here
we're
going
to
create
an
array
of
3,
3,
integers
and
then
we'll
just
modify
one
of
them
and
then
print
it
out.
A
So
here
you'll
notice
that
we
actually
have
a
different
thing
like
we
have
curly,
brace
calling
question
mark
and
curly
brace,
you
know
a
bit
of
line
noise,
but
you
know
it's
actually.
You
know
here.
It
is
like
a
way
that
we
can
do
formatting
for
specific
types.
So
we
have
the
curly
brace
close.
Curly
brace
is
what
we
call
display.
So
this
is
for
things
that
it
actually
makes
sense
that
you
know
they're.
They
have
a
natural
representation
as
a
string,
so
like
printing
out
an
integer
or
printing
out.
A
A
string
should
always
look
like
this,
but
sometimes
you
have
some
complex
types
like
an
array
where
there
isn't
just
like
one
way
of
printing
it
out,
so
we
don't
necessarily
want
to
just
have
a
canonical
way
of
printing
it.
So
we
have
this
thing
called
debug
which
just
helps
it
it's
designed
for
the
developer
for
helping
them
figure
out.
You
know
what
they're
doing,
whereas
display
is
really
designed
for
the
user,
the
end
user
and
also
like
for
them
to
be.
A
You
know
able
to
see
what
you
know
is
going
on,
so
we
we
don't
necessarily
want
to
make
assumptions
about
like
how,
like
what
kind
of
functions
you're
and
how
you
want
to
use
these
things.
We
we
just
try
to
give
people
options
in
order
to
express
like
how
they
do
things.
So
the
other
thing
is
that,
like,
if
you
have
there's
a
mode
called
pretty
debug,
so
this
is
colon
or
curly,
brace
colon
hash,
question
mark
and
curly
brace,
it's
kind
of
horrible
if
you
aren't
used
to
it.
A
C
B
A
So
the
in
this
case,
like
yeah,
the
the
return
value
of
this
function,
actually
so
so
the
return
value
like
we
didn't
specify
type
here.
So
that
means
that,
like
we
like,
the
main
function
doesn't
like.
You
aren't
supposed
to
return
a
value
so
conveniently
the
the
println
produces
like
this.
This
is
the
the
unit
type
is,
is
what
we
call
it.
So
this
is.
You
can
write
this
as
open
parentheses,
close
parentheses.
It
just
means
that
you
know
there
is
no
value,
and
so
that's
that's
implicitly
like
implied
by
not
specimens
yeah.
B
A
B
A
So
the
other
thing
that
will
be
useful,
for
you
is
a
another
macro
that
we
have
called
panic,
so
panic
will
just
abort
your
program,
so
you're
welcome
to
like
right
now,
modify
your
stuff
and
right
panic
and
it
will
just
throw
an
exception.
Saying
I.
Well
it
here
it'll,
just
they
are
so
we
also
have
Penix
will
be
automatically
thrown
if
you
try
to
access
a
value
outside
of
an
array.
A
So
here
we
have
an
array
with
three
items,
but
if
we
try
to
access
like
the
ninth
item
in
the
array,
we
are
also
going
to
throw
an
error.
Now.
This
is
also
like
the
source
of
like
many
bugs
in
in
see.
So
you
know
we
just
automatically.
You
know
if
you
do
something
like
this,
that
we're
just
going
to
abort
the
program.
A
There
are
ways
of
doing
this
so
that
it
doesn't
cause
a
problem,
but
this
is
just
one
of
the
ways
that
we
try
to
make
make
things
a
little
bit
safer
for
you,
okay,
so
moving
on,
so
arrays
are
actually
pretty
limited
in
rust
that
you
know
you,
while
you
can
modify
the
individual
values
inside
entering,
you
can
actually
add
new
items
to
it
like.
So,
if
you
want
to
actually
mutate
the
length
of
an
array,
you
actually
need
to
use
a
vector
rather
than
right,
so
it
is
like.
A
We
actually
write
this
just
the
same
way
as
we
do
arrays.
We
just
use
the
macro
Zek
bang
in
order
to
declare
it
so
beyond
that
it
acts
just
like
a
race.
So
you
can,
you
can,
you
know,
assign
values
to
it,
and
you
can
also
modify
the
the
length
you
can
add
new
values
to
it.
So
this
is
much
probably
a
lot
more
similar
to
two
arrays
that
you'll
find
in
languages
like
like
Ruby
or
Python.
A
They,
you
know,
so
we
just
give
different
options
like
we
like,
as
I
mentioned
before,
that
we
want
to
make
things
explicit
rather
than
implicit,
that
this
is
one
of
these
cases
that
we
want
to
make
sure
that
you
understand
that
there
is
a
cost
to
doing
these.
Things
like
we
arrays
are
much
cheaper
than
than
vectors,
but
you
know
a
lot
of
times.
You
actually
want
to
use
the
vector,
because
you
don't
you,
don't
have
a
fixed
length
array
that
you're
working
with
it
could
change
dynamically.
A
So
the
next
thing
after
we
have
a
raise
is
that
you
might
want
to
be
able
to
step
through
all
of
the
items
in
it.
So
so
here
we
have
a
few
different
ways
of
iterating.
We
call
these
four
loops,
so
you
know
we
I
showed
you
ranges
before,
so
you
can
actually
do
a
for
I
in
you
know,
0
to
10
it's
and
then
we'll
just
print
it
out,
but
you
might
also
want
to
step
through
all
the
items
in
a
vector
which
is
the
you
know.
A
Here
we
define
a
vector
and
then
we
we
do
for
name
and
names
hitter.
So
this
either
is
a
method
call.
So
this
actually
produces
an
iterator
that
I'll
go
into
a
second,
but
we
also
have
like
a
few
other
ways
of
stepping
through
things,
so
we
have
loops
which
are
just
infinite
loops,
so
we
have
while
loops.
A
So
if
you
want
to
have
an
exit
because
of
some
condition
and
break
which
allows
you
to
break
out
of
loops
at
any
point
time,
there's
also
I
forgot
to
put
on
continue,
which
is
just
like
you
know,
see
continue.
So
if
you
just
want
to
skip
to
the
next
loop
iteration,
did
anyone
have
any
problems
with
this?
This
doing
good,
okay
feel
free
to
oh,
yes,
sir,
can
you
use
the
microphone
in.
B
A
A
And
it's
a
well
liked.
Yeah
yeah
I
didn't
realize
that
we
were
using
two
different
things.
So
this
is
so
we
have
inclusive
ranges.
So
you
know
if
you
do
0.10
and
inclusive
range,
I
think
this
is
how
it
is
so
this
will
be.
It
will
actually
produce
items
zero
through
nine
if
you
do
0.10,
but
that's
only
sorry
that
is
0.10
will
be
zero
through
ten,
so
produce
one
two,
three,
four:
five:
six,
seven,
eight
nine
ten!
A
So
it's
just
whether
or
not
you
want
the
last
items
we
included
in
the
the
the
list
or
not
okay,
good
catch
I
should
fix
that
because
I
don't
know
if
I
really
need
to
go
into
that
all
right
here,
any
other
questions:
okay,
okay,
so
iterators.
So
this
is
one
of
like
the
really
super
cool
things
about
rust.
That
you
know
is
one
of
my
favorite
things
so
so
iterators
like
are
in
other
languages,
but
we
we
actually
have
these
really
powerful
ways
of
stepping
through
items.
A
So
you
know
before
we
had
like
0
through
10
but
say
we
wanted
to
look
at
just
the
even
numbers.
So
you
could
write
a
you
know
for
loop
and
then
have
a
use
if,
in
order
to
like
test
to
see,
if
an
item
like
if
the
modulo
is
like
some
item
is
2
or
0
against
2,
which
you
know
this
is,
is
going
to
do
so.
That
would
test.
A
A
Sequel,
SQL
yeah,
so
this
is
it
actually,
it's
very
similar
to
writing,
like
sequel
expression,
so
you
can,
you
can
like
filter
is,
is
like
a
select
statements
and
you
can,
you
can
do
joins
with
you
know
other
operators.
So
here
we
are
this
first
one
is
just
going
to
like
for
each
item
in
this.
This
range
that
we
are
just
going
to
apply
this.
This
is
called
a
closure.
A
So
this
this
will
be
called
on
each
item
where
the
you
know
inside
the
the
vertical
pipes
is
the
the
name
of
the
the
argument,
and
then
here
we
just
have
a
little
test
where
it's
going
to
return
a
bool
boolean.
If
the
boolean
is
true,
then
it
will
keep
it
and
if
it's
false,
then
it
will
filter
out
that
that
item
we
also
have
maps
like
mapping
is
just
like
for
each
item
that
we
iterate
or
we
are
stepping
over,
create
a
new
value.
A
That
is
just
like
we're
multiplying
this,
so
you
know
here
we
will
do
like
0
through
10,
but
this
will
produce
you
0
1,
4,
6,
0,
4,
9,
yeah,
yes,
okay
and
then
the
the
last
thing
that,
like
there's,
lots
and
lots
of
these
methods,
which
you
can
see
in
our
documentation
but
like
another
one
from
like
functional
programming,
is
called
cold.
Where
you
actually
are
you
for
each
item
you
want
to
like
in
this
case,
we
just
want
to
add
up
all
of
the
items
inside
this
array,
so
you
know
we.
A
We
are
initializing
it
with
a
default
value.
We
are
like
you're
stepping
through
a
closure
of
two
values
and
we're
just
like
we
are
adding
the
value
and
then
the
next
cycle
we're
passing
in
the
result
of
this
to
the
next
closure.
If
you
haven't
done
functional
programming
this
you
know
it
took
me
a
little
bit
more
time
before
I
really
understood
folds.
If
you
don't
quite
understand
this,
that's
fine
I
can
try
to
walk
you
through
it
later
so,
and
then
I
spoke
about
the
closure
has.
Is
there
any
questions
about
this?
Yes,
Oh.
A
D
A
Are
not
macros
there's
no
vectors
vectors,
they
are
not
they
actually
so
so.
This
is
actually
like.
Zero
dot
dot
is
actually
an
iterator
like,
so
it
is
an
iterator
that,
like
as
it
is,
so
it's
not
computing
like
all
of
the
items
it
is
just
under
the
covers.
It
just
has
a
counter
and
each
time
you
step
through
it.
It's
under
the
covers,
adding
one
to
that
value
and
returning
it
like.
E
A
So
one
thing
also
I
forgot
to
mention
about
like
the
coolest
thing
about
iterators-
is
that
that
these
actually,
like
you,
have
all
of
these
low
expression,
but
it
like
compiles
all
the
way
down
like
into
like.
You
know,
pretty
much
the
fastest
way
that
you
could
write
these
expressions
by
hand
like
all
of
the
like.
You
could
have
a
huge
number
of
these,
like
iterator
methods
being
called
like
you
could
be
mapping
filtering,
then
grouping
and
then
doing
another
mapping.
A
You
can
actually
do
really
horrible
things
to
these
things
and
it
all
just
like
compiles
away
into
essentially
as
fast
as
like
possible.
So
you
know
all
of
the
cool
things
that
you
can
do
with
like
Python
generator
expressions
that
this
is.
You
know
this
allows
you
to
do
really
complex
things
without
come
over.
Yes,.
F
A
F
A
Is
a
so
the
this
would
all
be
on
the
stack,
but
inside
the
iterator
it's
opaque,
like
it
could
be
internally
doing
something
on
the
heat,
so
it
could
like
like
say,
you're
like
if
you
want
to
iterate
through
a
tree
structure,
but
usually
you
have
to
have
some
kind
of
an
internal
stack
and
or
it's
like
keep
track
of
where
you
are
inside
this
whole
thing,
so
you
might
have
to
like
allocate
some
memory,
but
it's
all
like.
If
you
don't
need
to
then
like
it's
all
along
the
on
on
the
stack.
A
G
A
E
A
A
Yet
there's
there
are
things
called
reference,
so,
let's
say
say:
each
of
these
items
say
they're
like
some
really
complicated
like
expensive,
large
structure
like
so
not
just
like
these
strings,
but
like
something
that
is
using
like
you
know,
tens
of
you
know
bytes
and
you
don't
necessarily
want
to
copy
them
around.
So
either
is
going
to
create
a
reference
to
each
of
these
items
and
so
that
all
it's
doing
is
under
the
covers.
A
It's
just
passing
around
a
pointer
to
each
of
those
items,
so
it's
very
cheap
to
pass
a
drop
there's
also
a
eight
or
month
like
eight
or
underscore
mu
T.
So
this
will
create
a
iterator
that
returns
mutable
references.
So
if
you
want
to
mutate
like
change
the
items
that
you're
stepping
through
that,
like
you
know
it
will
it
will
allow
you
to
do
that.
Then
the
last
version
of
like
a
iterator
is
is
a.
A
A
Okay,
so
okay,
so
iterators,
so
he
knows
so.
This
is
or
one
of
the
other
like
things
that
I
really
like
about
the
language.
If
you've
used
C
or
Java
C++,
they
have
enums,
which
is
like
you
want
to
have
some
values
that
only
can
represent
like
these
three
values,
like
you
know,
if
we
have
traffic
lights
like
I'm,
not
sure
here,
but
in
the
u.s.
like
our
traffic
lights,
are
red,
yellow
green,
and
so
we
want
to
just
make
sure
that
you
know
we
have
some
value.
A
That
can
only
ever
be
these
things
and
if
you
ever
try
to
do
something
else,
there
will
be
a
compile
time
error
and
then
you
can
use
these
with
match
statements.
So
here
we
are
just
going
to
do
something
for
each
of
you
know.
If
it's
green,
we
want
to
go.
If
it's
red
we
stop.
Yellow
we
want
to
slow
down,
is
pretty
similar
to
what
you
get
in
in
other
languages,
but
in
rust
our
enums
are
actually
like,
so
much
more
powerful
than
that,
because
we
can
actually
pass
in
values.
A
So
here
like
say,
we
were
making
a
little
video
game
and
we
wanted
to,
like
you
know,
have
you
know
either
decide
whether
or
not
we're
doing
a
single-player
game
or
a
multiplayer
game
where
we
want
to
say
that
you
know
how
many
players
are
in
this,
so
you
can
define
it
just
like
you
know
you
have.
You
know
the
enum
type
:
:,
then
the
enum
variant
that
you
want
to
use
and
parentheses
the
values.
A
And
then
you
can
use
this
with
match
statements
in
order
to
do
something
special
based
off
of
the
particular
values.
So
you
can
do
multiplayer
with
parentheses
to
you
call
a
thing
off
about
like
recommending
a
game
of
checkers
with
two-player
game.
If
you
have
four
people,
you
can
recommend
a
game,
a
bridge
or
if
you
want
to
do
something
for
any
number
of
players
that
you
can,
you
can
suggest,
like
you
know
something
like
playing
tag.
Does
this
make
sense.
A
G
A
Any
other
question:
okay,
so
now
I'm
gonna
start
getting
into
things
that
are
particular
to
rust
itself,
so
the
okay,
so
we
saw
enums
before
so
one
of
the
one
of
the
other
things
that
is
special
to
rust
is
that
we
do
not
have
this
null
type
that
you
might
have
seen
in
other
languages
or
nil.
So
there's
like
for
all
of
our
values,
they
you
can't
just
assign
null
to
them.
A
This
is
because,
like
they're
just
so
many
problems
with
like
people
dealing
with
like
null
pointer
exceptions,
getting
thrown
or,
like
you
know,
if
you're
in
C,
if
you
try
to
dereference
a
null
pointer,
who
knows
what
could
happen?
You
know
someone
could
use
that
as
avenue
for
compromising
your
your
system,
so
we
we've
defined
in
our
standard
library.
What
we
call
is
the
option
type,
so
this
is
just
a
normal
in
that
you
know
either
represents
some
value,
and
this
is
a
generic
type.
A
So
you
know
you
have
like
this
less
than
symbol,
T
greater
than
symbol.
If
you
see
it's
just
like
generic
types
and
and
C
so
this
option
can
represent
like
you,
can
use
an
option
type
in
order
to
represent
any
any
value
and
then
like
you,
have
to
explicitly
do
a
match
statement
in
order
to
unpack
the
the
option
type.
A
So
as
an
example
like
here,
like
you
know,
a
lot
of
our
libraries
are
written
such
that
you
know
it's
going
to
use
option
types
in
order
to
make
you
force
you
to
handle
the
case
that
maybe
there
might
not
be
a
value.
So
here
we
have
a
vector,
like
you
know,
the
vector
just
has
my
name
in
it
and
if
we
use
the
pop
value,
which
just
removes
the
last
item
in
a
row
and
if
you
print
it
out,
then
you
will
you
should
get
a
it
should
say.
A
A
This
dot
expect
method
and
if
it
ever
turns
out
that
the
OP
that
this
value
actually
is
none,
then
it's
going
to
throw
a
panic
and
abort
your
program.
So
this
is
nice
for
your
simple
testing,
but
generally
speaking
like
in
real
programs,
you
you
shouldn't
be
using
expect
you
should
you
should
explicitly
handle
the
use
cases.
A
Okay,
so
here's?
This
is
just
an
example
of
using
match
in
order
to
do
something
for
a
particular
value
like
in
this
case,
like
we
define
a
option.
Type
that
you
know
has
no
value
like
we're
using
a
none,
and
so
when
we
match
on
this
value,
it's
going
to
print
out.
You
know
name,
but
if
you
change
this
sum
that
you
would
you
get
a
name
printed
out.
A
A
So
so
you
either
have
the
case
that
everything's
fine
and
you
get
a
okay
value
in
your
enum
or
you
get
some
error
and
you
know
the
system
is
you
have
to
do
something,
but
you
don't
necessarily
want
to
abort
the
process
like
say
you're,
trying
to
access
a
website
and
it
turns
out
the
websites
down
that
you
don't
want
to
kill
your
program.
You
want
to,
like
maybe
retry
in
five
minutes
when
the
websites
back
up.
A
So
here's
just
like
another
example
like
in
this
case,
like
we're,
trying
to
parse
a
string
into
a
number.
So
this
is
another
method
that
we
have
dot
parse.
So
in
this
case,
like
parse
like
we
can
do
parsing
into
a
lot
of
like
different
types.
So
this
is
just
one
of
the
ways
that
you
explicitly
say:
I
want
to
parse
this
value
into
an
I-32,
a
signed,
32-bit
integer.
A
We
we
called
this
little
expression.
The
colon
colon
angle
bracket
closed
angle
bracket
the
rocket
fish
because
it
kind
of
looks
like
a
fish.
That's
moving
really
fast,
so
this
will
return
a
result.
Type
it
will
be
like
num
will
either
be
okay
because,
like
in
this
case,
it's
actually
an
integer
or
if
we
are
passing
it
a
string,
that's
not
a
integer
that
it
will
be
an
error
type.
A
You're
welcome
to
try
to
run
this
now
or
if
we
can
do
this
later,
I
think
we're
starting
to
run
low
on
time.
So
here's
like
result
also
has
the
dot
expects,
which
is
just
like
what
we
had
for
options.
So
if
you
want,
if
you
are
like,
if
you're
confident
that
you're
always
going
to
like
the
thing
is
going
to
succeed,
then
you
can
use
expect
and
it
will
ill
afford
the
program.
It
will
panic
the
program
if
there
is,
if
it
turns
out
that
your
expectation
was
wrong.
A
A
So
are
one
of
the
cool
things
like
as
another
digression
to
this
is
that
if
you
actually
leave
out
like
in
a
match
statement
like
say
we
we
remove
the
error
statement,
rust
will
actually
will
at
a
compile
time.
Errors
say
like
hey:
you
haven't
handled
all
the
cases,
so
this
is
like
a
way
that,
like
you
know,
it
will
make
sure
that
they,
you
are
like,
if
there's
something
that
you
a
condition
that
you
weren't
handling
like
rust,
will
actually
province,
making
sure
that
you're
handling
these
conditions.
A
A
A
This
is
using
like
some
generic
programming
that
is
like
you
could
substitute
this
into
like
a
I
64.
If
you
want
a
64
bit
type
but
Parsons
generic,
so
you
can
actually
use
parse
for,
like
you
can
actually
customize
it.
So
if
you
have
like
your
own
type
that
you
want
to
parse
like
say,
you
want
to
parse
a
string
into
some
URL
structure
that
you
could.
You
could
implement
this
parse
thing,
and
then
you
know
it's
just
you
can
use
it
like
that.
A
G
A
Would
would
be
the
value
for
the
air
yeah
like
so
this
is
a
this
will
be
some
error
type,
so
you
can
actually
like.
It
depends
on
like
this
actually
is
like
the
error
is
coming
from
parse,
so
I
think
like
parse
could
have
its
own
error
type
thing
like
hey
I,
try
to
parse
this
thing,
but
the
second
character
is
a
letter,
not
a.
G
A
If
you
want
like,
if
you
are,
if
you
are
expecting
a
particular
error
type
like
you
could
like
this
could
be
something
like
you
might
want
to
manipulate.
You
might
like
a
might
say:
hey.
You
should
retry
this
inside
seconds
like
it
really
depends
on
on
the
B
implementation,
okay,
but
that's
actually
a
good
lead-in
to
the
next
section
that
so
sometimes
you
actually
don't
want
to
care
about.
Like
the
error
message,
like
you
know,
like
say
you
know,
you
are
expecting
like
you're
implementing
something
to
you
know.
A
A
So
we
have
a
shortcut
called
like
the
question
mark
operator,
so
you
can
just
add
that
at
the
end
of
something
that's
returning
an
option
and
if
it's,
if
it's
a
error,
that
it
will
automatically
return
a
result,
type
or
a
result,
value
up
the
to
the
next
level.
But
if
it's,
if
it's,
if
it's
okay,
it's
going
to
automatically
unpack
the
result
type
for
you
and
return
the
value.
So
you
know
the
result
of
this
is
going
to
be.
You
know
just
another
integer
and
then
you
can
add
to
it.
A
G
A
G
F
A
So
so
what
so,
when
you
use
this
question
mark,
so
if
say
this,
we
passed
in
a
a
non
integer
string
that
this
just
as
a
short
circuit,
and
it
were
just
like
return
a
it-
will
just
return.
The
error,
like
this
error
up
to
the
chain,
but
then
there
also
like
you
know,
will
like,
if
everything's,
okay,
that
it
will
like
this
expression,
will
evaluate
into
the
parsed
integer.
Does
that
make
sense?
A
Okay
and
then
we
just
have
to
rewrap
it
and
in
the
result,
type
in
order
to
propagate
up
one
of
the
other
things
that
you
can
do
like
in
this
circumstance
we're
returning
in
I
32,
but
you
could
also
like
say
we
wanted
to
like
reparse,
listen
to
a
string
or
like
return,
some
other
value
that
we
could.
The
okay
type
could
be
something
else
if
we
wanted
it
any
other
questions
before
moving
on.
F
A
Okay,
so
strings
so
I
mentioned
that
strings
are
really
complicated
us
and
we're
sorry
about
that.
We
we
are
trying
really
hard
to
come
up
with
simpler
ways
of
dealing
with
strings
the
the
reason
why
they're
complicated
is
because
this
is
also
like
this
whole
explicit
versus
implicit
like
we're,
trying
to
make
it
so
that
like,
if
you
need
to
you,
don't
have
to
pay
for
something
expensive,
so
strings
are
allocated
they're,
just
they're,
really
just
like
vectors
like
they
under
the
covers
are
allocating
a
block
of
memory.
A
You
can,
you
can
add,
characters
to
string
you
can
you
can
remove
characters,
it's
it's
easy
to
manipulate,
but
you
don't
necessarily
always
want
to
be
allocating.
You
know
strings
like
you
know,
if
you're
in
a
if
you're,
implementing
a
operating
system
that
you
don't
want
to
like
do
unnecessary
work
of
like
string
manipulation.
It's
like
you
can
just
pass
round
static,
string
arrays.
So
we
also
have
this
thing
called
like
ampersand
serve.
A
A
A
F
A
They
are
like
eight
work
like
they
are
objects,
in
a
sense
that
they
are
not
message.
They
are
not
like
allocated
they're
like
real.
You
know
they
just
fit
inside
of
register
inside
of
the
CPU,
but
yeah
they
are
kind
of
like
objects.
It's
theirs
yeah.
They
gets
a
little
bit
more
advanced
when
we
start
going
into
that.
So
any
other
questions.
G
A
Like
so
like,
so
if
you
call
like,
you,
have
an
integer
and
you
call
dot
to
string
on
it
that
that
is
going
to
it
has
to
allocate
memory,
has
like
parse
the
thing
into
some
some
string,
so
that
is
like
there
is
some
cost
associated
with
it.
But
if
you
don't
ever
call
to
string
on
it
that
you
aren't
going
to
be
allocating
memory,
okay,.
G
A
That
is,
like
you
know,
part
of
our
philosophy
of
like
we
as
much
as
we
can.
We
want
it
to
be
like
opt
in
that,
like
you
can
always
do
things
that
are
more
expensive,
but
like
we
try
to
make
sure
that
you
don't
have
to
do
the
expensive
thing,
but
this
is
one
of
the
ways
that
like
Russ
makes
it
like.
We
try
to
make
you
know
in
most
cases,
everything
like
as
fast
as
I
see
any
other
questions.
A
Really
Mac
there's
there's
no
like
performance
difference
between
calling
to
string
or
string
from
like
it.
If,
like
frankly,
it
just
depends
on
you
know,
there's
it's
you
know
they're.
So
under
the
covers
they're,
like
you
know,
we
have
these
things
called
traits
and
like
there
are
ways
that
you
can
generically
program
like
you
can
make
a
function
that
says,
like
I,
want
to
be
able
to
take
a
generic
type
that
has
the
ability
to
call
to
string
on
it,
but
I
don't
really
care
about
what
the
type
is
so
like.
A
There
are
some
things
like
when
you're
going
down
there
that,
like
you,
might
want
to
use
one
function
or
the
other,
but
for
the
most
part
it
doesn't
really
matter
it's
at
this
point,
it's
kind
of
like
a
style.
It
also
is
like
somewhat
of
a
implementation.
Detail
like
as
like
some
of
these
methods,
like
wewe,
had
to
do
some
some
changes
inside
the
compiler
in
order
to
make
them
more
efficient
so
that
there
are
some
like
there's.
Also
another
method
called
owned.
A
That
does
the
same
thing
at
one
point
in
time,
owned
was
cheaper
than
to
string,
but
it's
not
anymore.
So
it's
a
like
we
are
like.
We
are
ultimately
trying
to
like
all
the
changes
in
rust.
Like
you
know,
we
are
trying
to
evolve
the
language
over
time
in
order
to
make
it
faster,
but
we
also
don't
want
to
break
people's
code.
So
there's
you
know
it's.
You
know
there.
There
are
a
few
things
that
are
like.
There
are
not
necessarily
the
like
the
best
way
of
doing
things,
but
you
know
that's
the
life.
A
Otherwise
we
want
to
just
return.
The
number
like
you
know
it's
just
kind
of
a
silly
example.
So
if
anyone
is
playing
along
is
if
you
get
the
error
message,
anyone,
okay!
So
if
not
you'll
actually
get
an
error.
Saying,
like
you
know,
fizz
is
a
string
size,
but
you
know
you're
trying
to
return
a
string.
A
So
this
is
one
of
like
the
kind
of
the
annoying
parts
of
rust
that,
like
we're
trying
to
figure
out,
if
we
can,
we
can
do
this
a
little
bit
better,
but
usually
you
might
just
need
to
add
like
a
dot
to
string
on
one
of
these.
You
know
the
the
strings,
because
when
you
write
like
quotes
something
end
quote:
that's
actually
a
string
slice
like
it's.
It's
it's
a
compile-time
thing.
There's
no
reason
to
allocate
memory
for
that,
because
we
can.
A
G
So
if
the
stream
flies
and
that
in
the
stream
is,
can
you
see
them
some
like
in
JavaScript
that
box
values
of
that
building,
because
in
in
JavaScript
you
can
say
new,
extreme
and
we're
a
value?
So
it's
something
like
that.
You
get
like
more
functionality.
Out
of
that
a
box,
a
stream
that
row
a
stream
not.
A
Well,
so
you
do
have
more
functionality
with
with
strings
rather
than
string
slices
like
strings
you
can
you
can
mutate,
like
you
can
add,
you
can
depend
on
extra
like
characters
or
even
like
other
strings,
but
you
can't
do
that
to
string
slices
because
they
they
are
just
pointing
to
some
memory.
It's
possible
there
you're
actually
looking
inside
of
some
other
strings,
so
you
can
actually
append
values
to
it.
So.
G
A
G
A
A
We
don't
have
a
string
pool
like
under
the
covers
this
like
we
are.
This
is
just
like
pointing
out
a
block
of
memory
that
it's
it's
allocating.
It
is
possible
to
write
things
that
are
trying
to
to
to
implement
like
pull
strings.
If
you
want
it's
just
not
in
the
standard
library,
I
know
that
the
rest
of
the
Pilar
has
as
one
of
these
things
in
order
to
try
to
save
on
copying
strings.
So
if
it's
a
it's
pretty
common
pattern,
if
you
need
it,
okay,.
D
A
Maybe
so
this
you're
talking
about
inside
the
cook
the
executable
like
the
static
section
so
this
so
this
string
actually
would
be
in
this
static
section,
but
it's
also
possible
to
create
a
string
slice
of
like
pointing
inside
of
another
string.
So
actually
I
think
I
talked
about
that
oh
yeah,
under
these
the
slices
were
there
any
other
questions
before
we
get
to
slices
okay.
A
So,
as
I
was
saying,
like
string
slices
our
views
into
some
memory,
so
this
is
just
a
pointer
at
something,
so
it
could
be
a
pointer
into
the
static
part
of
the
binary.
So
this
is
like
you
know
it's
completely
free,
like
you
know,
there's
there's!
No,
it's
not
on
the
stack.
It's
just
like
you
know
one
of
these
things,
but
it
can
also
be
pointing
inside
of
like
some
allocated
string,
the
other.
So
the
other
thing
about
slices
is
that
it's
also
understand
how
long
of
a
slice
it
is.
A
H
H
A
A
A
The
vector
does
so
the
vector
has
under
the
covers.
It
has
like
a
block
of
memory,
and
it
knows
how
much
memory
has
been
allocated
for
the
slices.
All
our
slices
is
a
pointer
to
like
some,
you
know,
someplace
in
memory
and
then
the
amount
of
items
in
that
slice,
so
all
it
is,
is
just
a
pointer
and
alike.
Okay,.
G
E
E
A
I
think
we're
we
only
have
one
other
thing
to
cover
so
well:
okay,
actually
we're
two
other
things.
So,
as
I
mentioned
that
there
are
string
slices
there,
just
like
sector
slices.
So
here
we
can.
You
know
we
create
some
some
string
and
then
we
can
do
a
slice
inside
of
that
in
order
to
only
look
at
the
first
four
four
characters.
So
one
thing
with
strings:
if
you
ever
do
this-
that
we're
actually
looking
at
the
number
of
bytes,
not
the
number
of
characters.
A
A
A
It's
actually
it's
a
relatively
simple
thing
like
it's
like
you
know
it
is
the
compiler
tracks
who
owns
what
so
in
this
circumstance,
like
you
know,
I
at
this
water
bottle
like
if
I
give
this
to
someone
else,
then
you
know
their
responsibility.
They
can
do
whatever
they
want
with
the
water
bottles.
They
could
throw
it
away
or
they
could
give
it
back
to
me.
So
this
is
this
is
basically
you
know
like
by
tracking
this
and
the
compiler.
A
Then
the
compiler
knows
when
to
deallocate
things,
so
so
under
the
covers
we're
implementing
this
with
like
free
and
malloc.
So
we're
doing
all
that
memory
management
for
you,
so
the
as
I
mentioned
that
there's
this
whole
transferring
ownership.
So,
like
you
know,
if
you
want
to
like
here,
we've
allocated
some
block
in
memory
and
then
we
call
this
function
print
Veck.
A
So
this
actually
is
going
to
produce
an
error
because
we're
actually
like
in
this
first
line
we're
transferring
ownership
of
this
vector
to
the
function
and
then
at
the
end
of
the
function
it
actually
is
going
to
delete
all
the
memory
associated
with
the
vector.
So
when
we
call
quick
Beck
again,
we
actually,
this
is
going
to
result
in
a
compile
time.
Error
saying
that
you
know
the
vector
was
moved
into
this
other
function.
Does
that
make
sense?
A
Okay,
so
you
don't
always
want
to
be
moving
these
things
around,
because
that's
actually
inconvenient,
like
you
know
in
this
case
like
we
just
want
to
print
out
a
vector,
and
so
we
don't
actually
need
to
take
ownership
over
that.
So
this
is
where
references
come
in,
so
references
is
help
us
implement
borrowing.
So
this
is
saying,
like
you
know,
I
want
to
retain
ownership
over
a
piece
of
things
like
you
know,
my
water
bottle
I'm
going
to
loan
it
to
you
for
you
to,
like
you
know,
I
could
either
you
know
in
this
case.
A
I
could
just
you
know,
I
want
you
to
give
it
back
to
me
when
you're
done
with
it,
so
the
way
that
we
represent,
like
you,
know,
giving
someone
else
a
reference
to
something
is
by
using
this
ampersand
symbol.
So
this
is
just
saying
like
I
want
to,
like
you,
give
someone
a
temporary
loan,
but
I
want
to
own
it,
so
that
I
can
delete
it
when
you're
done
with
it.
So
here
this
should
work
fine,
where
we
are
just
doing
an
and
present.
A
So
one
special
thing
about
the
syntax
is
like
we
are
doing
like
we
actually
like
the
way
that
you
create
a
slice
from
a
vector.
As
that
you
do
this
ampersand.
You
know
the
value,
then
we
do
dot
dot.
Saying
like
we
want
to
grab
a
slice
of
the
entire
thing
and
then
down
here.
We
just
have
a
slice
that
you
can
print
out.
So
the
nice
thing
here
is
that
you
could
actually
use
this.
A
This
method,
print
SEC
with
you
know,
if
you
have
one
of
these,
like
an
array,
that's
stored,
like
a
static
array,
that's
stored
inside,
like
the
executable
that
you
can't
modify,
that
you
can
use
this
function
on
it
as
well
as
using
it
with
like
vectors
that
are
dynamic.
This
is
also
really
useful
for
Strings,
like
if
you
want
to
be
able
to
use
one
of
these
methods
to
print
out
strings.
A
So
the
other
thing
that
I
kind
of
touched
upon
with
iterators
is
that
you
can
have
mutable
references
as
well.
So
say
you
want
to
pass
like
I,
have
a
vector
I
want
to
allow
someone
to
modify
one
of
the
values
inside
of
my
my
array,
slice
that
you
can
use
just
ampersand
mut
and
pass
it.
You
know
this
slice
and
then
it's
okay
for
it
to
change
it,
and
then
you
can
do
this
a
few
times
and
then
print
it
out,
but
it
shouldn't
be
a
problem.
Are
there?
A
F
A
A
Depends
so
the
like?
You
say
you
had
you
know
your
this
wasn't
the
main
function.
It
was
just
something
that
created
a
like:
it
created
a
vector,
and
then
you
try
to
return
a
slice
to
that
the
you
would
actually
get
a
compile-time
error,
because
you
know
someone
has
to
delete
the
memory,
so
the
in
that
circumstance
like
the
compiler
would
say
like
at
the
end
of
this
function,
I'm
trying
to
delete
this
thing,
but
you're
trying
to
return
a
reference
to
something
that.
A
However,
there
are
ways
of
like
you
can
have
methods,
so
you
could
express
a
method
that
is
returning
a
reference
to
something
and,
like
you
know,
as
long
as
you
like,
someone
is
like
the
original
object
that
but
has
the
block
of
memory
that
you
want
to
return
a
reference
to
as
long
as
that
is
still
alive,
that
you
can
return
references
to
it
so
that
that
gets
into.
Hopefully,
we'll
talk
a
little
bit
more
about
that
today.
If
not
like
you
know,
there's
I
I
can
talk
offline
about
that
it.
A
A
We
grab
a
immutable
reference
to
one
of
the
items
inside
this
vector,
and
then
we
try
to
clear
memory
so
in
languages
like
C
this
can
actually.
This
is
actually
one
of
the
really
big
sources
of
like
you
know,
causing
you
know,
security
exceptions
because,
like
you
now
have
this
you're,
pointing
at
like
undefined
memory
and
who
knows
what
that's
pointing
to
so.
This
is
the
result
in
the
compiler.
A
This
is
also
going
to
be,
like
probably
one
of
the
areas
where
Russ
gets
kind
of
confusing,
like
it
might
take
a
little
bit
of
time
to
like
understand
how
to
manage
mutable
references
and
immutable
references
to
things.
So,
if
you
feel
confused
about
this,
that's
normal
we'll
help
you
get
through
all
of
this
so
Oh
were
there
any
other
questions
about
this.
A
Okay,
so,
finally,
all
right.
So
that
is
there's
a
lot
of
other
things
that
I
am
NOT
going
through,
but
we're
going
to
talk
about
some
of
these
things
later
on
today,
but
you
know
this
hopefully
gives
you.
You
know
a
little
bit
of
a
touch
of
like
you
know
all
of
the
the
core
concepts
in
the
language.
A
A
So
the
last
thing
that
I
want
to
mention
before
I'm
done
and
then
like
I'm,
actually
going
to
be
done,
is
that,
like
I
mentioned
a
long
time
ago
about
like
cargo
and
cargo
crates
that
we
actually
have
like
a
really
large
community
that
has
been
building
like
a
bunch
of
libraries
that
you
can
use
like
this
is
one
of
like
our
big
things
that
we
are
trying
to
encourage
our
our
ecosystem
to
develop,
like
so
I
grabbed
this
picture
from
a
few
days
ago.
This
is
our
website,
crates,
IO.
A
So
you
can
see
here
that,
like
we've
already
had
9600
individual
libraries
that
you
can
use,
but
all
you
have
to
do
is
add
a
line
in
your
cargos,
a
Tamil
file
and
you
can
just
start
using
like
any
number
of
these
things
and
we've
already
had
like
over
161
million
people
or
vote.
You
know
million
downloads
of
all
of
these
different
grits,
so
we
have
a
really
large
ecosystem.
A
We
are
trying
to
make
it
so
that,
like
you,
don't
necessarily
need
to
like
implement
a
lot
of
things
they
you
know
we
can
have
a
really
broad
standard
library
without
actually
having
to
implement
it
all
ourselves.
So
with
that,
I
am
I'm
done.
Thank
you.
So
much
so
I
don't
know
if
we
necessarily
have
time
for
a
question
because
I'm
really
over
time,
but
so
thank
you
all.
Thank
you
all
for
paying
attention
and
barring
missing.