►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
B
Enough,
okay,
then
so
C
will
return.
As
mentioned
last
week,
Seibo
Reader
is
basically
a
class
again
stateful
forward.
Only
reader,
you
know
so
I'm,
just
gonna
start
going
through
the
sort
of
main
methods,
starting
with
the
Constructors.
Well,
it's
basically
only
one
constructor.
It
accepts
read-only
memory
containing
the
C
bore
encoding
to
be
read.
It
accepts
a
Seaborg
conformance
mode
enum,
which
defaults
to
strict
just
a
reminder.
Strict
mode
is
validating
for
duplicate
keys
in
the
map
and
also
validating
utf-8
strings
apart
from
just
basic
well
formed
in
there.
B
A
B
A
A
Mean
I,
don't
know
exactly
what
the
scenarios
are,
but
I
would
think
most
people
will
probably
have
that
data
either
as
a
stream
or
as
a
vital
ray
if
they
ever
does
the
stream.
That
I
ought
to
get
a
byte
array.
I'm,
not
sure
anybody
in
also
to
do
a
read
only
memory
over
a
by
the
way,
necessarily
well
worst
case.
There's
a
stream
and
then
then
try
to
figure
out
how
the
global.
D
B
D
Guess
the
problem
with
taking
the
array
or
with
taking
the
memory
in
a
constructor
we've
said
the
ownership
or
that
the
caller
is
responsible
of
maintaining
the
value
until
the
object
they
passed
it
to
in
a
constructor
is
out
of
scope
with
a
byte
array
input.
We
don't
have
clear
answers.
Are
we
treating
it
as
functional?
Are
we
making
a
defensive
copy?
Are
we
are
you
responsible
for
serving
the
data
during
the
lifetime
of
the
object?
You
passed
it
to
and
I
think
that's
why
we
skipped
at
an
ASN
reader
of
we.
A
I
mean
it's
a
special
like
it's
a
specialized
API,
so
I
don't
care
too
much,
but
I
would
normally
think.
If
you
want
to
make
it
usable,
we
would
at
least
have
an
overload
okay,
because
I
think
most
people
will
probably
have
the
data,
and
some
I
mean
you
know
they
don't
have
it
as
a
byte
array
that
can
usually
vertically
easy
to
figure
out
to
do
that.
I
understand.
But
we
don't
take
streams
that
makes
sense.
A
B
I
mean
the
first
three
of
them
are
well.
Two
of
them
are
echoing
just
the
parameters
that
were
passed
to
the
constructor
right.
Then
there's
current
depths
that
you
know
self-explanatory
it.
It
returns
the
context,
steps
of
the
the
reader.
Then
there
are
two
properties
and
I
actually
have
a
criticism.
Inform
VAP
I
am
myself
proposing
here.
So
one
is
returning.
B
Bytes
read,
which
is
you
know
the
number
of
bytes
that
have
been
read,
which
is
echoing
the
by
it's
written
property
that
exists
in
co-writer
and
then
there's
a
second
property
called
has
data,
which
is
a
boolean
which
indicates
basically
whether
there
is
more
data
in
the
buffer
to
read.
I
would
myself,
you
know
this
is
what
exists
in
the
code
base,
but
I
would
recommend.
B
D
B
D
B
So,
let's
talk
about
peaking
peaking.
Obviously
it's
just
the
methods
that
this
is
the
reader
uses
to
look
ahead
in
the
current
data
without
actually
advancing
the
state.
There
is
one
primary
method
that
does
this
and
called
peak
state
and
it
returns
an
enum
applicants.
C
will
read
or
state
so
I'm,
just
gonna
go
through
all
the
possible
states
returned
by
the
enumeration
here.
B
Basically
there's
the
none
state
which
will
never
be
returned
by
the
civil
reader.
We
basically
just
use
this
to
populate
the
zero
value,
so
that
default
is
not
you
know,
occupied
by
a
valid
state.
We
called
it
none.
Then
it's
just
going
through
the
Seaboard
major
types,
so
major
types:
zero,
unsigned,
integer,
negative,
integer,
major
type,
one
definite
length:
byte
string,
start
byte
string
for
indefinite
length,
byte
string,
byte
string,
n,
byte
string.
B
You
know
determining
the
length
of
the
sorry
at
the
end
of
an
indefinite
length,
byte
string
text
string
for
a
definite
length,
utf-8
string,
start
texturing
for
the
start
of
a
indefinite
length
text
string
and
similarly
end
text
string
for
the
end
of
an
indefinite
length
text
string,
start
array
denoting
obviously
the
start
of
an
array,
major
type
for
either
definite
length
or
indefinite
length
and
array.
Similarly,
denoting
the
end
of
an
array
start
map
denoting
the
start
of
a
map
and
then
map
denoting
the
end
of
a
map
tag
for
major
type.
B
Simple
value
for
simple
values
in
major
type:
seven,
then
you
have
the
three
floating-point
types:
half
precision,
single
precision,
floating
double
precision,
float
and
then
I
have
a
few
additional
states,
specializing,
simple
values
that
are
useful.
So
if
you're
special,
if
you're,
if
you're
simple
value,
happens
to
be
null
that
will
be
returned
as
a
specific
state
and
the
same
applies
to
boolean
finished,
denoting
that
well,
the
reader
has
completed
reading
a
full
seaboard
document.
B
B
End
of
data
indicating
that
you
know
the
Seaboard
document
has
completed
abruptly
and
format.
Therefore,
all
other
kinds
of
for
matters
me
and
Jeremy
were
actually
debating
whether
those
should
be
collapsed
to
one
single
state,
I
kind
of
felt
that
we
might
need
to
keep
a
separate
one
for
end
of
data.
But
it's
you
know
up
to
you
guys.
What
do
you
think.
A
A
B
B
D
The
idea
in
in
this
one
is
like
what
the
Jason
reader
does
is
the
the
peak
state
essentially
tells
you
which
method
or
methods
are
legal
to
call
next
right
so
start
array,
whether
it
was
definite
or
indefinite
only
has
one
method
that
you
would
call,
so
it
didn't
need
to
there's
no
benefit
in
distinguishing
the
state,
but
I
think
start.
Bytearray
has
a
method
that
you're
allowed
to
call
that
byte
array
does
not,
if
I,
if
I'm,
recalling
three
pages
ahead
correctly.
B
In
general,
I
would
say
that
the
reader
doesn't
make
any
attempts
to.
You
know
course,
data
so
like
if
you're
trying
to
read
a
float
and
the
underlying
value
is
an
integer,
then
it
will
throw
an
invalid
operation
exception.
So
generally,
this
is
pretty
rigid
and
the
state
will
basically
guide
you
to
essentially
the
only
method
that
you
are
able
to
call
to
advance
the
reader
state.
E
E
A
It's
funny
how
sometimes
performance
can
completely
you
up
like
I
am
now
at
the
point
where
every
time
I
type
it
takes
like
two
seconds
for
the
character
to
appear.
So
it's
not
just
performance
that
is
annoying
it
just
really
messes
with
your
mental
state
of
what
you're
doing
all
right.
So
then
it's
cool,
pastas
guy.
B
C
B
Will
yeah
it
will
do
work?
It
will
read
one
byte
ahead
from
the
buffer,
so
there
is
a
small
amount
of
parsing
effort,
but
we're
also
caching
that
so
that
we
can
call
it
many
times.
I
think
that
a
method
better
communicates
this
and
I
think
the
other
thing
is
a
property
might
confuse
people
into
believing
that
this
is
something
that
has
been
read,
whereas
a
method
indicates.
That
is
something
that
lies
ahead
more
clearly,
if
that
makes
sense,
I.
D
Mean
to
me
is
a
property.
It
feels
a
little
weird
because
it's
it's,
you
know,
updated
by
side
effects
of
calling
other
read
methods
and
the
fact
that
some
of
the
it's
not
just
reading
like
the
top
three
bits
and
reporting
the
major
type
it's
in
some
of
them
doing
more
complicated
things
to
figure
out
which
more
precise
thing
it
wants
to
do
so,
the
it
is.
Definitely
not
just
a
memory
read
or
a
field
return
fast,
but
it's
also
not.
You
know
computing.
The
hundreds
digit
of
pi.
A
A
I
guess
my
mental
model
is
just
like
I,
don't
know,
I
mean
probably
would
help
to
see
some
sample
code
again,
because
I
can
I,
don't
remember
it,
but
like
I,
think
normally,
when
I
write
a
loop
like
the
tuba
crew,
we
deliver
is
basically
switch
over.
The
state.
I
will
probably
first
look
at
properties
before
I.
A
D
A
A
A
A
B
A
B
A
Yeah
I
guess
depends
on
what
do
you
mean
by
that
right?
I
mean
the
way
I
see
state
is
like
it's
basically
communicating
what
you're
supposed
to
do
next
and
the
way
I
think
about
it's
more,
like
lazily
computed
when
but
yeah
I
guess,
which
it
is
yeah
I
mean
I,
don't
care
what
method
or
the
other
one.
It's
just
intuition,
I
guess
yeah.
D
B
A
D
Yeah
because
I
mean
I
understand
end
of
data
as
a
subset
of
the
document
is
corrupt
of
based
on
the
fact
that
you've
read
like
three
start
arrays
you
shouldn't,
especially
if
they
were
indefinite.
You
shouldn't
have
hit
the
end
of
the
payload
without
seeing
the
end
markers,
and
so
that's
like
hey,
you
gave
me.
Truncated
data
were
broken
and
that's
a
something
you
can
diagnose
and
I
assume
that
format.
D
A
B
A
A
B
When
I
was
writing,
this
initially
I
ended
up
with
like
15
different
error
in
states,
and
we
were
like
you
know-
maybe
maybe
we
shouldn't
use
an
enum
for
that,
but
but
but
sounds
like
we
should
be
using
an
enum
for
invalid
sequel
at
all.
Yeah.
B
Okay,
so
reader
methods,
so
the
general
shape
of
read,
messages
of
the
form,
type
read
type
and
some
arguments,
the
read
methods
with
will
either
successfully
decode
the
requested
value
or
throw
an
exception
and
not
advance
the
reader
state.
So
starting
with
integer
values,
which
are
major
types,
0
and
1.
Just
a
reminder.
Major
type
0
is
the
unsigned
integer,
as
you
type
1,
is
the
negative
integer
type.
B
So
first
we
have
the
signed
integer
reader
methods,
so
read
in
32
and
read
in
64,
so
basically
they
can
throw
three
kinds
of
exceptions.
You
have
invalid
operation
exception
in
cases
where
you
are
basically
trying
to
read.
Basically,
the
underlying
data
is
not
matching
beyond
the
measure
type
that
you
requested,
overflow
exception
can
be
thrown
if
the
value
is
too
large
to
fit
in
the
in
the
return
types
format,
exception
can
be
thrown
for
a
variety
of
reasons.
Whether
you
know
the
underlying
data
is
invalid.
D
So
I
mean
the
the
description
of
format
exception,
like
the
just
the
short
one
is
exception
is
thrown
when
the
format
of
an
argument
is
invalid
or
when
a
composite
format
string
is
not
well
formed.
I
agreed
that
the
that
we
do
want
an
exception
for
the
C
bore
is
broken,
but
format
exception
to
me
feels
like
it's
very
intimately
tied
to
two
string
format,
codes
and
and
parse,
so
I'm
doing
two
string
and
that
we
want
some
other
exception
here.
I
mean.
A
B
D
A
C
A
A
This
is
happened
to
be
the
Seaver
api
that
you
miss
using,
but,
like
the
error,
condition
is
read
the
docs
right
and
I
think
in
this
case
it's
like
yeah,
you,
you
gave
me
an
invalid
lee
or
an
not
a
well-formed
c
word
document
right
so
and-
and
that
seems
like
for
any
error
that
you
have
at
the
previous
one-
we
talked
about
like
the
end
of
data
and
format.
Errors
should
probably
be
also
doing
see,
bore
exceptions,
okay,.
B
A
A
B
Okay,
so
then
we
have
the
unsigned
integer
integer
methods
which
are
meta
type-0
again,
the
from
an
exception
perspective.
It
behaves
exactly
the
same
way
as
the
previous
methods
and
it
returns
see
you
interview,
unsigned,
int
or
and
saya
unsigned
long.
Then.
Finally,
there's
the
esoteric,
you
know
intentionally
long
name
called.
We
read,
see
board
Nega,
negative
integer
encoding,
which
explicitly
decodes
major
type,
one
negative
and
codings,
and
it
complements
the
deal
method
that
exists
in
the
writer.
E
D
E
D
A
Mean
I
think
everything
escape
head
should
only
make
sense
for
these
kind
of
api's
and
I
think
you
succeeded
already
having
a
long
name,
which
is
already
like.
Okay,
you
have
to
read
the
docs
right
like
this
is
not
the
casual
API
that
does
what
you
think
it
does
so
I
guess
I
can
live
with
and
without
encoding
like
even
if
you
drop
encoding,
the
bird
is
still
sufficiently
long
to.
D
B
D
Yeah
I
mean
what
well
so,
if
you
have
this
and
the
one
on
the
writer
this
sample
of
showing
how
to
deal
with
the
big
initrah
version
of
it,
like
you
read
this
and
now
here's
how
you
move
it
into
big
integer,
which
is
probably
just
big
enough
1
and
negative
1
negative
you're,
that's
value,
but
it's
still
like
what
do
you
do
with
it?
How
do
you
turn
it
into
a
number
that
you
can
make
sense
with,
given
that
it
almost
by
definition,
doesn't
belong.
A
D
I
mean
in
in
this
case,
I
think
I.
If
there
was
a
like
peak
next
value
or
peak
next
encoded
value
type
thing.
I
would
expect
that
for
this
one
it
would
return
on
the
average
case,
nine
bytes,
which
would
be
the
initial
bite
saying
it
had
eight
bytes
to
go,
and
it
was
a
negative
number
and
here
the
eight
content
bytes
associated
with
it.
B
If
you
got
those
bytes
and
you
read
them
as
a
big
big
endian
long
representation,
you'd
still
need
to
once
you
parse
that
you'd
still
make
need
to
make
the
transformation
minus
one
minus
the
integer,
so
right,
I,
think
fundamentally,
people
would
like
people
in
this
situation
would
need
that
number
it
you
know
regardless.
So.
D
D
D
D
A
B
A
B
Then
there's
an
equivalent
method
for
writing
the
data
into
a
buffer
that
you
own.
Following
back
the
standard
shapes
again
exactly
the
same
semantics.
If
it
encounters
an
indefinite
length
string,
it
will
write
the
concatenated
byte
array
string
into
your
buffer.
But
if
actually
you
wanted
to
just
treat
an
indefinite
length
string
as
an
array
of
definite
length
length
strings,
then
there
exists
a
couple
of
methods
called
read,
start
byte
string
and
read
with
n
byte
string
and
where
you
can
actually
consume
the
individual
chunks
of
the
indefinite
length
string.
B
B
D
A
A
D
Right,
so
the
absolute
upper
bound
for
irate
byte
string
is
going
to
be
the
total
number
of
bytes
left
in
the
payload,
because
it
could
be
there
minus
one.
It
could
be
that
it's
everything
after
the
first
byte
is
this
one
byte
string,
that's
the
so
that's
the
upper
bound.
The
expected
value
can
be
anywhere
between
zero
and
that,
and
so,
unless
we
add
a
method
that
lets
you
ask
ahead
of
time.
How
big
would
it
be?
D
D
D
D
Here's
the
span
or
the
memory
or
whatever
of
this
is
exactly
the
stuff
I
found
you
get
a
zero
copy
thing
to
deal
with,
and
now
it's
yours,
which
would
make
a
lot
more
sense
for
using
the
read,
start,
byte
string
and
read
in
byte
string,
because
then
you
get
the
segment's
yourselves
to
copy.
As
you
see
fit,.
B
D
Wouldn't
there
cuz
the
rules,
are
you
have
to
you
can't
split
between
a
multibyte
character
in
the
segments?
So
all
the
read
only
span
of
bytes
of
utf-8
data
would
be
semantics
or
you
can
even
make
it
read-only
span.
I
guess
you
could
couldn't
make
read
only
span
of
char
cause,
you're
gonna
have
to
decode
it,
but
but
it
could
return
a
read
only
span
or
read
only
bite
of.
D
Encoded
bytes
yeah,
so
what
I
have
on
an
ASN
reader
just
for
comparison
is
like
try,
read
primitive,
octet
string,
which
only
works
if
it's
the
primitive,
which
is
closest
to
definite
in
in
this
case,
and
then
that
outs,
the
contents,
but
in
in
my
world
it's
generally
someone's
more
likely
to
know
that
they
have.
They
expect
an
octet
string
here
and
like
whether
it
was
going
to
be
definite
or
not
is
hard
to
tell
I
mean
they
can
look
of
the
data's
there.
So
it's
a
question
of
in
C
boring
coded
things.
D
If
the
spec
says
there's
a
byte
string
here,
and
so
someone
was
going
to
write
blind
code
without
doing
the
peek.
So
that's
why
I
have
the
try
of
all
that
it
says
in
the
in
the
data.
Language
is
there's
a
there's,
an
octet
string
here
and
it's
up
to
the
writer
if
they
encoded
it
indefinite
or
or
in
my
case,
permit
ever
constructed.
Would.
D
D
If
people
complained,
I've
I
was
just
looking
through
a
bunch
of
places
where
I
used
a
s,
and
reader
and
I
was
looking
for
all
of
the
segments
that
I
call
a
try
method
and
then
in
the
false
block,
have
debug
not
fail,
and
so
it's
one
of
those
like
maybe
I,
should
have
just
had
read
primitive
octet
string
as
a
do
this
or
throw,
and
so
a
similar
logic
applies
here
for
both
either
having
the
true
we're
not
having
the
true
sorry
try.
A
It
seems
to
me
like
in
file
formats.
You
generally
want
to
throwing
API,
because
either
you
have
a
generic,
a
pattern
where
you
can
just
understand.
What's
next,
which
is
basically
what
peak
state
will
do
and
then
the
rest
is
just
all
unreachable
state
effectively
right.
If
you
know
that
you
expect
conformant
well,.
D
The
I
mean
the
question
is:
when
would
you
know
that
you
have
to
see
a
definite
encoded,
byte
string,
in
my
case,
it's
if
you're
in
der
mode
I
think
here,
if
you're
in
C
tap
to
canonical
right,
you
know
it's
never
going
to
be
an
indefinite
byte
string,
and
so
you
could
just
straight
call
the
throw
if
this
is
not
right,
because
it
was
gonna.
Throw
anyway
give
me
the
next
definite
encoded,
byte
string,
but.
D
A
A
D
A
B
A
D
A
A
A
D
A
D
D
D
A
D
Yeah
so
now
the
question
would
be
for
this
thing
is
that
in
fix
or
suffix
with
with
ASN
I
couldn't
like
read,
octet
string,
primitive
kind
of
would
have
worked,
but
it
felt
weird
so
I
put
the
primitive
in
your
case
definite,
but
as
a
preface
so
I
guess
an
index.
So
it
read
definite
byte
string
returning
a
read-only
memory,
a
byte.
D
D
A
B
D
D
D
A
Honestly,
I
would
probably
not
have
a
try,
I
would
probably
just
say,
read
definite
bison,
because
all
the
Troy,
like
you,
think
the
only
tries
here
that
makes
sense.
There
are
things
where
you
have
buffers.
Everything
else
is
a
fall
in
violation.
You
shouldn't
have
called
the
API
to
begin
with.
Would.
B
A
B
D
D
Language
is
the
next
vet,
like
the
next
value
you
will
read,
is
I'll
use
a
s
in
terms
an
octet
string,
but
depending
on
the
particular
encoding
semantics
that
you're
going
with
that,
octet
string
can
be
constructed,
which
is
the
same
as
indefinite
here
or
or
a
primitive,
which
is
the
same
as
definite
here
and
either
of
them
is
legal
in
context.
So,
if
you
were
just
writing
a
flat
call
and
you're
like
I,
don't
care
just
give
me
the
thing
then,
like
it
says,
there's
an
octet
string.
D
Give
me
an
octet
string
and
and
I
know
that
that
maps
to
a
bite
or
a
net
so
be
a
byte
array,
and
so
that's
what
I
went
for
in
the
ASN
reader,
which
is
the
simplest
operation
just
matching
the
DDL.
Is
that
read
a
byte
string
return
it
as
an
array,
understanding
the
what
the
encoder
chose
to
do
a
visit,
primitive,
constructed,
definite
indefinite.
Whatever
is
up
to
the
reader,
and
the
reader
has
to
deal
with
that
problem
right.
B
D
A
D
A
D
D
If
we
wanted
to
bring
read
only
segment
into
the
world
there
into
this
universe,
then
we
could.
We
could
have
read
byte
string,
that
returns
read
only
segment
and
then
that
has
dot
array.
If
you
wanted
to
do
that,
but
that's
less
friendly
and
I
don't
know
that
it
really
matters
to
most
people.
Yeah
I
I
feel.
B
A
A
A
B
D
B
D
D
Because
so
there's
there's
two
different
approaches
that
you
could
do
for
indefinite.
One
is
read,
start,
read,
end
and
read
definite.
So
then
you
say:
oh
I,
except
this
is
an
indefinite
encoding
read
start
and
then,
while
the
state
is
not
into
byte
string,
read
definite
or
while
the
state
is
read
is
a
definite
byte
string
called
read,
definite
and
then
you
get
all
the
individual
segments.
D
You
apply
on
all
the
segments,
the
way
that
you
need
to
and
and
you
move
on
or
you
could
have
something
that
returns
read
only
sequence,
which
gives
you
all
the
individual
pieces
in
one
shot.
And
then
you
don't
need
to
start
and
end
by
string
or
you
could
do
both
but
I.
Don't
know
that
both
really
matters
and
by
I,
don't
remember
where
read
only
segment
lives
in
our
layering
world
or
what
needs
we
might
have
for
this
later.
D
So
I
don't
know
if
it's
complicated
to
take
a
dependent
and
read
only
sequence
here
and
it's
also
not
a
particularly
friendly
type,
and
so
it's
if
caring
about
the
indefinite
encoding
is
already
gonna,
be
rare
and
then
fine
I
think
that
probably
the
most
common
thing
that
people
would
do
in
general
is
they're.
Gonna
call
the
byte
array
allocating
read
byte
string
right.
A
That's
why
I
kind
of
like
the
approach
to
say
the
only
API
is
believe,
is
read:
byte
string,
we'd
start
by
string,
read
end
byte
string
and
then
we
add,
read
definite
byte
string
right
and
this
way
you
can
say,
if
you
don't
care,
you
just
call
read
byte
string.
It
might
allocate
right
all
right,
well,
I,
locate
for
sure
no
matter
which
party
going
to
and
then
the
other
one
is
like
yeah.
A
If
you,
if
you
want
to
get
the
definite
one,
then,
if
you're
standing
on
one
already,
then
just
call
me
definite
byte
string
and
if
you
are
standing
on
a
weight
on
and
it
on
an
indefinite
one,
then
you
have
to
walk
it
with
we'd
start
by
string
and
we
definitely
byte
string
and
we'd
end
byte
string.
But
then
you
basically
can
always
have
a
non
allocating
walk
over
there.
The
the
byte
strings
right,
yeah.
D
D
B
A
B
A
B
I
mean
you'll
be
glad
to
know
that
major
type
3
has
essentially
the
same
shape,
but
it
only
deals
with
utf-8
strings.
So
you
have
again
the
allocated
allocating
variant
called
read
text
string,
which
just
returns
a
string,
I
removed
the
comment
here,
but
it
will
additionally
format
exception.
If
the
underlying
encoding
is
not
valid
in
a
faith
there's
the
again
the
behavior
here
is
concatenating
has
defined
in
major
type
2.
So
if
you
have
an
indefinite
length
text
string,
it
will
concatenate
all
the
chunks
into
a
single
string.
B
Try
read
text
ring,
behaves
like
try,
replied
string.
So
again
it
will
copy
the
characters
to
the
buffer
that
you
provided.
If
it
is
an
indefinite
length
string,
it
will
concatenate
the
results,
well,
write
them
in
sequence.
Rather,
and
then
you
have
the
read,
start
text
string
and
read
and
texturing
methods
again,
if
you
want
to
sort
of
manually,
walk
through
the
individual
chunks
of
the
indefinite
length
text
string,
so.
A
D
D
A
D
D
D
D
A
A
A
So
neck
has
reusing
the
utf-8
suffix
here
would
make
sense
to
to
say
we
definitely
extra
utf-8
and
it
gives
you
a
read-only
memory
of
pile
right.
I
mean
it's
a
bit
unfortunate,
but
we
don't
have
I
think
an
on
allocating
version
of
we
don't
list
of
duty
weights
doing
anyway.
Why
did
fall?
It
remains
to
be
you
some
version
of
it.
Only
memory
may
be
right.
A
D
C
A
But
I
guess
that
that's
fine
but
I,
think
the
question.
Is
you
constructed
the
string
at
that
point
right,
and
so
you
are,
of
course,
the
person
that
it
up
then
but
like
if
you
get
it
from
something
else.
That
already
is
processing
some
sort
of
format.
Then
the
question
is:
what's
the
expectation
for
the
return,
types
and
I
think
if
we
say
we
give
you
utf-8
encoded
string,
then
the
better
way
utf-8
encoded
right
right.
D
D
D
It
breaks
at
code
point
boundaries.
So
if,
if
something
is
a
is
a
code
point
that
turns
into
three
bytes
in
utf-8,
they
can't
be
in
different
segments.
They
have
to
all
be
in
the
same
segment.
So
it's
it
does
have
some
sort
of
the
spec
says,
there's
a
little
bit
more
structure
here
then
then
this
is
just
the
the
byte
arrays
chunk.
However,
we
feel
like
it
and
tagged
as
three
instead
of
two
so.
C
E
D
E
E
D
D
So
I'm,
but
I
like
the
question
here
I
think
really
determines
what
sort
of
suffix
it
gets
right.
If
we
say
if
we
say
utf-8
as
the
suffix
I
think,
the
onus
is
on
us
to
make
sure
it's
legal.
If
we
say
raw,
then
maybe
that
is
ask
a
patch
of
a
non-conforming
document
that
that
didn't
meet
the
rules
of
indefinite
encoding
with
proper
segmentation.
If
we
say
bytes
I
think
we're
allowed
to
be
flexible
on
what
we
do.
D
D
D
B
A
A
A
A
E
D
Well
because
I
think
see
tap
to
canonical
says
you
can't
have
an
indefinite
length
string.
So
none
of
this
even
really
matters
to
you.
A
D
A
D
Instead
of
the
replacement
char
of
you
see
a
the
first
byte
that
identifies
itself
as
I'm
a
three
bite
encoding,
and
then
it's
immediately
followed
by
I'm
a
three
bite
encoding
instead
of
the
two
further
content
bytes,
instead
of
replacement
char
you
get,
this
is
this
is
broken
bozo
and,
and
it
throws
an
exception.
These.
A
B
Okay,
so
here
you
have
two
methods,
one
for
pushing
the
array
context
and
one
for
popping
the
array
context.
The
return
type
is
malleable
in
these
we'd
start
array
method.
The
return
type
is
an
allowable
integer
and,
as
you
would
expect,
if
it
is
inhabited,
it
denotes
that
the
array
is
of
definite
length
and
if
it's
no,
then
it
is
in
different
lengths
and
you
have
to
while
loop
while
peeking
the
exceptions
that
might
get
thrown
here
are
exactly
the
same
as
all
the
other
read
methods.
B
Similarly,
read
and
array
is
just
a
method
that
pops
the
array
context
yeah
that's
about.
It
makes
little
sense
to
me.
Yeah
I,
guess
Maps
is
the
same.
Maps
is
exactly
the
same
again.
You
know
making
the
point
that
you
made
in
during
last
week.
Emo.
The
return
value
here
denotes
the
size
of
the
team
map,
which
is
the
number
of
key
value
pairs
rather
than
the
total
number
of
data
items.
Within
this
context,.
B
Okay,
so
then
major
types,
six,
which
is
basically
tag,
data
items,
our
quick
reminder:
a
tag
is
a
data
item
that
encapsulate
s',
another
C
ball
value,
and
it
is
essentially
used
to
assign
meaning
to
the
encapsulated
value.
So
a
string
tag
with
the
num
0
denotes
a
daytime
string
or
an
integer
attacked
with
the
number
1
is
a
unix
time
string,
etc.
B
So
you
so
first
of
all,
this
block
defines
the
basic
methods
for
reading
the
next
tag
and
doing
nothing
else.
So
read
tag
returns,
a
seaboard
tag,
a
num
behaves
exactly
the
same
way
as
the
other
made
methods,
and
then
interestingly,
I've
also
exposed
a
peek
tag,
method
that
again
returns
the
same
tag
without
advancing
the
reader
state.
Now,
the
reason
why
I
did
this
is
typically
when
you
read
semantically
tagged
values,
those
readers
would
need
to
consume
the
tag
as
well.
B
Then
then,
the
remaining
read
methods
implement
particular
semantics,
attica
and
coatings,
as
defined
in
the
CBO
spec.
You
have
read
a
time
offset
which
reads:
datum,
strings,
there's,
read
unix
time
seconds
which
again
returns
a
daytime
offset,
there's
big
integer,
which
returns
big
integer,
it's
the
known
as
the
big
numb
and
coding
in
the
super
spec
and
finally
read
the
small,
which
is
the
decimal
which
reads
the
Seaboard.
This
mole
fraction
encoding
and.
B
B
B
A
I
didn't
mean
like,
in
terms
of
you
know
what
happens
at
runtime
is
saying
semantically
right,
though
then
developers
think
of
like
decimal
or
you
end
or
in
this
kind
of
primitive
types
right.
So
like
basically,
my
question
is:
how
does
somebody
know
that,
when
I
call
with
decimal
that
I'm
supposed
to
stand
on
a
tag,
that's
not
a
see
what
I'm
gonna
try
to
get
at
this?
It
seems
you
have
some
ap.
A
D
Maybe
so
the
the
difference
is
integer
types
are
defined
in
C
bore
as
primitives
and
decimal
is
defined
in
C
bore
as
interpreted
and
so
right.
If
you
were
looking
at
something
that
said,
there's
a
Seaboard
decimal
here,
then
the
encoding
would
say
that
it
has
to
be
tagged,
because
that's
the
only
way,
time
that
Seaborg
understands
a
decimal
is,
I'm
writing
some
stuff
down
hey
by
the
way.
This
represents
a
decimal
value
right.
D
D
We
could
put
tagged
in
all
of
these
Reid
methods.
I
mean
not
read,
tag
tag.
Well,
technically,
you
can't
read
a
tag
tag,
but
the
if
we
want
to
say
it's
read,
tagged
DTO,
read
tagged.
You
next
time
read
tag
to
begin
adjourn,
read
tag
decimal
because
you
think
it
conveys
more
information
than
that
I.
Don't.
B
A
D
B
D
B
You
don't
know
what
the
schema
is,
but
if
you
know
what
the
schema
is,
you
can
skip
those
two
steps
yeah,
but
I
think
that
the
point
here
is
that
in
the
equivalent
write
methods,
the
tag
will
be
written
for
you
so
like.
If
you
call
the
right
the
right
big
into
integer
method
on
the
writer,
then
it
will
prepend
the
appropriate
tag.
You
know
per
the
Seaboard
spec
I.
A
B
D
Yeah,
so
I
don't
think
that
the
the
word
tagged
needs
to
really
be
here,
because
it's
there's
not
a
difference
between
a
tag
to
date/time
offset
and
an
on
tag
to
date/time
offset
the
it's
simply.
The
rules
of
C
bore
our
date/time
offset
is
tagged
or
you
presented
it
just
as
string,
and
you
tell
someone
by
the
way
at
runtime
interpret
this
string
as
a
our
fc7
d,
nope
RFC
whatever,
or
have
no.
C
B
Okay,
so
major
type,
seven
again,
nothing
too
interesting
here
reminder
major
tab.
Type.
Seven
can
be
broken
into
two
separate
kinds
of
values.
You
have
these
simple
values,
which
is
basically
just
a
single
8
bit
tag
used
to
encode,
among
other
things,
false,
true
and
null,
and
then
you
have
the
half
single
or
double
precision
floating
point
and
codings.
B
So,
to
begin
with,
there's
the
read
simple
value
method
that
just
returns
a
seaboard,
simple
value.
Enum
again
it
operates
as
you
would
expect.
If
it
encounters
a
different
major
type,
it
will
throw
an
invalid
operation
exception
if
it
encounters
a
floating-point
encoding,
which
is
all
the
same
major
type.
It
will
also
throw
with
the
same
exception.
B
Perhaps
a
thing
to
note
here
is
that
the
read
single
method
will
throw
an
invalid
operation
exception.
If
you're
trying
to
read
a
double
precision
float,
the
opposite
doesn't
hold
like.
If
you
do
a
read
double
and
you
encounter
a
single
or
a
half
precision,
it
will
encode
those
appropriately
sorry
decode.
Those
now.
C
D
D
A
D
B
B
So
this
set
of
methods
basically
provides
some
essential
functionality
needed
to
just
skip
data
items
that
you
don't
care
about.
So
calling
skip
value
will
just
skip
the
data
item
and
all
its
contents
and
move
on
to
the
next
one.
If
there
is
one
and
by
default
it
will
throw
any
appropriate
format,
exceptions
pertaining
to
either
well
for
for
madness
or
the
Seaboard
document,
or
conformance
mode
validation,
not
succeeding.
The
first
method
does
precisely
that,
so
it
skips
the
next
data
item.
D
A
B
I
I
feel
that
this
method
is
kind
of
controversial
and
I,
wouldn't
mind
if
we
decided
to
completely
drop
it.
The
reason
why
I
added
it
is
because
it
comes
for
free
when
you
implement
skip
value.
What
it
does
essentially
is
assuming
that
you
are
in
a
context
where
you've
encountered
invalid
data.
It
skips
the
remainder,
the
remaining
data
items
in
the
current
context
and
pops
that
context
for
you
right.
A
B
D
B
B
D
B
A
Mean
yeah
I
mean
to
me
it's
like,
maybe
it's
just
me,
but
like
I
I,
think
intuitively
understood
what
it
meant.
So
that's
seems
good
enough.
I
mean
I
I'm
generally
a
live
video
skip
value
because
the
basically
means,
if
you
have
invalid
documents,
because
one
of
your
you
know
people
you
exchange
data
with
happens
to
have
an
implementation.
That
is
not
strictly
correct,
but
you
know
it's
only
not
correct.
In
one
area
you
can
basically
still
say
I
validate
anything
and
then
I
just
keep
the
one
thing
that
I
know
is
not
correct.
B
Yeah
I
mean
definitely
for
script.
Value
III
think
another
remark
I
could
make
here
is
that
the
two
methods
can
actually
be
generalized
to
a
single
method
that
accepts
a
height
parameter.
So
basically
it
tells
you
how
many
levels
you
want
to
skip,
but
I
find
that
even
more
difficult
to
communicate
to
users.
A
D
Changing
changing
state
feels
very
weird
because,
depending
on
your
level
of
paranoia
and
I,
think
Mary
and
I
are
both
very
paranoid.
At
the
moment,
you
pass
it
into
a
method
you're
getting
immediately
going
to
need
to
say
I
need
you
to
go
back
into
strict
mode,
so
it
if
it
is
for
a
single
function.
Only
that
seems
fine,
but
for
changing
the
mode
out
of
what
you
built
it
in
the
constructor
seems
inappropriate.
D
E
D
D
D
So
yeah
add
the
defaulted,
disable
conformance
mode
checks
to
read
and
coded
value,
and
then
now
you
can
say
fine.
This
didn't
work
under
C
tap
too,
but
this
particular
thing
that
I'm
doing
is
important
enough.
That
I'm
going
to
try
reading
this
one
segment
using
just
strict
and
see
if
I
can
get
the
data
I
want
out
of
it
and
then
move
on.
D
D
D
Yeah
I
can
go
either
way.
It's
not
a
complicated
loop
for
someone
to
write,
I
think
skip
to
ancestor
which
we've
discussed
but
I'll.
Let
everyone
else
know
I
think
it
had
too
many
fail
modes
of
you
passed
in
a
number
bigger
than
your
depth
versus
you're
in
a
state
and
so
skip
to
skip
to
parent
made
more
sense
to
me
than
skip
to
ancestor
or
skip
with
a
count
and
or
skip
up
with
a
counter
any
other
variant
of
that.
D
B
B
B
B
A
B
A
Right
because
it's
it's
a
it's
an
expression
of
intent
right
and
then
we
have
notes
that
tell
you
what
we
want
to
do
with
that.
I
think!
That's
good
enough,
like
I,
mean
I,
see
video
in
specs,
but
at
the
same
time,
I'm
also
not
like
and
all
to
say
this
nicely,
but
I'm
not
like
a
paper
pusher
either
right,
like
I,
want
to
I
want
to
have
a
process
that
is
reasonable,
but
also
very
but.
A
B
A
So
well,
I
just
updated
this
one
for
round
two,
and
so
this
one
will
say
approved
and
then
we
will
have
video
link
here.
This
will
sing
round
one
and
there's
a
round
two,
but
the
other
feedback
and
that's
the
same
thing
right
I
mean
when
we
approve
issues.
We
don't
update
the
issue
description
either
right,
we
just
say
here's
here's
our
feedback
and
then
we
just
mark
the
issue
as
approved
and
an
issue
gets
closed
right,
we're
not
going
back
and
edit
the
descriptions
either.