►
From YouTube: SES-mtg: Lexical Value Types
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
And
I'm,
you
know
I'm
happy
to
follow
up
with
with
Leo
about
this.
Also,
if,
if
we
get
to
a
point
where
we
have
tests
but
they're
not
being
run,
then
there
are
various
things
we
could
you
could
you
know
another.
Another
thing
we
can
do
is
contribute
upstream
into
the
engines
to
do
the
integration
for
them,
but
they
shouldn't
be
just
sort
of
a.
B
So
someone
just
raised
to
me
that
I
was
making
a
point
earlier
that
I
didn't
finish
and
I
should
probably
finish
it
around
structuring
of
invariance,
around
values
and
the
way
in
which
different
invariants
can
be
more
or
less
powerful
in
a
given
context,
the
one
that
we
just
discussed
was
a
virtualize
ability
within
the
scope
of
implementer,
implement
ability
and
I
think
that
this
is
an
important
thing
to
capture,
because
you
know
in
a
in
a
vacuum.
A
lot
of
these
decisions
would
be
really
easy
to
make,
but
we're
not
working
within
the
vacuum.
B
We're
working
within
an
interconnected
system
of
moving
parts.
There's
a
couple
of
ways
that
we
can
record
that
I
think
some
invariants
may
be
easier
to
write
down
than
others,
and
we
can
just
directly
write
those
down
and
group
them.
Others
may
need
more
nuanced
approach
and
I,
don't
exactly
know
what
that's
going
to
look
like.
C
Okay,
so
things
like
the
negotiated
compromise
and
temporal
could
be
would
be
consistent
with
a
primordial,
should
have
no
hidden
mutable,
state
or
IO,
and
then
the
temporal
is
a
compromise
where
the
the
IO
is
easily
corn.
Corn
corn
MP
is
organized
so
that
it's
easily
easy
to
quarantine,
but
it
is
there
mixed
in
with
the
primordial
object.
Mm-Hmm.
B
There
was
another
detail:
oh
yes,
okay!
So
there's
another
important
detail
to
this.
I
agree
with
what
Mark
said
earlier.
That
invariants
should
be
changeable
and
we
should
maintain
the
change
ability
of
primordial
of
invariance,
because
if
we
don't,
we
may
forget
why
they're
there
and
the
context
may
change
so
radically
over
the
next
20
years
or,
however
long
we're
working
on
this,
that
they
may
no
longer
make
sense.
So
the
rationale
behind
why
the
invariant
exists
must
also
accompany
that
invariant
in
the
past,
we've
used
short
terms
such
as
security
or
integrity.
B
C
I'll,
give
you
a
great
example
of
something
that
we
used
to
take
as
an
absolute
invariant,
and
then
we
three
of
the
invariant
away
and
we're
happy
to
do
so.
That
wasn't
even
controversial,
which
is
the
relationship
between
double
equal
and
triple
equal
and
type
of
was
the
invariant
was
that
your
type
of
a
a
is
the
same
as
type
of
B
and
a
double
equals
B?
If
it
then
a
triple
equals
B.
C
So
so,
if
the
type
of
czar
the
same
than
double
equals
and
triple
equals,
are
always
an
agreement
and
the
the
full
value
types,
a
proposal
would
allow
overriding
a
double
equal,
but
not
triple
equal,
and
that
would
be
an
example
of
having
violated
something
that
in
es5
Evert
discussions.
We
actually
took
to
be
an
invariant.
We
couldn't
relax
and
now
it
seems
like
we're
willing
to
relax
it,
and
nobody
cares,
which
is
interesting.
B
B
So
to
me
it
sounds
like
we're
all
pretty
much
in
agreement
that
writing
down
invariants
and
making
them
something
that
is
agreed
upon
and
in
the
specification
is
a
good
idea.
It's
something
we
should
pursue.
The
exact
shape
of
this
is
maybe
not
100
percent
clear
yet,
and
we
need
to
gather
some
details
about
this
I'm
guessing.
We
probably
won't
get
all
of
the
details
and
the
design
of
this
down
in
this
meeting,
but
would
it
make
sense
to
start
an
email
thread
with
everyone
who's
in
this
call
and
start
gathering?
B
First
of
all,
invariance
examples
of
how
invariants
have
been
adopted
or
not
used
where
there
was
a
sugar,
must
situation
etc
and
just
start
gathering
so
that
we
can
start
looking
at
what
all
of
that
looks
like
and
making
sense
of
it.
Would
that
be
a
good
step
forward,
for
this
sounds
good
to
me.
Okay,
so
I
can
take
responsibility
for
sending
that
email.
D
D
D
C
Trying
to
prevent
something
without
explaining
the
rationale
and
still
haven't
explained
the
rationale.
Let
me
just
state
the
punchline
for
everybody's
benefit,
which
is
and
Chris
actually
mentioned
this,
which
is
the
problems
with
the
exotic
internal
thoughts
containing
objects.
There
is
no
fatal
problem
there.
It
is
one
of
these
shoulds,
rather
than
must,
since
an
issue
of
trade-offs
and
what
those
trade-offs
are
and
and
when
they
hurt
and
when
they
don't
is,
is
the
thing
that
needs
presentation.
C
D
D
B
E
D
A
C
A
A
But
the
the
idea
that
I
have
is
that
I
mean
the
big.
The
big
prop
like
value
types
is
that
you
need
for
two
objects.
You
need
some
kind
of
registry
such
that
when
you
do
to
object
on
a
value
type
you
get
something
that
has
the
prototype
you
wanted,
but
that
registry
becomes
this
indication
channel
mark
is
that
is
that
the
problem
you
see
also
oh
yeah,.
A
So
my
proposed
solution
is
what,
if
we
use
lexical
scope
for
this
registry,
we
like
lexical
scope
right,
so
I'm
gonna
share
a
code
sample,
so
here
this
would
be
the
definition
of
a
value
type
for
a
complex
number.
So
there
are
two
key
parts.
One
is
that
value
types
have
a
key,
though
there's
this
there's,
this
API
type
dot
tag
and
type
dot
untagged.
So
the
key
gives
you
the
capability
to
both
produce
values
of
that
value,
type
read
their
internal
private
contents
and
because
symbols
are
unique
entities
most
of
them
at
least
they.
A
They
this
works.
It
really
preserves
privacy
because
you
only
pass
this
symbol
as
a
this
symbol
represents
this
capability
of
it.
That's
unfortunate,
so
you
have
this
API
type
that
tag
where
you
you
have
a
record
here
now
that
we
would
have
records
in
tuples,
arbitrary
compound
data
teams
and
Biggins
provide
arbitrary
binary
data,
and
you
tag
it
with
this
key
and
then
you
can
untag
it
also
passing
the
key
now.
A
Okay,
so
this
is
not
the
type
of
the
type
of
is
part
of
the
public
API.
If
type
of
gave
you
this
tag,
then
all
encapsulation
would
be
lost
and
people
would
be
able
to
forge
values
and
the
private
data
just
from
giving
me
technically.
So
the
idea
is
that
when
you
construct
a
new
value
type,
you
have
both
a
key
or
tag.
A
I
guess
I
have
to
decide
what
what
analogy
I
want
to
use
view
them
any
of
a
separate
type
of
then
you
also
have
a
prototype
for
the
rapper
and
possibly
operator
overloading
behavior.
The
other
thing
that
you
would
have
is
a
proxy
handler.
So
if
you
want
your
rapper
to
be
an
exotic
object,
then
each
one
would
use
the
same
handler
and
I'll
go
to
another
example
with
that
later,
so
this
type
constructor
does
not
communicate
with
any
registry
at
all
it
just
we
just
stored
in
this
type
property.
This
is
just
a
convention.
A
I
think
looks,
looks
nice,
so
you
have
the
constructor,
and
then
you
also
have
the
type.
The
only
thing
you
can
do
with
the
type
or
the
main
thing
you
can
do
with
the
type
is
make
it
available
in
a
lexical
scope.
So
there's
there's
no
global
communication
about
key.
You
can
make
multiple
types
that
have
the
same
key,
but
you
have
to
have
the
key
to
make
the
type
that
refers
to
it.
When
you
do
you
type
complex,
dot
type.
A
What
that
means
is
that
when
we
see
two
objects
on
one
of
these,
it
will
look
in
the
lexical.
You
can
think
of
it.
The
enclosing
lexical
scope,
having
like
a
stack
of
maps
from
symbols
to
these
types
from
these
tags
to
the
type
constructor,
and
from
that,
when
you
do
two
objects,
you
just
look:
okay,
what's
the?
What?
What
is
there
for
the
key?
A
Okay
I'll
make
a
wrapper
with
this
prototype
and
it
should
I
think
that
should
work,
and
similarly
for
operator
overloading,
we
previously
discussed
in
tc39
that
operator
overloading
it
would
be
governed
by
lexical
scope,
opt-in,
which
preserves
a
lot
of
important
invariants
and
the
more
I
think
about
it.
The
more
I
think
well,
if
this
is
design
for
value
types,
then
maybe
we
should
just
make
operator
overloading
couple
to
value
types,
especially
now
that
we
have
symbols
as
weak,
math
keys
that
allow
us
these
value
types
to
reference
to
reference
up
yeah
yeah
week.
A
C
First,
let
me
say:
I
really
like
a
lot
about
this
and
I.
Think
it's
promising
and
Clara
I
mean
it's.
It's
the
it's
making
use
of
this
obscure
property
that
we
already
have
for
primitive
values
that,
when
you
do
a
to
object
on
a
primitive
value
which
prototype
it
promotes
them
to
depends
on,
is
as
a
effectively
a
lexical
property
of
the
code,
doing
the
promotion
doing
the
dot.
You
know
if
you
exactly
and.
A
C
A
Throws
it
out
there,
so
you
all
of
this
code
above
manipulates
these
values
and
carefully
avoids
all
object
operations
on
complex
values,
because
if
they
use
them,
it
would
get
it
tight
there.
So,
in
this
case
it
this
is
just
building
off
of
that
pattern
established
in
the
operator
overloading
proposal
where
operator
overloading
was
also
based
on
a
type
there
when
used
outside
the
lexical
declaration.
G
A
D
A
A
A
There's
no
side
effect
that
comes
from
two
objects,
so
I
didn't
want
to
call
a
callback
when
you
do
two
object,
because
that
that
prohibits
the
way
that
engines
like
to
work
to
avoid
that,
it
also
inhibits
the
work
that
we
did
with
strict
mode
to
prevent
the
wrapper
from
being
sort
of
observably
created.
When
you
have
a
strict
mode
method,
it
doesn't
get
the
wrapper
as
the
receiver
right.
C
A
Just
give
it
let
it
have
the
prototype
and
the
handler,
then
it's
it's
enough
and
what
one
further
note
about
this
wrapper
when
we
have
these
type,
this
type
dot
untag
function
works
both
on
the
primitive
value
and
on
the
wrapper.
You
can
distinguish
them
through
the
type
of
that
the
wrapper
will
have
type
of
object
function
but
and
the
good
ones
will
have
these
other
symbol.
Typos,
but
and
type
of
and
tag
works
through.
The
meeting
wrapper,
otherwise
sort
of
doesn't
make
sense,
I
think
otherwise,
there's
there's
nothing.
C
A
C
C
C
A
E
That
I,
that
I
mentioned
in
chat
here.
One
of
them
is
when
you
gave
this
presentation
ten
minutes
ago,
I
heard
dependencies
on
at
least
three
other
tc39
proposals
that
are
in
various
stages
of
progress.
I'm
wondering
how
that's
going
to
smell
to
the
committee
in
general:
I'm,
not
a
part
of
tc39
I'm,
just
calling
it
out
so.
A
It's
depending
on
records
and
tuples
I'm
working
closely
with
the
record
and
couple
champions
and
I
really
hope
that
we
can
go
to
stage
two
next
meeting.
I
was
thinking
of
making
this
part
of
the
operator
overloading
proposal
service,
assuming
the
current
operator
overloading
proposal
with
this
being
operator
overloading
coupled
with
value
types.
This.
C
Gets
rid
of
the
main
pain
point,
because
the
operator
overloading
proposal
about
this,
the
values
that
you're
overloading
operators
on
are
still
genuine
objects
with
first-class
identity
and
for
a
lot
of
is
Kate
Hewson
users
we
want
to
make
it
operator
overloading
having
them
be
objects,
rather
than
values,
is
really
unpleasant.
When
this
we
fix
them.
A
Yeah
and
conversely,
there
were
a
bunch
of
use
cases
presented
for
upward
or
overloading
that
would
depend
on.
They
really
wanted
to
be
with
references
to
objects
and
I.
Think
now
that
we
have
symbol
as
we
clap
key
sort
of
there,
that
will
let
us
build
everything
and
it
won't.
It
won't
be
this
fundamental
restriction
that
I
thought
it
was
before.
C
A
A
We
so
membrane
system
gets
the
key
when
it
sees
that
and
when
it
sees
this
type
pass
over
the
membrane,
then
it
says:
okay,
I'm
gonna,
replace
it
with
something.
That's
like
this,
but
each
one
of
these
things
individually,
membrane
rafts,
so
that
then,
when
you
do
two
objects,
so
then,
then
you
can
use
it
in
the
with
statement.
You
know
because
somehow
you've
passed
this
type
over
the
membrane
and
you
want
to
use
it
in
the
with
statement
and
it
will
just
work
because
the
key
is
the
same.
A
C
D
A
C
A
C
Yeah
I
can
see
why
you
need
to
do
it
that
way
or
I,
don't
see
how
to
avoid
that,
but
it
does
create
a
much
more
burdensome
coordination
with
the
membrane
right
now,
a
membrane
can
be
transparently
practically
transparently
interposed
between
two
realms
without
any
knowledge
of
any
of
the
particular
things
on
each
side.
So
there's
some
so
membranes,
basically
are
a
generic
Combinator
that
you
can
create
them.
You
could
put
them
between
object,
graphs
that
you
ignor
it
is,
and
except
for
edge
cases
through
all
the
practical
sort
of
normal
practical
cases.
C
A
E
C
Actually,
I
say
that
the
second
one
is
actually
consistent
with
the
Stan's
you've
already
taken
on
lexical
scope
with
no
membrane
boundary.
Then
you
just
pass
one
of
these
things
from
one
module
to
another
and
the
receiving
module
has
no
static,
has
no
lexical
knowledge
of
the
complex
type.
Then
it's
just
opaque.
So
if
there's
a
membrane
in
the
way,
then
that
shouldn't
make
it
any
less
opaque
for
the
receiver
made
a
receiver
that
doesn't
have
static
knowledge,
it's
opaque
whether
it
comes
to
remembering
or
not.
A
C
A
Intervention
would
be
that
you
export
the
constructor
and
there's
this
convention,
but
it's
not
required
at
all
and
you
put
the
type
as
a
property
called
title
on
the
constructor.
So
then
you
can
use
it
with
this.
With
this
particular
idiom.
Okay,
now
there's
still
separable
capabilities.
There's,
no
reason
why
the
capability
to
construct
you
know,
values
of
this
value
type
should
be
coupled
with
the
capability
to
put
them
in
scope,
but
I
think,
usually
you
want
to
couple
them
and
so
I
think
it
at
a
convention
level.
E
A
Thinking
about
that,
but
I
wouldn't
I,
wouldn't
want
it
to
implicitly
read
the
simple
property
like
this.
We
could
do
with
type
of
complex
and
then
that
would
implicitly
read
a
symbol
but
I
felt
like
that
would
be
kind
of
if
it
implicitly
read
the
symbol,
I
thought
that
would
be
kind
of
lower
integrity
because
then
you're
making
this
this
really
specific
requirement
that
the
type
be
found
within
this
bigger
structure
that
has
the
symbol.
Okay,
we
could
find
a
different
name.
That's
not
tight!
The
thing
is
that
type
is
just
entirely
convention.
A
C
Is
you
have
it
doesn't
care
about
the
constructor,
so
the
constructor
doesn't
even
necessarily
have
to
have
been
exploring
the
thing
that
needs
to
have
been
exported
and
imported,
but
is
this
type
object,
however,
its
thing?
So
what
kind
of
what
is
the
type
object?
What
is
the
thing
that
the
type
of
constructor
Kremes
I?
Don't.
A
A
Maybe
the
only
thing
that
might
we
might
make
that
the
type
of
public
we
definitely
wouldn't
make
the
key
public
we
could
make
the
prototype
or
operators
or
handler
public,
but
I
think
that
would
be
a
little
bit
weird
I
think
it
would
just
be
an
object
that
has
internal
slots
for
each
of
these
five
things,
these
four
that
you
see
here
in
the
handler
and
then
the
type
prototype
might
have
a
getter
to
get
the
type
of,
and
the
other
thing
is
just
held.
Private,
okay,.
C
C
Right
and
if
you,
if
we
did
so,
if
we
look,
if
we
just
take
a
look
at
a
pair
of
modules,
a
and
B
without
a
membrane
between
them,
a
defines
complex
exports,
the
type
object,
B
imports,
the
type
object,
does
the
width
on
the
type
object
and
now
everything's
fine.
Now
we
put
a
membrane
between
a
and
B,
they
be
complex.
Values
go
through
the
membrane
with
no
problem.
A
C
So
so,
instead
of
thinking
about
having
to
prearranged
each
separate
type
with
the
membrane
system,
is
there
some
generic
generic
special
case
oxymoron?
Is
there
some
or
some
rule
we
can
adopt?
That's
very
specific
to
these
type
objects
such
that
a
type
object
passed
through
a
membrane
creates
on
the
other
side,
something
that's
a
valid
type
object.
A
A
It's
really
without
adding
a
bunch
of
extra
proxy
traps.
It's
really
hard
for
me
to
picture
how
that
would
work.
Okay,
okay,
but
that's
just
offhand
I
can't
I'll,
have
to
think
about
this.
Some
more
I
was
I
was
really
hoping
that
it
was
gonna,
be
just
fighting
to
patch
tight.
That
was
part
of
my
a
mental
story
for
this.
If
that's
anyway,
if
this
is
the
only
problem
that
I'm
like
thrilled
I
thought,
there
would
be
something
else
more,
a
bit
more
of
me.
Instead
of
drunk
yeah.
A
A
A
D
A
G
So
yeah
you
may,
you
may
encounter
if
we
see
you
know
the
way
modules
kind
of
like
said
no
like
import
and
whatever
those
on
the
top
level
again,
so
you
may
encounter
whatever
it
is.
That
leads
to
those
becoming
top-level
module,
not
declarations.
That
would
be
rude,
but
at
least
they
would
only
be
top-level
module.
C
Actually
had
a
proposal
for
generative
modules
that
enabled
things
like
import
to
appear
inside
a
function
would
be
multiple
instantiate
and
Dave.
Herman
succeeded
succeeded
at
attacking
it
in
ways
that
I
had
no
response
to
so
I.
Don't
remember
what
there's
a
tax
warning
might
be
hard
to
reproduce,
but
my
attempt
to
to
generalize
it
did
fail
under
trilogy
forgave,
her
Dave
Herman
yeah.
C
A
C
A
And
we
can't
go
changing
things,
so
maybe
I
could
walk
through
examples
of
things.
I
think
we
could
implement
through
value
types.
Then
I
mean
I
haven't
written
up
the
code.
Yet
this
is
just
what
I
have
in
my
head,
but
we
could
probably
feel
like
vegan
in
terms
of
tuples
and
32-bit
integers
or
it
could
be
in
terms
of
web
assembly.
Like
imagine,
you
have
a
linear
webassembly
heap,
you
use
weak
references
and
final
finalization
groups,
finalization
registry
to
to
free
the
memory.
A
G
I
can
I
give
you
like
a
use
case
scenario
because
waiting
for
a
chance-
oh
yeah
yeah,
so
so
I
I
used
to
do
math,
lab
and
Java,
and
then
you
know
graduate
and
I
was
like
I'm,
never
gonna,
pay
them
and
I
I
wanted
to
make
JavaScript.
You
know
be
the
replacement
to
that.
So
so
so
yeah
we
wanna.
We
want
to
think
of
webassembly
executing
you
know,
FFT,
you
know
complex
numbers,
you
focused
love
on
complex
numbers,
but
but
there
are
also
other
other
things
that
you
do
with
computational
signs
or
I'll.
G
Stick
in
my
area
of
the
woods,
color
science
so
yeah
so
like.
How
would
you?
How
would
you
consider
you
know
going
from
I
guess,
data
types
that
are
based
on
porting
stuff
to
web
assembly
and
going
back
and
forth
between
JavaScript
and
web
assembly
functions
that
you're
sure
work
and
they
have
their
own
signatures.
A
So
you
know
with
these
methods
that
exist
on
prototypes,
you
could
sort
of
do
anything
so
inside
of
the
payload
you
could
have,
so
you
have
a
record
maybe,
and
the
record
could
have
an
integer
which
is
an
index
into
a
web
assembly.
You
could
also
have
a
symbol
and
we
could
have
a
week
map
off
to
the
side.
It's
clean
by
these
symbols,
where
that,
where
the
value
corresponding
in
that
week
map,
we
do
you,
it
could
be.
A
You
know
the
web
assembly
memory
or
it
could
be,
or
it
could
be,
a
value
that
sort
of
holds
that
that
has
a
finalizer
registered
against
it.
Actually,
I
guess
the
symbol
can
have
would
be
able
to
get
registered
in
a
finalization
registry
directly.
So
this
symbol
is
registered
in
the
finalization
registry
and
then
and
it
becomes
inaccessible,
it
would
free
the
the
underlying
memory
in
the
web
assembly
here
all.
F
G
A
Will
be
offset
and
then
the
symbol
that
that
frees
the
memory-
and
maybe
you
have
one
global
webassembly
heap,
so
you
don't
need
to
sort
of
close
over
it
on
a
per
value
Basin
and
then
you
know,
then
you
can
just
have
methods
to
deal
with
it.
I
think
it
would
probably
be
easier
to
just
use
ordinary
objects
for
that,
but
the
value
types
would
give
you
the
operators
and
things
like
that.
Yeah.
G
G
E
G
G
Pointers
to
memory
buffers,
you
know
somehow
from
webassembly
you
kind
of
want
to
want
to
say.
Okay.
This
is
the
data
structure
that
I
want
to
actually
consume
it
as
when
it
comes
out
of
the
web
assembly
function,
I
don't
want
to
just
get
the
buffer
back.
I
I
want
to
decompose
this
or
deconstruct
this
or
something
you
know,
I,
don't
know
what
the
right
terminal.
B
A
G
D
G
F
A
Yeah
so
I
think
the
design
tier
later
any
arbitrary
object,
be
wrapped
they've
done
a
single
big
map
keys
to
be
used
in
value
type.
It
could
have
operator
overloading
so
that
you
could
apply
that
these
people
you
showed
there
was
no
use
of
operator
over
look
I'm,
not
sure.
If
that's
what
you
were
getting
at.
F
So
I
somewhat
tangential
thought
to
that
and
just
I'm
a
completely
wrap
my
head
around
your
your
your
idea
here,
but
I'm
just
really
really
liking
the
the
general
flavor
of
it.
But
some
something
and
I've
been
thinking
about
for
quite
a
while
is
the
is
having
a
more
graceful
way
for
handling
the
serialization
and
deserialization
of
data
into
Jason.
F
This
line
of
thought
was
was
actually
big
aunt,
since
jason
has
the
syntax
for
integers
and
big
ants
could
be
encoded
with
them,
but
there's
kind
of
no
place
to
stand
in
the
current
encode
decode
pathway.
To
take
advantage
of
that.
So
I'm
gonna
find
think
about
ways.
One
might
extend
the
Jason
API
to
do
that.
F
As
I
said,
this
is
very
vague
and
hand-wavy,
but
I've
been
working
on
a
design
that
involved
having
essentially
some
kind
of
type
tag
registry
thing
for
for
for
marking
various
different
classes
or
things
according
to
how
they
should
get
serialized,
and
this
feels
like
a
more
elegant
way.
Dealing
with
that
that
problem
of.
F
D
A
A
So
it's
there
there's
sort
of
three
ways
that
we
can
go
about,
having
extended
literal
syntax,
because
we
have
the
problem
where
you
might
want
to
use
I
for
a
suffix,
but
also
I
for
a
variable
and
things
like
that
or
infra
suffix
or
in
for
a
variable.
It
wouldn't
make
sense
for
2px
to
look
at
the
lexical
variable,
so
we
sort
of
have
three
options.
One
option
was
that
we
have
this
leading
underscore
in
the
underscore
is
part
of
the
name.
A
What
option
was
that
we
have
a
name
space
object,
but
that's
just
sort
of
out
of
the
question
and
the
other
option
is
that
we
have
a
separate
lexical
namespace
or
for
suffixes
and
I
want
it.
I
want
to
push
on
that
last.
One
I
think.
If
we
give
it
a
separate
namespace,
you
could
think
of
these
as
implicitly
like
something
that's
untie
pible
concatenated
to
the
to
the
variable
name,
and
this
would
be
you,
sugar
into.
A
A
A
Yeah
I'd
be
up
for
revisions
on
that,
especially
in
this
kind
of
weird
that
were
pre
parses.
It
is
number
but
then
it's
also
available
as
a
string
that
was
specifically
requested
by
the
CSS
working
group,
because
they
would
want
to
be
able
to
if
they
have
the
X
they
wouldn't
want
to
have
to
parse
it,
but
also
in
theory
that
could
be
handled
by
the
same
caching
mechanism.
So.
A
C
A
E
Is
it
operator
precedence
or
something
like
that?
I
mean
normally
that's
problem
solved
with
parentheses
I'm,
just
saying
I
mean
when
you
have
character
as
a
Jason
to
your
px.
It's
got
to
be
clear,
and
maybe
it
isn't
implicitly
I
don't
know.
I'm
just
speculating
here
am
I
making
any
sense
at
all.
I
do.
C
C
E
E
E
E
D
G
Also
one
one
you
know
detail
you
may
use
with
and
code
maintainability
means
that
you
want
to
make
sure
you
use
the
right
width
everywhere,
you're
using
it.
But
if
we're
saying
that
you
know
we
have
modules
now
in
JavaScript,
there
is
no
need
really
for
compiling,
so
you
might
as
well
just
import
suffix
px
from
you
know
great
suffixes
right
there.
A
D
G
D
G
A
G
A
G
A
F
C
Yeah
I'm,
not
not
necessarily
that
we
would
allow
it
in
the
you
know
the
the
full
the
full
proposal
corresponding
the
test.
That's
in
front
of
us
here,
I,
don't
know
that
I'm
in
favor
of
that
either.
But
even
without
that,
the
you
know
this
proposal
you
started
with
is
basically
saying
that
px
is
a
lexical
name,
but
it's
not
in
the
it's
in
this
new.
C
Lexical
namespace
of
suffix
things
as
if
you
were
mangling
in
this
percentage,
suffix
percent.
Well,
you
could
we
could.
We
could
have
done
the
same
thing.
So
just
just
thinking
about
mangling,
the
hypothetical
manual,
the
mangling
that
you
can't
break
it
down.
Well,
we
could
have
done
the
same
kind
of
thing
for
template.
Literal
text.
A
Well,
this
makes
me
very
happy
if
you're
you're,
okay
with
this,
that
means
that
the
decimal
proposal,
both
versions,
the
disk
:
28,
as
well
as
big
decimal,
would
be
fully
poly
fillable
as
value
types
with
extended
literal
definitions.
As
long
as
you
have
this
sort
of
two
line
Prelude
with
suffix
and
with
type
it
wouldn't,
let
you
do
with.
If
you
are
gonna,
probably
fill
the
number,
is
it
wouldn't?
Let
you
have
man
and
it
won't,
let
us
define
it
would
be
very
awkward
to
define
new
things
that
are
like
negative,
zero.
A
C
I
agree
with
your
emphasis
on
both
of
those
that
man
is
really
bad
because
it
makes
equality
non
reflexive.
Well.
Negative.
Zero
simply
makes
equality,
a
less
precise
equivalence
class,
but
it
still
has
all
the
algebraic
properties
of
the
quotient
to
us,
but
it's
still
bad.
It's
just
not
as
bad
right.
A
So
what
we
decided
I
mean
not
what
we
decided.
What's
the
current
proposal
for
records
and
tuples
is
that
the
definition
of
triple
equal
of
strict
equality
would
be
sort
of
based
on
the
same
value
0,
so
0
and
0,
when
nested
in
records
and
tuples
would
be
identified
with
each
other,
but
like
a
couple
containing
man
would
triple
equals
a
couple
containing
man,
and
so
that
definition
would
like
ricochet
up
through
all
these
value
types
good,
where
maybe
you
could
overload
double
equals
but
triple
equals
would
be
that
version.
That's
defined.
C
C
G
I
I
think
also
it
allows
people
to
finally
have
ranges,
as
expressed
you
know,
as
expressions
not
as
a
new
range,
and
then
you
put
all
that
funky
mojo
in
there,
so
so
I'm
not
sure
if
it
made
it
anywhere
in
in
proposals
yet,
but
the
double
dot,
notation
I,
don't
know.
If
folks
considered,
you
know,
number
two
number
as
double
dots
but
I
see
the
problem
with.
That
is
that
you
could
have
what
do
they
call
it
again?
The
interval
couldn't
be
just
ones
and
that
he
had
the
double
dot
notation.