►
From YouTube: The Builder Pattern and Typestate Programming - Stefan Baumgartner - Rust Linz January 2023
Description
Almost 30 years ago, the Gang of Four wrote about software design patterns. They were highly influential, and over the course of decades, the proposed patterns have been cited, reused, misused, thrown away, and found again, over and over. One of those patterns -- the builder pattern -- gained some popularity in Rust's libraries. Let's take a look at what does, why the builder pattern is such a great fit for Rust, and how we can use some of the unique features of Rust's type system to make them even better.
--
Stefan Baumgartner works at Dynatrace. He writes for Manning, Smashing Magazine and A List Apart and made the Kessel run in less than 12 parsecs.
In his spare time, he organizes ScriptConf and DevOne in Linz, and co-hosts the German language Working Draft podcast. Stefan enjoys Italian food, Belgian beer and British vinyl records.
A
Maybe
let
me
look
real
quick,
so
before
I
start
I
want
to
ask
you
if
you
recognize
this
image,
it's
called
swans
it's
from
1956.,
it's
from
MC
Escher,
who
is
a
very,
very
known
artist
and
I
love
his
name
or
their
name,
because
I
guess
MC
are,
are
the
initials
but
I
always
think
of
a
techno
club's
master
of
cereal
money
when
I
read
this
name
and
yeah.
So
this
this
image,
those
swans
flying
in
a
pattern
are
also
produced
on
on
some
sort
of
pattern.
A
A
It
has
possibly
sold
over
half
a
million
copies
because
it
has
really
defined
how
people
think
of
object,
oriented
programming,
a
short
disclaimer
I
I
learned
about
object-oriented
programming,
of
course,
in
in
University
I
I
have
done
my
fair
share
for
cryptority
programming
in
the
past.
I
wouldn't
I
wouldn't
tell
for
myself
that
I'm
an
expert
in
object,
oriented
programming,
but
this
is
all
part
of
this
talk,
because
I
decided
to
look
a
traditional
object-oriented
programming
and
see
how
it
holds
up
in
Rust
and
those
design
patterns.
A
This
designed
patents,
book
defined
23,
Classics
of
the
design
patterns
with
examples
in
C,
plus,
plus
and
small
talk
and
University
teachers
all
over
the
globe
rejoiced
because
they
finally
have
enough
to
put
on
the
slides
for
their
curriculum.
This
is
where
I
learned
it
so
I
learned
it
at
the
Lindsay
University
software
engineering,
2
object-oriented
programming,
and
we
did
all
of
them
in
detail,
but
in
a
Java
script.
A
In
a
travel
context,
though,
the
book
splits
up
design
patterns
in
three
categories,
so
first
they
are
create
a
creational
design
patterns
designed
around
the
creation
of
objects
rather
than
instantiating
objects,
directly
their
structural
sign
patterns.
They
are
concerned
about
class
and
object
composition,
and,
last
but
not
least,
there
are
behavioral
design
patterns
which
are
which
Define
communication
between
objects.
There's
one
behavioral
design
pattern
that
you
should
know
when
you're
developing
rust,
which
is
the
iterator.
So
iterate
is
a
classical
design
pattern,
and
here
you
can
see
how
they
hold
up
in
Rust.
A
I
hope
I
didn't
put
to
his
name
that
they
claim
that
they
have
not
invented
design
patterns,
that
they
are
not
A,
New
Concept
and
they
were
presenting
software
development
for
ages,
but
they
were
the
first
ones
to
collect
them
to
talk
about
them
to
give
them
names.
So
p,
people
have
a
common
vocabulary
for
discussing
design
patterns,
and
this
is
why
this
this
book
is
also
so
impactful
in
my
opinion,
because
not
only
has
it
described
lots
of
common
things
in
software
development,
but
people
were
able
to
talk
about
that
and
I
guess.
A
This
is
why,
to
this
day,
this
book
is
one
of
those
which
is
still
recommended,
even
though
you
know
it's
the
way
it's
written
is.
Is
you
I
guess
you
wouldn't
write
a
book
like
this
today,
but
you
can
still
get
a
lot
out
of
it
and
again
I
tried
to
see
how
do
they
hold
up
in
a
modern
day,
programming
language
like
rust.
This
is
a
little
side
project
of
mine,
which
I
call
gamers
radiation
gamma
because
of
erigama
one
of
the
authors
of
the
book
in
the
radiation
like
okay.
A
If,
if
his
ideas
radiate
to
this
time,
how
far
to
be
radiate,
so
it's
it's
a
little
little
play
on
words,
and
you
know
how
can
it
be
the?
How
can
those
patterns
be
developed
in
Rust?
You
know
that
rust
has
many
influences
from
other
programming.
Languages
like
C,
plus
plus
also
influences
from
other
Pro
object-oriented
programming
languages
as
well,
and
the
Rust
book
this
one
here,
I
have
it
here
as
well.
A
The
rough
programming
language,
which
is
the
the
paper
copy
of
the
one
book
that
you
find
online,
also
discusses
object-oriented
programming
and
the
funny
thing
is
it
discusses
it
with
a
quote
from
their
design
patterns
book.
So
this
is
now
a
quote
section,
because
this
quote
here
is
quoted
from
the
rasp
program,
language,
which
quotes
it
from
the
design
patterns
book
in
the
talk
about
design
patterns,
and
it
says
that
this
book
that
object,
oriented
programs
are
made
up
of
objects.
A
Yes,
okay
and
then
object
packages,
both
data
and
the
procedures
that
can
operate
on
on
that
data
and
the
procedures
are
typically
called
Methods
or
operations,
and
well
we
have
that
in
Rust.
You
know
if
we
boil
it
down
if
you
boil
down
object-oriented
programming
to
that,
we
have
structs
and
in-ups,
and
we
have
input
blocks
so
yeah
with
that
we
have
some
way
of
object
orientation.
A
It
might
be
a
little
bit
different
than
you
know
it
from
well
languages
like
Java,
because
rust
lacks
inheritance
and
inheritance
is
a
fundamental
Concept
in
Java,
and
you
also,
if
you,
if
you
think
about
implementing
options
against
an
interface
here,
you
can
do
that
with
trades,
but
you
also
need
to
define
the
relationship
of
a
trade
like
to
memory
like.
Is
it
just
some
marker
for
monomerifications
or
trades
through
generics,
or
are
you
using
trade
objects,
which
is
a
fundamentally
different
thing
in
two
fundamentally
different
programming,
Styles,
so
yeah?
A
We
have
object
orientation,
which
means
it's
good
to
revisit
those
old
patterns
of
object-oriented
programming
and
one
pattern
that
I
decided
to
start
with
well
next
to
the
to
the
iterator
pattern,
obviously,
is
to
build
a
pattern,
because
this
is
one
pattern
that
I
constantly
stumbled
upon.
So
I've
seen
that
in
libraries,
I've
seen
that
in
the
standard,
library
and
I've
implemented
a
couple
of
builders
on
my
own
as
well,
it's
a
creational
pattern
and
if
you
do
it
right,
it's
also
a
recreational
pattern
and
it's
in
chapter
three
of
the
book.
A
The
first
chapter
of
the
design
patterns
catalog
and
it's
the
second
pattern
already.
So
it's
it's
pretty
pretty
early
in
the
book
in
the
Builder
pattern
is
for
object,
creation,
it's
a
creational
pattern
and
it
says
that
you
should
use
this
use
it
when
the
algorithm
for
creating
a
complex
object
should
be
independent
of
the
parts
that
make
up
the
object
and
how
they
are
assembled,
and
we
are
going
to
see
a
couple
of
examples
for
that,
and
also
the
construction
process
must
allow
different
representations
for
the
objects
that's
constructed.
A
Well,
this
is,
you
know
a
little
bit
about
polymorphism
and
we
are
not
going
to
touch
that.
We
are
only
talking
about
the
creation
path
about
the
assembling
part,
and
you
know
it's
it's
a
book
that
it's
loved
by
University.
We
have
class
diagrams
in
there.
So
this
is
something
where
you
can
fill
up.
Your
slides,
like
I,
do
right
now
and
you
have
a
couple
of
different
different
components
in
this
filter
pattern.
So,
first
of
all
the
Builder
and
the
Builder
is
in
this
case
an
interface.
A
So
if
I
remember
correctly
for
my
days
back
in
University,
if
it's
italic,
then
it's
just
an
abstraction
of
the
concretization
in
the
Builder
specifies
and
strict
interface
for
creating
parts
of
product
object.
Then
here
we
have
a
concrete
Builder,
which
is
an
implementation
of
Builder
and
it
actually
constructs
and
assembles
parts
of
the
product
by
implementing
the
Builder
interface.
A
So
it
defines
and
keeps
track
of
the
representation
it
creates,
but
it
also
provides
an
interface
or
a
method
for
retrieving
the
product.
So
this
is
get
result
in.
In
that
case,
and
of
course,
then
you
have
the
product.
The
product
represents
the
complex
object
which
is
under
construction,
and
the
concrete
Builder
builds
the
product's
internal
representation.
A
It
also
defines
the
process
baby
to
disassembled
and,
last
but
not
least,
you
have
to
directly
because
everything
needs
to
be
an
object.
Well,
what
it
does
it?
It
calls
the
build
in
the
assembles
part,
so
you
can
say
big
part
that
build
part.
This
yada
yada
yada,
let's
see
how
it
works
in
first,
so
in
Rust
you
are
stumbling
upon
Builder
patterns.
If
you
look,
for
example,
at
hyper,
so
hyper
is
decreed
for
doing
HTTP,
requests
and
responses.
You
can
Implement
clients
with
servers
with
it.
A
If
you
have
done
anything
web
related
in
Rust,
you
have
used
hyper
in
one
way
or
another,
and
Hyper
has
a
wonderful
way
of
constructing
requests,
and
you
know
in
in
terms
of
request.
It
makes
a
lot
of
sense.
We
are
going
to
see
why,
and
this
implements
the
Builder
pattern
we
call
or
we
create
the
Builder
by
calling
request
colon
column
Builder.
A
It
gives
us
an
instant
of
the
request
Builder
an
instance
of
the
request,
Builder,
and
then
we
have
a
fluent
interface
where
we
can
specify
different
parts
of
the
product,
which
is
a
request.
We
want
to
get
the
request
out
of
that.
So
we
have
one
method
to
Define.
Well,
the
method
get
post
put
delete
whatever
we
can
Define
the
URI.
We
can
define
a
header,
and
you
know
we
can
add
more
headers.
This
is
a
funny
thing
about
Builders
because
we
can
say
well,
I,
don't
know
how
many
headers
I'm
going
to
have.
A
Why
would
I
need
to
specify
everything
upon
construction
I
have
them
stored
in
some
variable
in
some
binding?
Let's
move
them
over
to
the
Builder,
and
this
is
a
very
flexible
part,
but
in
in
terms
of
an
HTTP
request.
This
makes
a
lot
of
sense.
You
know
you
don't
know
how
many
headers
you
are
going
to
set.
A
If
you,
if
you
you
know,
deal
with
Dynamic
requests,
for
example,
and
also
here
the
last
thing-
and
this
is
beautiful
after
we
have
defined
everything,
we
call
Builder
dot
body
which
gives
us
the
product
and
the
product
is
the
finished
HTTP
request
and
the
body.
The
body
method
call.
Is
the
last
method
called
we
do
so
after
that
our
object
is
constructed,
and
this
follows
you
know
the
the
pattern
of
of
an
HTTP
request.
A
We
are
defining
method
in
your
right
and
we're
defining
a
lot
of
headers,
and
the
last
thing
we
defined
is
the
body
and
in
theory
you
know
up
until
that
point
hyper
could
think
of
well.
Maybe
we're
already
sending
the
first
information
like
get
URI
header
and
only
when
the
body
is
being
set.
We
are,
we
are
closing
the
request,
so
you
can
do
a
streaming
HTTP
request
and
the
way
this
interface
is
constructed.
It
allows
you
to
stream
on
right
away.
So
this
is
a
nice
news.
A
I
don't
know
if
they
do
it
like
that,
but
the
interface
would
allow
it
and
yeah.
So
every
step
is
concrete
and
if
you
think
about
all
the
the
variants
in
HTTP
request
can
take
and
all
the
variations
that
you
can
do
having
an
interface
like
that
is
beautiful,
and
this
leads
me
to
a
couple
of
implications.
A
Think
about
print
Line
Print
line
is
not
a
function.
It's
macro
wide
because
we
have
a
very
editing
list
of
arguments
and
you
can't
set
default
values
for
functional
arguments.
So
if
you,
if
you
use
a
Constructor
function
like
colon
colon
U,
which
is
funny
enough,
a
pattern
on
its
own,
it
wouldn't
work
as
well,
and
we
can
see
that
in
this
fictional
representation
of
a
standard
process
command.
So
this
is
not
true.
This
is
something
that
I
put
up
a
command
is
exists
in
standard
process.
A
It
is
used
to
spawn
a
child
process
and
where
you
can
set
the
commands
some
arguments.
Environment
variables,
you
define
standard
in
standard
out
and
standard
error,
and
you
can
have
a
working
directory
in
the
working
directory
is
funnily
enough.
The
only
thing
that
is
optional
every
other
thing,
all
the
other
things
need
to
be
said:
indiff
I'm,
doing
a
standard,
Constructor
function
where
I'm
going
to
set
all
those
values
you
see.
On
the
right
hand,
side.
A
This
is
the
new
function
and
everything
is
optional,
except
the
one
thing
that
I
actually
need
the
one
thing
that
I
actually
care
about
and
in
my
implementation,
I
either
say
unwraport
default
and
Report
default
or
I
set
it
to
iOS.
10.
I
understand
about
iOS
10.,
so
I'm
setting
already
a
couple
of
default
values
and
this
Constructor
function
is
really
really
inflexible.
A
If
I
look
at
the
usage,
look
at
that,
so
I
have
ls.into,
then
maybe
l
and
a
as
arguments
and
then
lots
of
none
and
I
don't
even
know
what
all
those
nouns
mean.
So
this
is
something
where
I
say
well.
This
is
a
really
really
bad
interface
to
use
for
something
like
a
command
for
something
that
spawns
a
child
process.
I
mean
I
could
instantiate
it
directly
like
having
having
distract
opens
it
common
to
LS
and
then
just
go
for
default.
You
know
if
I
implement
the
default
trade
for
command.
A
I
can
do
things
like
that.
But
then
again
you
would
need
to
know
a
lot
about
all
these
properties
and
the
more
complex
the
object
or
the
instances,
the
harder
it
gets
to
say
well
just
to
default
default,
and
maybe
you
really
want
to
know
what's
behind
it
or
you
want
to
have
a
little
bit
of
flexibility.
A
A
That's
the
one
line,
it's
beautiful
and
it
when
you
read
it,
you
know
exactly
what
it's
doing
and
if
you
have
something
more
complex
well
for
like
the
optional
working
directory,
you
can
say:
well,
let's
do
a
new
command,
let's
set
a
couple
of
arguments
and
then,
if
I
have
a
working
directory
well
then
please
set
it
and
then
spawn
the
command
so
again,
also
also
from
the
construction.
Here
again
it
becomes
obvious
what
it
does
and
it's
prepared.
A
The
interface
is
prepared
for
everything,
a
really
really
beautiful
interface
and
something
you
know,
I
get
I,
get
pretty
excited
about
interfaces
like
that.
If
I
look
at
this
example
from
the
docs,
so
I
can
I
can
say
either
I
do
something
on
on
Windows
on
it's,
not
partial,
I.
Guess
it's
just
command.
We
have
a
couple
of
arguments
or
I
call
it
on
on
dash.
A
Okay,
a
little
bit
more
about
build
dependency,
rust
because
yeah
well.
This
is
something
from
the
standard
Library,
some
something
from
from
hyper,
but
there
are
lots
more
builder
patterns
in
Rust
and
usually
we
differentiate
between
two
variations.
One
variation
is
a
non-consuming
builder
and
a
non-consuming
builder
means
it
is
respective
to
the
ownership
of
the
Builder
structs.
A
A
And
if
you
look
at
that,
both
Arc
and
ox,
and
also
all
the
other
methods,
there
use
a
mutable
reference
to
itself,
which
means
that
the
actual
instance
is
going
to
be
changed
and
to
get
a
fluent
interface.
So
you
can
call
Dot
arc.arc.arc.arc.
It
also
returns
a
mutable
reference
to
itself,
which
means
that
if
you,
if
you
call
that
Arc,
if
you
call
to
them
it
changes
the
actual
instance
and
so
on
and
so
forth-
and
this
is
non-consuming,
you
don't
consume
the
actual
instance.
A
You
are
changing
the
instance,
and
this
has
a
couple
of
implications.
So
if
I
call
it,
for
example
like
that
they
say,
let's
command
is
common
color
column
new.
With
one
argument:
the
return
type
is
not
command
anymore,
it's
mutable
command,
so
it's
a
mutable
reference
to
to
command
and
difficult
spawn
in
the
next
line.
A
So
you
would
need
to
to
assign
it
then
again
to
binding.org
and
send
it
to
command.
But
you
need
to
have
the
first
instance
once
you
create
it
with
new,
you
need
to
store
it
in
The
Binding
to
continue
with
it.
And
of
course
you
can
still
do
one
Diner,
so
one
liners
are
still
still
totally
fine.
On
the
other
hand,
you
have
consuming
buildings,
and
this
is
also
an
example
from
standard
thread
Builder.
A
So
you
can
create
the
new
Builder,
a
new
thread
via
this
Builder,
where
you
set
the
name
and
optional
name
and
can
set
the
stack
size.
But
if
you
look
at
the
interface,
this
is
also
abbreviated
again
to
fit
on
a
slide.
You
see
that
they
take
a
mutable,
a
mutable
owned
struct,
so
not
a
multiple
reference
but
an
own
struct
and
also
return
and
own
struct,
which
means
that
if
you
are
changing
methods
within
your
control
flow,
you
need
to
reassign
to
a
new
binding
after
each
method.
A
A
A
Builders
have
an
actual
use
cases
in
Rust.
We've
seen
that
group
use
cases
is
that,
but
I
want
to
know
if
it's
easier
or
if
I
can
steer
in
some
way
how
my
products
are
constructed
and
it
should
be
simple
to
my
users
and
it
should
be
elegant
and
it
should
be
fun
and
what
I
want
to
create
is
again
it's.
It's
always
my
example.
A
Maybe
I'm
biased
here,
but
I
want
to
create
a
serverless
platform
in
this
serverless
platform
creates
execution
environments
where
you
have
a
worker,
a
worker
process
that
contains
ad
workload.
The
one
thing
that
you
want
to
execute
some
allocated
memory
and
the
flag
if
the
worker
should
be
kept
alive
after
execution
or
should
be
terminated.
A
You
need
to
have
all
properties
set.
You
need
the
workload,
you
need
the
mem
size
and
you
need
to
keep
alive.
However,
only
mem
says
in
people
life
can
be
pre-filled
with
defaults.
You
know
you
have
some
default
settings
and
you
can
change
them
later
on
whatever,
but
they
are
defaults,
the
workload
isn't
and
the
workout
might
come
from
an
external
source.
A
So
you
don't
know
when
constructing
the
instance,
if
you
already
have
a
workload
ready
or
if
the
vehicle
comes
from
some
stream
or
some
request
or
whatever,
and
this
Nuance
is
mirrored
in
the
worker
Builder.
If
you
look
at
the
worker
Builder,
it
has
the
same
properties
as
the
worker,
but
it
contains
an
option
of
a
string.
So
the
workload
is
not
yet
defined.
A
So
the
the
Builder
is
a
great
way
to
get
rid
of
those
optionals.
If
you
don't
need
them
so
yeah
a
little
bit
of
a
different
API,
and
that
has
some
reason
so
now,
let's
Implement
a
very
rough
implementation
of
a
worker
Builder.
So
first
of
all,
we
have
the
worker
build
up
here,
we're
creating
a
Constructor
function.
It
has
no
arguments,
so
we
are
say
workload,
there's
no
workload.
We
don't
have
one
defined,
yet
we
create
the
memory
size.
A
This
is
well
in
megabyte,
I,
guess
or
128
megabytes,
and
we
don't
want
to
keep
it
alive,
so
the
work
is
terminated
after
execution
and
then
we
have
the
workload
method.
So
this
is
where
we
set
the
workload
method.
It's
a
mutable
reference
to
myself,
which
means
it's
a
non-consuming
builder
and
workload
impulse
into
string,
which
means
that
anything
that
can
be
converted
into
a
string
I
take
it.
This
is
a
beautiful
way
of
monomorphization
beautiful
way
of
working
with
genetics.
Where
just
say
well,
give
me
whatever
you
have
can
be
a
string.
A
Slides
can
be
an
on
string,
can
be
anything
that
implements
to
string
or
display,
doesn't
matter
as
long
as
you
can
be
transformed
into
a
string.
I'll.
Take
it
and
then
I
said
well.
I
set
this
doubleclick
tool.
This
workload,
I
called
workload.in
2
to
go
from
what
it
had
to
an
actual
string
and
to
return
myself.
This
is
how
I
get
this
chainable
interface
I
dropped
the
methods
for
mem
size
and
keep
alive
they're,
pretty
easy,
we're
going
to
see
them
later,
anyway.
A
A
I
I,
transfer
memsa
as
I
transfer,
Keeper
Live
and
have
this
worker,
and
actually
this
should
be
just
self
or
consuming
a
method,
because
after
this
step,
I
want
to
consume
the
worker
Builder.
So
the
worker
Builder
can't
be
reused
again
after
the
worker
bill.
Determinates
I
want
to
be
done
with
it.
So
this
is
an
area
in
Mass.
That's
a
mirrors
are
about
that,
but
here's
one
problem
so
I
have
this
scared
scared,
Emoji
right
next
to
it,
because
hey
I'm
calling
unrepair.
This
is
an
answer
for
operation.
This
might
Panic.
A
A
First,
I
change
the
worker
Builder
interface,
so
I
said
the
worker
Builder
now
doesn't
have
a
workload
which
is
an
optional
string,
but
it
has
a
generic
parameter.
It
is
a
generic
parameter
where
I
have
not
decided
yet
what
the
workload
should
be
and
then
I'm
going
to
implement
the
generic
record
Builder.
Those
are
all
the
methods
which
don't
care
about
the
state
of
my
workload,
because
the
workload
has
a
state
either
it's
here
already
or
it
isn't,
but
those
methods
for
memsizing
keep
alive.
A
They
don't
care
about
the
state
of
the
workload,
so
I
can
implement
it
for
the
generic
version
of
worker
Builder,
and
this
is
what
I
do
here.
So
it's
just
it
just
says.
You
have
implemented
that
and
again
it
takes
a
mutable
reference
returns,
a
mutable
reference.
So
it's
it's
a
non-consuming
builder,
but
now
I
start
with
the
case.
What,
if
I,
don't
have
a
record
yet
and
I
Define
a
struct,
no
workload.
Look
at
that!
It's
an
empty
struct.
A
It
has
no
Fields,
it's
just
here
to
say
well,
this
is
one
thing
I
want
to
I
want
to
care
about,
and
then
I'm
implement
worker
builder
for
this
particular
structure.
So
no
generics
anywhere
just
for
this
particular
structure,
and
here
in
this
particular
implementation
for
worker
builder,
of
no
workload,
I
have
the
Constructor
function
and
the
Constructor
functions
is
new.
It
returns
local,
which
is
not
working.
It
fits
because
hey
that's
my
that's
my
parameter
here.
That's
okay!
A
The
memsa
sent
to
keep
alive
fine,
that's
great
and
I,
already
defined
mem
size
already
defined,
keep
alive
so
now,
I
need
to
Define
workload
and
it
takes
again
a
workload
imprint.
The
string
but
look
at
that
now:
I'm,
not
returning
self
or
change
something
in
my
parameters:
I'm
returning
a
new
worker
Builder
I'm
returning
a
new
worker
Builder,
where
I
set
the
workload
into
this
particular
string
where
I
set
the
memo
size
to
self-rem
size,
keep
alive
to
Safe,
Keep
lab
and
moving
those
fields
over
to
the
new
worker
Builder.
A
And
if
you
look
at
the
at
the
function,
signature,
if
you
look
at
the
return
type
and
now
not
returning
self
I'm
returning
a
worker,
Builder
string,
so
I'm
having
the
same
struct
the
same
type
but
I
have
a
different
state
of
imaginary
type,
so
I'm
moving
from
no
workload
to
stream,
and
you
can
really
think
about
like
about
it
like
a
state
machine.
So
you
started
in
a
workout
and
when
you
call
workload
you're
moving
to
a
different
state.
A
So,
let's
implement
the
rest.
Let's
Implement
worker
build
or
string
here.
I
have
to
build
method
and
again
sorry.
This
is
this
is
wrong.
This
shouldn't
be
an
ampersand
unit,
should
be
just
self,
and
this
one
since
now,
I'm
I'm
100
sure
that
I
have
everything
that
I
need,
that
I
have
a
workload.
I
can
simply
construct
a
worker
with
the
workload
with
mem
size
and
keep
alive
and
return
that.
A
And
yeah,
that's
the
last
state
and
the
beautiful
thing
about
that
workout
has
a
different
state.
Vehicle
has
a
state
where
it
starts,
which
is
nowhere
close
and
then
it
has
a
state
when
it
ends
which
is
I'm
having
a
workload
of
type
string
and
those
are
two
bookends
of
the
construction
process.
So
this
is
where
you
start
in
the
Builder
pattern.
A
You
start
creating
a
builder
and
then
you
are
done
with
the
building
process
and
you're,
getting
an
actual
object
or
an
actual
instance
of
your
struct
and
and
those
two
bookends
are
always
there
in
a
build
beta
and
the
one
thing
in
the
middle
is
variable.
This
is
the
one
thing
where
something
changes
and
those
two
bookends
are
separated
by
state
by
the
different
implementation
blocks.
A
A
There
we
go
so
actually
now.
I
just
had
a
talk
and
I'm
doing
some
some
slides.
Now
it's
getting
really
interesting
because
I'm
I'm
doing
new,
Bim
and
I
haven't
done
it
yet.
Oh
sorry,
I
should
I
should
add
it
to
the
stream
damage.
So
it's
going
to
be
interesting,
I
hope,
I,
hope,
I,
don't
I'm,
not
I'm,
not
stumbling
over
myself
yet,
but
yeah
I've
implemented
everything
you've
just
seen
here,
I
have
the
worker
I
have
to
struck
my
workbook
I.
A
Have
this
worker
builder
of
w
after
implementation,
for
the
no
workload
State
and
I'm
having
here
I'm,
adding
you
the
broke
a
bit
of
string,
okay,
I'm,
actually
getting
the
build
method,
so
yeah
here,
I've
also
changed
something
so
here.
I
have
also
changed
it
to
a
consuming
call
because
I'm
getting
a
new
structure.
So
this
is
okay.
This
this
works
like
intended
and
here
I'm
having
mem
sizing.
A
So
there
you
go
and
now,
let's
try
to
implement
it
well
to
work
with
it
so
I'm
having
my
worker
and
as
a
worker,
Builder
yeah,
can
you
edit
it
colon
colon
new
there?
It
is
Works
fantastic
and
if
you
look
at
it,
I'm
getting
a
worker
build
of
no
broker.
So
the
inlay
hints
from
us
to
analyzer
already
tell
me
that
I'm
having
no
workload
and
I
can
do
things
like
you
know,
whoop.
A
Something
nice
there
you
go.
You
see
that
I'm
having
here
a
worker
build
of
network
code
still
so
so
nothing
changes
here.
It's
still
a
worker
build
of
no
problem,
but
if
I'm
going
to
change
this
to
so
to
build,
look
at
that
I'm
also
getting
to
know
this
well,
no
method
name
build
found
to
start
to
Acapella.
So
it's
not
there.
It's
not
within
the
implementation
that
I
have
here
and
if
I
do
cargo
quilt.
A
It
also
tells
me
method
not
found
in
worker,
build
on
a
workload,
but
the
method
was
found
for
worker
Builder
string.
So
again,
things
is
the
bump.
Those
are
great
error.
Messages
that
help
me
with
my
case
so
I
go
to
this
line
and
say
well
now,
I'm
setting
a
workload
and
I'm
sitting
it
to
an
empty
string
and
look
at
that
now
it
changes
from
worker,
build
on
a
workload
to
worker
Builder
string
and
now
I'm,
also
having
the
build
method
available
and
now
I'm
getting
a
workout.
A
So
this
is
this
is
what
I
get
out
of
them,
and
you
know
I
still
can
work
with
with
the
generic
method.
So
you
still
can
say:
well,
let's
have
mem
size
and
set
it
to
something
entirely
different
or
let's
call
keep
alive
and
change
it
to
to
fault,
so
I'm
still
having
those
methods
that
come
from
the
generic
implementation.
They
are
still
there
because
their
generic
over
all
possible
States,
but
the
moment
I
go
at
the
workload.
A
I'm
moving
state
I'm
moving
state
from
the
concrete
concretization
of
no
workload
to
the
concretization
of
string,
and
this
is
how
I
can
use
type
State
programming
to
make
sure
my
apis
are
good
to
make
sure
that,
when
I
develop
something
that
my
users
and
everybody
who
uses
my
apis
are
not
doing
anything
wrong
and
they
don't
have
any
weird
state.
So
I
need
to
take
care
about
results
when
the
only
thing
that
can
happen
is
to
have
a
vehicle
in
here.
A
A
Okay,
you
should
see
myself
again
there
you
go.
Okay,
I
showed
it
that's
fine,
so
how
how
far
went
Gamers
radiation,
yeah,
I,
guess
the
Builder
pattern
holds
up
really
well,
in
fact,
I
think
it's
perfectly
suited
for
us.
So
it
shows
with
a
lot
of
examples
that
we've
already
seen
in
hyper
I,
understand
that
library
and
if
you
have
situations
where
you're
constructing
a
complex
object.
That
may
react
to
certain
things
in
your
program
then.
Well
it's
it's
really
good
to
use
a
build,
a
pattern.
A
How
often
do
you
need
to
set
an
option,
even
though,
though
you
shouldn't,
if
the
Constructor
gets
more
complex,
then
instantiate
that
instantiated
instantiating
it
directly
I'm.
Sorry,
then
why
not
using
then?
Why
don't
you
use
a
builder
directly?
It
has
the
complexity
of
the
product,
and
you
know
with
type
step
that
it
can
add
a
fantastic
and
types
of
API.