►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
B
B
In
other
scenarios,
like
CAD
programs,
where
single
precision
floats
might
not
provide
the
precision
required
and
where
you
may
want
to
be
using
double
instead
or
for
other
scenarios
where
you
may
want
similar,
but
in
alternative
positions
such
as
half
or
potentially
even
integral
types
which
we've
had
requests
for
as
well
and
which
some
other
math
libraries
provide
support
for.
So
the
proposal
is
essentially,
we
take
the
existing
types
that
we
have
and
we
expose
new
variants
of
them
that
are
generic.
B
This
will
help
ensure
we
don't
have
a
type
explosion,
as
we
potentially
look
to
support
more
types
in
the
future.
Today's
proposal
is
only
going
over
supporting
having
that
generic
implementation
support
float
in
double,
but
given
that
it
is
generic,
we
would
be
able
to
extend
it
in
the
future
to
support
other
types
without
needing
to
explode.
The
number
of
types
we've
exposed
and
without
necessarily
needing
to
do
more
in
depth,
API
review
about
what
we
are
exposing.
B
B
Potentially,
but
for
some
for
some
things,
it
doesn't
necessarily
make
sense
for
any
numeric
type,
because
you
may
need
specialized
behavior
to
do
the
computation
or
to
handle
the
intermediates
for
simple
numeric
types
like
adding.
That
certainly
makes
sense.
But
for
other
things,
like
the
length
of
a
vector,
you
may
need
specialized
behavior
to
correctly
handle
the
the
truncated,
floating-point
or
fractional
part
of
the
result.
B
The
idea
would
be
that
these
likewise
get
hardware
acceleration
support
where
possible,
for
example,
with
double
you
can
still
use
sim
D
intrinsics
to
support
them.
I,
don't
know
if
implementing
it
directly
in
the
JIT
is
a
good
idea.
I
think
this
might
be
a
good
place
to
use
the
the
actual
hardware
intrinsic
since
10,
so
we
don't
have
to
explode
the
JIT
with
support
for
additional
types
here.
E
F
They
would
be
considered
intrinsic
in
the
same
way
that
the
the
you
know
the
non
hardware
intrinsic
Sindhi
intrinsics
are,
which
is
to
say
they.
They
don't
necessarily
have
direct
acceleration,
but
you
know
they
be
recognized
and
accelerated
where
possible
and
doing
that.
The
way
Tanner
has
started
to
do
with
with
this
empty
type
with
the
existing
sim
d-types
makes
a
lot
of
sense.
A
F
Right
and
currently
for
vector
of
tu
when
it
when
you
try
to
instantiate
it
over
an
unsupported
table.
It
just
throws
so
there's
there's
the
supported
in
hardware
and
you
get
you
know,
ideal
JIT,
acceleration
and
there's
those
that
need
to
have
some
sort
of
backup
implementation
and
then
there's
those
where
we
say
I'm.
Sorry,
you
can't
use
that
type.
Sadly,
we
don't
have,
you
know,
static
interface
constraints
now,
so
we
can't
stay,
you
know,
must
implement
I
an
attack
or
anything.
A
Right
I
mean
yeah
that
to
me
kind
of
echoes
what
I
was
feeling
because
I
mean
to
me.
The
the
vector
of
teeth
of
a
phobic
was
not
exactly
super
useful
to
people
right
because
the
performance
just
degraded
so
so
much
that
before
they
would
have
been
better
off
just
throwing
in
this
case,
and
so
my
concern
generally
is
when
you
make
something
more
generic,
then
you
know.
Unless
we
really
know
that
we
don't
regress
many
things,
it
seems
not
necessarily
a
helpful
thing
to
do
so.
F
So
you're
suggesting
that
if
it
was
not
directly
supported
by
hardware,
you
wouldn't
even
emulate
it
I
mean
I
would
I
would
say.
This
is
actually
quite
different
than
vector
of
T
vector
of
T
had
the
problem
that
it
was
difficult
to
emulate
because
it
was
dynamically
typed
at
runtime,
I,
don't
think
vector,
2
3,
&
4
ever
had
that
same
kind
of
issue.
You
didn't
get
a
you
know,
that's
substantial
penalty!
F
A
F
B
Well,
that
could
also,
in
this
case,
be
trivially
handled
with
a
so
something
that
we
have
on
vector
of
T,
that
we
don't
have
on
vector.
2
3
&
4
today
is
in
is
hardware-accelerated
property
right,
which
would
help
annotate,
for
example,
on
arm
32.
This
isn't
were
accelerated,
but
on
arm
64
and
x64
and
x86.
It
is
right.
D
B
A
That's
a
broad
bar
because
that
step
will
be
better
than
vector
of
T
right
away.
If
you,
if
you
vectorize
your
Cobra
vector
of
T,
without
having
hardware
support,
it
will
run
significantly
slower
than
what
a
naive
version
would
have
been
and
I.
Think
that's
probably
the
biggest
problem
with
vector
of
T
I
mean
slower
is
never
nice,
but
if
you're
slower
in
the
direction
where
you
want
it
to
be
3x,
faster
or
2x
fast
and
now
you're,
like
4x
slower,
that's
pretty
bad,
so
I
think
it
could
I.
A
Think
I
would
agree
with
that
and
just
to
clarify
like
when
I
said,
generic
I
didn't
mean
the
T
part.
I
meant
the
iPhone
metal
part,
sorry
not
I,
for
Matt
about
the
I
arithmetic
or
whatever.
The
thing
is
maybe
say
like:
oh,
we
support
em
any
any
numeric
type,
but
that
that
is
the
thing
that
I
can
see
being
not
super
fast.
Unless
we
have
support
for
this
natively
right
versus
vector
of
biood
versus
vector
of
int,
for
example,
right.
D
A
I
mean
it
shouldn't
block
us
right,
I
mean
I,
get
me
to
say
today.
You
can
only
I
mean
the
question
is
what
behavior
do
we
give
you
when
we,
you
use
something
like
a
custom,
struct
or
vector
of
to
do
we
allow
that
or
do
we
just
throw
if
we
throw
some
of
the
vector
of
TV,
we
say
yep,
you
can
only
pass
in
the
numeric
based
types.
Then
it's
for
us
relatively
easy
to
open
up
that
constrain
to
something
more
generalizable
with
an
eye
arithmetic
that
seems
fine.
G
A
G
Well,
if
we
added
a
new
constraint-
and
somebody
was
already
passing
in
some
like
they
said-
new
vector
of
some
type-
that
was
equatable
and
formattable
I-
guess
sorry,
the
T
isn't
actually
constraint.
They
said
new
vector2
of
string,
right,
that'll,
compile
and
that'll
run.
The
thing
it'll
do
is
throw
out
of
the
constructor
the
and
then,
if
we
added
the
I
arithmetic
Abul,
then
they
would
now
start
getting
a
compile
error.
But
that's
fine,
because
the
type
wasn't
gonna
work
anyway.
Yeah.
A
I
mean
that
to
me
is
the
is
the
least
interesting
scenario,
but
it's
more
just
thing
to
say:
I've,
a
generic
method
today
that
takes
a
K
and
then
I
instantiate,
vector
of
T
of
that
K
if
I
only
happen
to
use.
You
know
this
types
that
vector
of
two
supports
for
my
K.
That
code
will
even
work
today
right
and
that
would
be
that's.
What
would
be
the
code
would
regress.
We
wouldn't
all
say:
okay
now,
UK
has
to
be
constrained
to
our
arithmetic,
so
that
would
be
the
actual
breaking
change.
Yes,.
A
Seems
unfortunate,
but
I
would
agree
with
you
that
it
seems
more
beneficial
for
us
to
do
that
if
we
believe
in
our
you
know,
assuming
we
believe
my
arithmetic
right,
if
we,
if
you
don't
believe
I
rhythm,
think,
is
super
useful,
then
yeah,
we
wouldn't
do
that.
But
if
you
believe
I
this
is
a
super
useful
thing
and
we
can
generalize
a
bunch
of
stuff
with
it.
Then
I
think
we
probably
take
that
and
say
yep
tough
luck,
I
mean
the
question.
How
many
people
will
like
generic
code
over
that
right?
B
B
B
This
one
actually
has
the
t
struct
constraint
as
it's
supposed
to
so
so.
The
first
important
detail
is
something
that
the
where
this
proposal
differs
from
vector
of
two
vector
two
and
all
the
other
types
currently
expose
the
X,
Y,
Z,
W
and
other
members
as
public
fields
I
am
proposing.
We
don't
expose
them
as
public
fields,
because
that
hinders
optimizations
and
other
things
that
we
can
do
to
improve
the
code
in
the
future.
A
B
So,
with
a
normal
with
a
normal
struct,
you,
you
were
working
with
scalar
like
data,
so
when
you
mutate,
a
single
value,
you're
actually
going
to
be
mutating
it
in
place
generally
on
the
stack
or
somewhere
else,
but
with
a
sim
d-type.
These
actually
represent
a
single
register
on
the
CPU
most
of
the
time,
and
so
when
you
mutate
it,
it
behaves
much
like
other
primitive
types
in
that
it
mutates
the
entire
value
at
once.
So
if
you
set
X
what
you
get
back,
isn't
you
just
wrote
X
to
memory?
B
It's
you
modified
a
physical
register,
a
sub
part
of
a
physical
register
and
gotten
the
entire
register
back
as
the
result,
and
so
a
wither
is
more
close
to
how
you
should
actually
think
about
sim
D,
but
it's
not
necessarily
as
optimal
for
the
software
fallback
or
for
people
who
have
already
been
using
the
existing
vector
types.
I
see.
A
B
A
B
The
proposal
is,
we
support,
float
since
that's
already
what
supported
on
the
non
generic
version,
and
then
we
extend
that
to
support
double
because
that's
a
scenario
that
people
have
been
frequently
requesting
and
then
because
it's
generic
it
opens
the
opportunity
for
us
to
support
other
types
in
the
future
as
people
either
request
them
or
as
they
become
apparent,
that
we
should
provide
them.
Some
people
have
asked,
for
example,
int
in
you,
int,
which
would
be
frequent
for
use
with
certain
windowing
applications,
for
example,
where
they
don't
use,
float
and
double.
B
B
No,
they
would,
they
would
perform
exactly
the
same,
except
for
some
scenarios
where,
because
the
fields
are
publicly
exposed,
users
could,
for
example,
take
the
address
of
a
field
which
could
hinder
code
gen
or
do
other
things
to
the
fields
that
aren't
necessarily
a
sim
D
friendly
way
to
interact
with
it.
But.
A
B
There's
at
least
one
other
place
where
there's
a
suggested
break,
which
is
around
length,
which
is
a
method
today,
but
which
likely
should
have
been
a
property
and
then,
of
course,
there's
some
parameter
and
name
fixes
that
went
in
where
they
are
just
value
one
or
like
value.
One
and
value
two
today,
instead
of
left
and
right.
A
Right
yeah.
That
would
be
good
if
you
could
call
that
out,
because
that
seems
it
seems
like
the
scenario
that
you
want
to
support
as
people
being
able
to
move
from
vector,
2
to
vector
2
flow
right
or
vector
alright.
With
minimum
work,
I
mean
it's
clearly
an
API
breaking
change.
They
expose
their
vector
tools
today,
but
you
know
logically
at
least
that's
what
we
would
like
to
enable
cool.
Then
how
do
you
want
to
do
this?
A
B
I
think
that
would
be
fine
and
I've
commented
all
the
differences
here.
So
the
first
difference
is:
we
actually
expose
a
copy
to
method
that
takes
an
array
today
and
for
a
vector
of
T.
We
exposed
span
equivalents
and
we
have
constructors
that
take
it.
So
the
first
changes
expose
constructors
that
take
the
array
and
take
the
span
since
they
don't
exist
today,
but
they
likely
should
and.
B
G
A
Mean
one
question
that
you
should
ask
ourselves
like:
modulo
the
the
breaking
changes
in
the
sense
where
you
you
know,
move
to
future
property,
should
we
add
them
to
vector
two
so
that
if
you
could
also
move
from
vector
to
flow
to
vector
two
or
do
we
believe,
that's
in
one
scenario
go
in
the
other
direction.
I
think.
B
A
B
A
Forward
I
mean
we
could
to
say:
okay,
vector,
flowed
or
vector
to
float
is
the
replacement.
So
if
you
do
that,
then
we
would
effectively
deprecated
the
old
once
and
then
maybe
even
have
a
code
fixer
that
replaces
usages
right
and
then
just
say
yes
or
you
took
an
address
of
a
field
too
bad.
You
can't
do
that
within
your
thing,
but
if
the,
if
they
effectively
behaved
the
same,
then
why
would
you
do
that
and
I?
A
B
The
the
next
difference
here
is,
we
have
negate,
but
we
don't
have
the
inverse
of
negate,
which
is
Plus,
which
is
essentially
the
identity.
Operation.
I
put
it
here
just
because
it
seems
like
we
should
have
it
for
parity
and
the
it's
the
only
place
where
the
compiler
actually
doesn't
require
you
to
have
the
inverse
for
parity
I.
G
B
I
A
No
but
I
think
I
get
to
a
nice
point
right.
If
you,
if
you
write
math
code
it
sometimes
it's
nice,
if
you
can
just
put
them
in
the
same
spot,
and
you
know
you
have
two
lines
to
each
other
and
then
it
makes
sense
right.
I
mean
I
would
hope
that
our
code
gen
is
smart
enough
to
not
make
that
expensive.
I
would
hope
that
we
just
make
this
a
no
op
I
mean.
G
A
A
G
J
B
A
B
A
I
mean
like
we
should
ostrich
it
folks,
but
my
personal
take
is
like,
unless
somebody
can
prove
to
me
that
this
makes
code
worse,
I
think
I'm.
Fine
with
that
I
mean
it
makes
sense
from
went
from
an
editing
standpoint
when
you
align
code
it
makes
sense
of
consistency
argument.
You
can
do
it
on
the
primitive
times,
but
I
wouldn't
be
able
to
do
it
on
the
vector
T
type
I
mean
unless
there's
a
penalty.
B
If
you
want
to
scroll
down
mo
the
rest
of
these,
are
the
exact
same
as
on
the
existing
vector
to
type
that's
on
the
screen.
Now,
there's
a
comment
here
on
transform
vector
to
position
by
a
quaternion
rotation,
most
other
math
libraries
name,
this
rotate,
rather
than
transform,
specifically
when
it's
being
done
by
a
quaternion
I'm
fine
with
keeping
the
existing
name,
though
Frank
for
compatibility,
I.
B
A
G
G
B
And
then
the
only
other
two
remaining
bits
on
this
is
a
copy
to
that
takes
an
array,
and
that
takes
an
array.
Plus
index
already
exists
on
vector
2.
There
is
known
for
copy
to
span,
so
that
was
added
and
then
for
length
and
length,
squared
in
particular,
vector
to
have
them
as
methods
today.
However,
their
implementation
on
Hardware
on
all
hardware
that
exists
within
the
past
twelve
years
is
approximately
four
instructions,
sometimes
is
fuse
one
instruction,
and
so
realistically
this
should
have
been
a
property,
not
a
method.
A
B
B
A
B
A
A
I
agree
that
I'm
just
asking,
because
you
were
more
of
a
domain
expert
here,
but
they
if
we
believe
that
we
want
to
align
the
type
so
it's
easier
to
move
between
them.
Then
you
know
that
seems
like
an
almost
like
a
you
know
to
the
naming
thing
like
an
arbitrary
change
right
versus
the
field
1,
we
just
said:
well,
we
really
up
the
design
at
the
time
we
shouldn't
have
made
them
fields
in
the
first
place
and
for
performance
reason
is
better
if
there
are
properties,
but
this
one
seems
more.
A
D
A
G
B
D
B
G
G
B
A
A
G
B
G
I
G
G
G
A
A
Also
seems
it's
kind
of
kind
of
the
opposite
direction
of
it.
We
would
like
to
go
by
arithmetic
right.
The
point
of
arithmetic
would
be
that
you
can
write
generic
:
right,
and
so,
if
you
exploded
now
like
you're
completely
screwed,
because
if
you
can't
do
anything
with
this
type,
I
mean
you
can
invoke
methods
on
it,
but
anything
that
involving
math.
You
would
be
blocked.
A
B
B
A
B
B
G
B
Was
to
explicitly
call
out
the
difference,
because
the
the
as
I
stated
they
start,
we
could
either
have
it
with
setters
or
with
withers
the
withers
weren't
explicitly
listed
here
and
naturally,
if
we
do
get
only
rather
than
with
a
set,
and
we
have
the
withers,
then
it
would
be
a
read-only
struct.
Instead,
it
was
basically
and
if
we
decide
the
property
should
be
mutable,
then
the
struct
would
be
mutable
and
therefore
these
have
to
be
explicitly
read-only.
But
if
we
decide
that
the
withers
are
actually
better,
then.
B
Modifying
a
value
modifying
a
vector
as
if
you're,
not
returning
the
entire
vector,
for
example,
there's
explicit
instructions
for
for
inserting
a
particular
element
of
a
semi
vector,
but
that
returns
the
entire
vector.
As
the
result,
it
returns
a
copy
with
the
with
the
one
value
modified.
So
it
is
functionally
a
wither.
G
G
B
B
Right
and
if
you
were
to
convert
the
downside
is
if
you're
converting
between
the
generic
and
non-generic
version,
then
you
have
to
translate
setting
the
field
to
using
wither
versus
just
setting
the
property,
but
like
I
was
saying,
setting
the
property.
Isn't
necessarily
the
correct
way
to
be
doing
that
when
thinking
about
this
in
terms
of
sim
decode
right.
A
B
G
Mean
for
devil's
advocate
the
objection
to
making
it
read-only,
as
you
do
lose
a
little
bit
of
the
ease
of
translation,
but
I
think
that
I
think
that
there's
justification
for
making
them
properties
and
once
we're
making
the
properties.
We
should
make
the
whole
structure
read-only
and
and
either
add
the
width
methods.
If
we
think
that
they're,
valuable
or
people
can
explode
it
into
the
constructor,
which
would
give
them
if
they
needed
to
modify
to
things,
that's
presumably
going
to
give
them
better
performance
than
calling
a
with
twice
it.
B
Depends,
in
particular,
the
the
whiff
methods
are
easier
to
optimize
for
the
case
where
you're
modifying
a
single
value,
which
is
more
likely
to
be
the
common
case
for
the
case,
where
you're
modifying
more
than
one
value,
the
constructor
would
have
to
do
some
analysis
to
determine
what
the
optimal
way
to
insert
those
additional
elements
were.
It
might
be
two
separate
inserts,
it
could
be
a
shuffle,
etc.
A
G
G
B
G
B
B
B
A
Yeah
I
guess
my
question
is
like
same
thing:
if
we,
if
we
expect
people,
if
we
don't
deprecated
plane
and
we
basically
say
plane
and
plane
floater
effectively
indistinguishable,
then
I
will
probably
not
do
that.
I
would
just
live
with
the
fact
that
we
of
the
name-
and
we
want
I-
mean
it's
not
great
but
like
it
seems
less
problematic.
D
A
G
It
like
the
the
one
of
transform
vs.
rotate
like
that
one
feels
like
it's
harder,
like
it's
a
little
harder
to
figure
out
why
the
method
that
you
were
looking
for
doesn't
exist
as
you
do
the
move
we
at
some
point.
We
made
a
decision
on
the
name
and
I
think
we're
sticking
with
it
in
the
type
hierarchy,
but
the
the
unless
planes
have
a
concept
called
D
which
I
don't
think
they
do.
G
A
G
A
B
B
The
own,
the
only
other
thing
for
plane
and
the
following
types
is
unlike
the
vector
types:
they
don't
implement.
I,
formattable
I,
don't
think
that's
something
we
necessarily
want
to
add
here
as
I'm,
not
quite
sure
what
it
means
to
format
a
plane
outside
of
allowing
custom
formatting
for
the
individual
components
of
the
plane.
We'd,
essentially
just
forward
it
down
to
the
underlying
T,
but
I,
don't
feel
particularly
strongly
about
I
just
wanted
to
call
it
out.
Yeah.
A
B
B
B
B
B
B
B
A
K
A
B
B
G
B
B
B
For
for
the
matrix
types,
the
one
thing
I
didn't
call
out
was
a
decomposed
and
invert
the
static
methods.
Here
they
return
a
bool,
so
they're
functionally
try
methods,
we
didn't
name
them.
Try
four,
but
I!
Guess,
given
the
compatibility,
we
don't
want
to
change
that
and
since
they'll
end
up
on
the
non-generic
class
first
non-generic
struct.
A
A
B
A
L
L
Yeah
I
guess
I'll
go
ahead
with
the
overheating.
So
if
you
scroll
down
to
the
bottom
of
the
issue
description
all
the
way,
there
is
the
original
proposal
that
Johnson
had
for
having
the
structured
log
viewer
just
a
little
bit
further
on
yeah
right
there.
So
basically
the
way
original
thorry.
At
the
moment
we
have
logging
setup.
L
Is
that
there's
two
options
on
the
console,
but
either
you
would
have
multiple
lines
per
log
message
or
a
single
line,
which
is
a
belief
for
like
containers
if
I'm,
not
if
I'm
not
mistaking
so
for
containers
and
such
there
needs
to
be
like
a
one
line,
log
message,
but
there
but
seems
like
now:
they're
nice,
like
there's
more
interest
to
have
better
customizability
for
logging,
and
therefore
there
were
two
requests
coming
up.
Is
that
one
to
also
enable
having
JSON
format
logs
printed?
L
Not
only
let's
say
if
we
right
now
have
multiple
lines
or
a
single
line
or
colored
or
whatnot,
and
additionally,
basically
making
it
more
customizable?
If
you
scroll
up
a
little
bit,
I
have
like
a
screenshot
of
yeah
right
in
the
middle
of
like
the
first
one
is
what
we
currently
have.
If
it's
multiple
lines,
it's
the
default
and
the
the
next
three
of
them,
like
the
one
that
says
default
when
its
not
multi
like
these,
but
the
next.
L
L
L
Like
for
the
last
last
of
the
four
like
blobs
is
like
an
exception
where
it
would
have
like
stack,
trace
message
and
whatnot
and
then
the
end
it
would
have
something
called
scopes,
and
but
this
is
this
is
a
little
overview
of
like
the
four
different
types
of
long
messages
that
could
be
there.
But
if
you
scroll
all
the
way
up,
I
tried
to
summarize
everything.
I'm
just
want
to
make
sure
I
didn't
miss
anything.
So
there's
four
items
up
there,
ABCD.
A
L
L
So
let's
say
they
don't
necessarily
they
may
want
to
have
JSON,
but
not
necessarily
those
with
the
way
it's
formatted
and
built-in,
so
to
have
that
cost
of
customizability
as
well
and
for
be
able
to
control
the
formatter
like
that.
Let's
say
if
you
want
to
have
cut
like
time
stamp
or
whatnot
via
the
configuration.
So
the
proposal
I
have
ads.
Api
is
in
order
to
satisfy
all
of
these
four
requirements,
and
the
usage
is
a
little
bit.
If
you
scroll
down
a
little
bit
below
it
would
show
how
the
usage
would
look
like.
L
L
J
L
J
So
one
pattern
unit
that
we
kind
of
do
is
we
we
normally
do
this
thing
around
stub
builders,
so
normally
you
can
do
add,
console
and
console
console
would
return
a
console
builder
that
you
could
do
console
specific
things
off
of.
But
since
that
thing
already
returns
the
top-level
builder,
we
can't
do
it
here
because
it's
a
breaking
change.
J
So
instead
we
have
to
have
a
different
top
level
API
to
configure
your
console
specific
sub
options,
which
is
a
little
bit
unfortunate,
but
to
avoid
it
breaking
change
kind
of
required.
Does
that
make
sense
so
like
so
so?
Normally
this
would
like
add
consul,
and
then
you
get
my
console
logger
builder
and
then
off
of
that
you
do
adjacent
console,
formatter
adblock,
because
you're
configuring
the
options
for
a
specific
provider.
J
So
it
kind
of
gives
you
a
nesting
where
you
say,
like
I'm
gonna
configure.
First,
the
loggia
Builder,
which
is
four
which
is
top
level
and
then
you
say,
add
console
which
brings
you
into
the
console.
Namespace
are
console-specific
options,
and
then
you
would
configure
things
for
the
console
in
this
model.
We're
just
adding
it
top
level,
because
we
can't
we
don't
want
to
break
the
API.
The
return
value
of
add
console
to
be
something
else.
Then
I
log
in
builder.
L
L
So
the
add
console
there
are
existing
ones,
but
then
those
like
five
six
line,
those
would
help
configure
figure
that
configure
which
of
the
lock
for
matters
built-in
ones
you
want,
or
line
15
and
16
is
add.
Console.Log
formatter
you
can
provide
your
custom
format
are
with
the
option,
so
the
t4,
minor
and
T
option
T
formatter
would
implement.
I
lock
I
console.log
for
matter
which
you'll
see
below
it's
a
new
interface
and
t
options
would
implement.
I
console.log
formatter
options.
Another
interview
so.
L
K
L
Know,
if
you
don't
want
ya
know,
if
you
don't
want
to
customize
the
options,
you
just
use,
add
console
you
pass
the
name,
but
if
you
want
to
fully
customize
give
that
you
could
let
let's
say
for
adjacent
with
the
the
for
JSON,
you
would
use
a
JSON
console.log
formatter
and
then
you
within
it
you're
configuring.
All
the
like
options.
Just.
C
Just
to
be
crystal
clear,
the
last
three
lines
the
add
default
at
Jason-
that
system
D
those
exist
purely
because
we
haven't
exposed
the
concrete
logging
types
for
default,
Jason
and
system
D,
because
if
we
had
exposed
those
that
you
would
just
call
add,
console
log
format
or
new
jason
log
formatter
right.
That.
J
No,
you
wouldn't
because
nothing
takes
arguments
that
are
passed
in
via
di,
so
so
here's
the
corruptor
a
bit
of
the
issue
with
YB.
I
don't
blows
instead
of
doing
it
wasn't
the
type.
The
type
has
a
bunch
of
arguments
that
come
from
the
ambient
like
environment
right
our
our
path.
In
from,
like
being
being
you,
don't
own
the
construction
of
those
types,
so
you're
saying
what
type
you
want
and
then
someone
else
will
create
it
on
your
behalf.
That's
that's
just
of
it.
I
did.
C
J
J
The
custom
ones
so
the
ad
council,
local
matter,
api's,
are
convenient
to
for
for
doing
what
like
adjacent
console,
does
right.
If
you
want
to
add
your
own
formatter,
you
just
new
clubs,
overload
I,
mean
we'll
add
the
right
goop
and
you
give
us
the
type,
and
we
will
do
the
same
things
that
the
default
ones
do.
The
Jason
sits
in
the
end
default
to
wire
it
out
to
make
it
work
well
and.
J
They
would
add
the
right
things
to
di
so
that
the
console
logger
can
resolve
it
and
it
would
give
you
a
way
to
specify
options,
for
example.
So
so
you
would
write
emails,
log
console
formatter,
it
would
implement
that
interface
and
then
you
would
take
him
and
email
options
and
the
T
options
not
today
options
and
then
the
user
would
call
I.
J
L
C
L
So
just
one
sector,
sir,
do
you,
okay,
so
I
actually
SR?
He
reminded
me
that
I
obviously
have
examples
there.
So
if
you
wanted
to
see,
if
you
go
back
to
the
other
tab,
scroll
all
the
way
back
up
because
I
have
this
like
how
you
use
the
usage
on
their
usage,
you
can
yeah.
So
there's
these
four.
If
you
want
to
add
an
extension
point
so
that
user
can
specify
their
own
custom
map
format,
this
is
what
they
would
do.
L
Builder
dot
at
console,
they
provide
their
own
name
and
then
they
do
add,
calls
a
lot
formatter
and
then
it
within
it.
There
fighting
the
options
for
that
custom,
console
dot
format,
options
and
also,
if
you
wanted
to
see
how
again
in
the
PRI,
have
implementations
as
well.
So
if
you
wanted
to
see
how,
like
those
different
API
slopes,
but
it's
basically
how
a
David
described
this
is
just
convenience
meant
the
before
setup.
Do.
L
J
No
I,
so
we
we
could
support
that.
We
could
support.
It
was
when
you
call
I'd
blot
it
it.
It
was
set
the
right
consul
arguments
to
make
it
pick
the
right
formatter
it
just
means,
but
then
the
order
matters.
So,
if
you
add,
if
you
add
ten
of
these
serious
there's,
there's
a
pattern
where
you
could
say
calling
at
is
how
you
turn
it
on
on
how
you
select
the
right
one
or.
D
J
You
at
is
how
you
say
you
want
to
put
it
in
this,
put
it
in
the
system
to
say
what
this
this.
Actually,
this
thing
is,
but
then
something
else
has
to
pick
the
Asheville
specifically
one
being
used
all
right,
so
so,
for
example,
what
would
happen
is
you
can
imagine,
having
a
plugin
that
rat
on
a
sure
that
added
an
add
your
specific
formatter
right
to
the
system,
but
then
the
user
could
pick
which
one
it
wants
it
based
on
the
environment
variables,
so
adding
isn't
necessarily
a
way
to
say
to
select
it.
L
C
H
C
J
Adding
too
so
so
I
think
not
overload
is
misleading
a
little
bit.
It
might
be
so
so
odd
console
passing
a
string
in
might
be
a
bit
misleading.
The
other
overload
is
you
call
that
console
I'm
you
getting
lambda
and
you
say
you
know:
options
dot,
current
form
at
R
equals
Jason
all
right
and
that's
more
of
a
selection.
J
L
B
J
No,
no,
no
see
the
problem
is
add,
console
is
doing
a
different
thing
and
that
happens
to
be
a
shortcut
for
like
add,
console
and
also
select
the
current
formatter.
So
let's
just
get
rid
of
the
overload
because
it
is
confusing
because
add-on
so
I
actually
means
add
the
console,
provide
and
there's
like
different
providers
right.
So
a
console
needs
to
exist
as
a
thing
and.
J
K
J
J
You
want
to
configure
options
for
the
console
logger
without
configuring,
the
Jason
specific
options
there.
So
there's
a
hierarchy
right,
there's
console
has
options.
Every
formatter
has
their
own
options
and
you
can
configure
both
individually,
so
I
think
one
thing
we
could
do
is,
if
you
add
a
formatter
without
calling
out
console,
we
can
make
it
add
a
console
on
your
behalf.
That
actually
would
be
a
good
change,
because
it
would
save
you
having
to
add
having
to
call
our
console
for
the
common
use
case.
J
The
problem
is,
you
still
need
someone
to
select
which
one
you
want
to
use.
So
if
you,
if
you
called
a
Jason
and
some
other
component
in
the
system
called
ID
address,
was
a
bit
longer,
then
the
last
one
wins
like
with
one
wins:
I
mean
last
could
win
right,
but
but
that
would
have
to
be
figured
of
it
for.
J
J
I
think
a
couple
of
things
remove
the
overlook
that
takes.
The
string
is
one
of
them
to
this
confusing.
If
you,
if
you
add
the
formatter
well,
when
you
call
odd,
what's
they
call
it
I
had
a
console
up
for
a
matter
yeah,
you
should
add
the
console
bloggers
as
well.
Okay,
that
way
for
the
most
part,
you
call
add
blah
and
it
will,
it
will
add
the
formatter
and
it
will
set
the
default
to
be
that
specific
for
minor.
L
L
Here
so
so,
if,
in
the
past,
we
had
this
new
console
law,
blogger
format
default
because
we
only
had
we
would
just
pick
between
those
two
options
and
now
we're
going
with
more
and
also
using
custom,
and
so,
instead
of
you,
know
we're
using
this
to
actually
pick
it
by
name
pick
the
format,
my
name
also
because
each
formatter
would
have
its
own
format
our
options.
Then
it
didn't
make
sense
to
keep
these
disabled
Ike.
These
properties
that
you
see
on
console.log
our
options
anymore,.
L
L
Yeah
so
there's
one
two,
three
four
yeah,
so
there's
four
properties
and
then
the
fifth
one
is
the
format
yeah.
The
fifth
one
is
the
format
which
is
off
type
console.log
Reforma.
So
these
are
the
only
ones
that
would
get
deprecated,
basically
because
we're
gonna
use
other
things
to
set
up
the
options.
H
L
A
H
Answer
your
question
on
what
replaces
a
we
mean
establish
the
hierarchy.
Initially,
we
only
had
console.log
adoptions,
and
now
we
have
options
associated
with
each
of
the
four
matters
and
I.
Previously
the
there
were
just
two
formats,
and
that
was
a
enum,
so
starch
has
been
replaced
by
moving
them
from
the
console
logger
to
the
individual
for
managers.
So.
A
G
L
L
L
A
Okay,
I
mean
I've
I'm
following
the
mechanics
but
like
I,
think
I
have
a
high
level
understanding
of
what's
going
on
here.
So
maybe
maybe
we
should
look
at
the
api's,
because
it's
the
way
I
think
is
more
about
the
api's
and
the
ND
and
the
usages,
and
it
kind
of
seems
like
these-
are
the
only
changes
you
made.
No
there's
more.
L
L
A
J
A
L
I,
don't
think
there
would
be
need
for
adding
any
another.
Api
would
just
be
removing
that,
because
it's
confusing
and
then
actually
those
last
four
would
internally
make
sure
the
problem
value
is
selected.
There's
one
thing,
though:
I
have
a
question
for
YouTube:
David
is
yep
iPhone,
so
walk
formatter
has
this
getter,
which
is
the
name?
K
J
J
K
L
L
L
L
L
A
I
was
just
typing
schooling.
L
J
L
So
basically,
each
time
you
do
write
like
a
log
message,
you
do
allow
the
log
right
message
or
anything
maternally
at
the
console
logger
with
recalling
this
line
75.
It
will
first
pick
which
formatter
it's
needs
to
use
and
then
the
formatter
will
call
line
75
and
it
takes
the
log
level.
These
are
all
pretty
much
everything
that's
already
been
passed
on,
except
for
I.
M
J
Sure
so
the
logger
internally
has
a
a
background
thread
that
that's
been
loved
the
console.
So
when
you
call
log
it
store
stuff
into
it,
you
a
string
into
a
qubit,
basically
and
then
on.
A
migrant
thread
does
console.writeline
for
performance
reasons.
So
we
have
to
take
the
current
message
being
logged
and
turn
it
into
a
string.
So
the
job
of
the
formatter
is
to
turn
that
that
object
into
a
string,
so
it
gets
passed
all
the
same
arguments
that
log
gets
passed.
So
this
is
some
signature
matches.
J
For
matters
eternity
yeah
and
then
the
the
formatter
is,
it's
actually
stringify
the
message
so
T
state
is
the
thing
being
logged
and
the
formatter
is
basically
to
string
and
then
I
external
scope.
Writer
is
a
thing
we
should
discuss
and
then
the
Builder
is
what
you
write
to
to
actually
create
the
message.
So
then
log
is
called.
We
call
format
passing
in
the
right
state.
Try
it
turn
it
into
a
string.
The
string
is
put
into
the
Q
and
Q
then
write
some
sometime
in
the
future.
A
G
J
J
A
I
I
J
G
A
J
A
There's
two
things:
one
is
the
new
Windows
term
will
actually
will
support
vt100
natively.
So
you
don't
have
to
do
anything
there.
If
you
sterilize
the
legacy,
then
yes,
that
would
have
to
happen,
but
I
mean
I
would
say
if
we
would
provide,
let's
say
a
VD
100
brighter
and
IBD
100
parser
than
I
think
it
would
be
fine
to
say:
color
is
just
part
of
the
string
and
then,
if
you
ever
care
to
extract
it,
then
you
can,
because
you
have
a
parser
right
and
then
I
prefer
that,
because.
D
A
J
J
And
I
also
prefer
from
from
a
point
of
view,
because
you
can
turn
into
a
string
once
and
then
on
the
other
side,
what
is
DQ'd
from
the
cue
to
the
to
log
it
you
can
split,
it
split
it
and
keep
it
all
on
the
stack
without
having
to
like
worry
about
splitting
things
across
the
formatter
and
the
thing
doing.
The
actual
right
call
right.
J
J
H
J
J
K
A
Mean
honestly,
I
would
say
like
I
would
be
in
favor
of
saying
we
have
a
vt100
builder
right
that
just
allows
you
to
yeah
I,
don't
think
we
should
get
asked
people
to
go,
look
up
a
skier
fancy
escapes
but,
like
I,
think
it
makes
more
sense
of
a
generic
API.
That
is
kind
of
like
a
string
bow
that
to
do
that.
It
is
not
tied
to
the
logging
framework
exactly.
A
G
Does
that
mean
so
format,
David
you're
changing
to
be
returning
a
string
instead
of
being
void?
Yeah
cuz
I
was
gonna,
give
the
comment
that
either
it
should
be
called
right,
because
it's
a
side-effect
method
or
it
should
be
non
side
affecting
and
returning
something
if
you're
making
it.
You
know
on
side
affecting
we
saw
that
mobile.
Yes,.
D
K
J
J
So
scope
is
basically
an
ambience
set
of
key
value
pairs.
It's
a
nascent
local
that
stores
key
value
pairs,
so
you
can
add
ambient
context
to
every
log,
so
you
can
say
like
begin
scope,
the
current
request
ID
is
is
is
five
and
every
log
will
have
that
stopped
on
to
the
vlog.
So
it's
a
way
to
correlate
context
in
an
ambient
way
across
multiple
logs
and
the
scope
provider
gives
you
an
API
I
mean
think
of
it
as
passing
you
an
ienumerable
of
name
value
pairs,
so
you
can
append
to
the
string.
A
J
Yeah
I
I
think
we
should
consider
it.
My
concern
is
that
this
scope,
but
I
was
not
in
the
first
version.
It
was
added
in
like
two
point
two
points
who
are
two
point
one
so
I
worry
about
putting
it
in
the
actual
call
to
format,
because,
like
law
does
that
have
it,
it
gets
passed
up
to
the
lugger
via
the
same
mechanism.
J
J
A
J
A
H
J
Yeah,
so
when
you
call
a
log,
we
have
to
turn
your
context.
Your
state,
so
T
State,
is
an
object
right
and
that
has
to
be
string
a
fight
in
place,
because
the
the
contract
is
that,
what's
the
cost
of
log
returns,
the
person
can
can
keep
the
object
and
do
stuff
with
it.
So
that
could
be
reused,
for
example,
so
you
don't
wanna
hold
on
to
it
and
pass
it
around
yeah.
A
J
J
A
J
M
J
A
Not
sure
I
mean
you
couldn't,
for
example,
say
it's
a
stringbuilder
right,
because
the
string
bill
is
already
better
than
the
string
right,
because
you
don't
force
the
whole
thing
to
be
contiguous
in
memory
you
can,
you
can
rent
buffer
us,
you
can,
there
can
be
disjoint
and
then
you're
done.
You
just
sent
the
whole
stringbuilder
over
alright
and
and
that's
still,
probably
better
than
individual
strings
yeah.
K
L
L
Chu
within
the
log
I
mean
parts
of
the
law
and
then
reset
color,
because
you
want
a
little
bit
of
it
to
be
in
that
different
color
and
then
you
set
color,
and
then
you
do
pop
and
again
it
was
basically
behind
things
for
a
single
log
message
is
using
a
string
milder,
but
then
now
you're
talking
about
returning
either
a
string
or
a
ring
milder
or
something.
So
it's
just
gonna
be
along
the
lines
of
what's
already
happening
behind
the
scenes.
What
I'm
trying
to
say
yeah.
A
I
guess
feel
like
I
mean
yeah
I'm,
just
asking,
because
it
seems
like
if
you
codify
effectively
in
the
API
that
this
thing
must
produce
the
string,
then
optimizing.
This
away
is
harder
right
like
if
you
say
it's
a
side
effect
thing,
then
it's
your
infrastructure
and
how
that's
wired
up
is
kind
of
an
implementation
detail
for
the
user.
Alright,
yes,
sir
I.
M
J
J
I
I
K
A
A
H
J
J
K
J
H
J
Yeah
that
isn't
really
an
option
that
isn't
really
a
formatter
decision
right,
it's
more
of
a
the
console
logger
itself,
this
sightings,
where
it
goes
based
on
level.
Okay,.
L
K
L
J
No,
it
shouldn't
so
the
logger
should
call
format
it
should
pass
in
whatever
context
needs
to
be
to
be
passed
into
for
that
synchronous
call
and
then,
after
it
returns,
it
would
have
all
the
state
required
to
in
queue
it
I
sent
it
somewhere
else.
So
the
I
think
the
figure
out
is
if
we
want
to
somehow
encapsulate
color
in
this
interface
being
passed
to
to
format,
slash
right,
I'm,.
K
J
L
D
L
L
L
A
Yeah
because
then
I
think
what
David
said
makes
sense
to
me,
because
if
you
didn't
just
say
this
is
just
a
text
writer
and
we
have
some
other
way
to
construct
colors
and
that
seems
reasonable.
I'm
not
really
sure,
like
what
the
constraints
are
on
the
writing
it
out
part.
But
if
you
can
assume
that
your
console
supports
vt100,
you
can
the
to
just
print
it
out,
as
is
I.
Don't.
L
Know
what
100
is
but
I
just
looked
at
the
implementation
differences
between
Windows
and
the
like,
none
like
other,
like
Linux
and
whatever
or
so
on
the
windows
side.
You
have
to
write
one
at
a
time
for
each
color
you
can't
just
but
like
for
Italy.
It's
just
the
implementation
and
details
between
windows
I'm,
not
but
all
except
it's
because
I
don't
have
a
background
in
it.
H
A
I
A
I,
don't
think
it's
like
it's
not
a
shop
on
one
windows:
either
you
you
just
have
to
opt
in
and
I
think
you
have
to
be
on
effect
effectively
some
version
of
Windows
10.
That
has
it
so
it
wouldn't
be
support
them
in
seven,
let's
say,
but
you
could
say
on
win7
you
just
yeah,
you
just
parse
it
and
then
do
the
console
dot
set
color
color
codes
before
you
write
it
out,
which
again
wouldn't
wouldn't
help
you
perf,
but.
H
A
I
A
A
Mean
that
kind
of
depends
on
how
we
want
to
do
vt100
in
general,
but
I
would
think
for
now.
I
would
just
say
you
know
assume
it
as
a
separate
PCL
API
for
that,
and-
and
maybe
you
want
to
design
it
as
part
of
this
and
then
just
say
it's
a
separate
issue
but,
like
you
know,
you
design
it
and
then
see
whether
that
works
for
you.
A
K
K
A
M
A
Yeah
I
don't
feel
like
I'm
in
the
best
position
to
this,
but,
like
I,
can
summarize
what
I've
written
in
my
notes
and
then
because
my
notes
are
also
someone
hand
wavy,
because
I'm
not
sure
I
understand
the
concept
100%,
but
we
basically
said
we
want
to
remove
the
console
overload
that
takes
the
string
and
rely
on
the
other
ones
to
do
the
right
thing
we
said.
Instead
of
using
icons
for
logo
options,
we
should
just
use
the
base
type
console
logo
options.
A
We
said
instead
of
tying
colors
to
the
formatter.
We
should
decouple
this
by
exposing
engineering
vt100
builder
for
colors,
maybe
even
a
parser.
This
way
we
can
simplify
the
architecture
here
by
making
icons
of
formatters
job
purely
about
building
up
the
string
or
writing
to
a
text.
Writer
and
then
I
basically
said
the
last
one
was:
should
I
console
up
for
my
deposit
text,
where,
instead
of
returning
a
string,
is
lost
implementation
to
optimize
buffer
management.
K
A
They
seem
fine,
I
would
just
make
sure
we
only
have
one
period
at
the
end,
but
other
than
that
I
think
it's.
The
only
thing
I
would
say
is
when
you
obsolete
something
you
kind
of
want
to
hook
it
to
point
people
towards
what
they
should
do
instead,
and
we
should
probably
find
a
way
to
precisely
say
that
and
also
short,
because
you
only
have
a
string
that
you
put
in
the
air
in
the
error
list,
but
other
than
that
I
think
it
makes
sense.
L
A
A
G
K
L
About
it,
but
I
am
in
order
to
make
the
deprecated
okay
I,
don't
know
how
the
deprecation
situation
works
like
we
need
to
support
it
for
a
while
right.
So
then,
I'm
I,
don't
think
it's
a
good
idea,
because
there
are
overloads
I'm,
adding
that
are
using
console
logger
options.
If
you
scroll
all
the
way
up,
if
you
remember
so
I'm
just
going
along
adding
more
overloads
there,
so
it's
using
console.log
or
options,
so
that's
I,
think
kind
of
why,
on
some
longer
options,
remember
the
string
thing
that
I'm
gonna
remove
lot
in
14.
L
H
L
F
A
To
me,
like
think
of
Absolution,
more
as
an
as
it
is
a
user
experience
thing
where
you
basically
say
you
know,
don't
use
this
API
use
another
API
over
here,
and
so
the
question
is:
how
do
you?
How
do
you
concisely
explain
to
your
customers
what
the
expectations
are
alright
and
it
seems
a
bit
of
a
cognitive
dissonance
to
say
everything
on
the
type
we
currently
have
is
deprecated,
but
we
had
one
more
thing:
that's
not
deprecated
right.
A
A
H
M
B
A
A
Can
see
we're
talking
past
each
other,
like
what
I'm
saying
is
in
this
new
world
right?
You
have
basically
an
icon
so
lot
of
formatting
options
right
and
we
said:
okay,
it's
of
an
interface
using
abstract
base
type
and
then
base.
If
asking
is,
could
the
abstract
base
type
b
console
logger
options
because
it.