►
From YouTube: Design Meeting 2020-07-22: Const generics MVP
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).
B
B
B
I
guess
I
would
just
give
an
origin
of
how
this
happened
is
that
someone
made
a
pr
to
remove
at
most
the
the
limiter
to
our
current
array.
Implementations
of
you
know:
that's
like
the
trade.
It's
called
like
at
most
length,
32
or
whatever.
B
It's
called,
because
you
know
it's
not
technically
necessary
and
we
had
previously
just
done
it
just
to
make
sure
that
the
set
of
impulse
that
stood
exposes,
doesn't
change,
but
we've
been
using
the
constant
eric's
impulse
for
about
a
year
now
more
than
a
year
actually,
and
they
work
fine,
and
so
I
this
was
randomly
assigned
to
me
and
then
I
was
just
inclined
to
agree
that
we
should
just
remove
the
limiter
from
all
of
these
impulse,
which
then
raised
the
question.
B
If
it's
good
enough
for
stood,
then
maybe
there's
a
subset.
That's
also
good
enough
for
most
libraries
that
currently
are
implementing
traits
for
arrays
up
to
32
or,
however,
they
handle
the
situation
with
the
raise.
Could
we
make
it
so
they
could
implement
their
traits
for
all
arrays,
and
so
talking
with
the
people,
who've
been
working
more
closely
on
const
generics.
B
Which
would
cover
like
all
the
impulse
instead
and
a
lot
of
functionality
that
all
those
sort
of
basically
the
functionality
to
make
arrays
of
first-class
citizen
is
really
what
it
covers
like
it
doesn't
cover
any
of
the
sort
of
fancier
using
it
to
like.
You
know,
create,
ranged
integers
and
things
like
that,
but
it
covers
these
sort
of
like
these
cases,
like
a
raisin,
where
you
just
have
a
something.
B
That's
abstract
over
like
a
constant
and
so
the
two
restrictions
are
first
limiting
it
to
only
the
integral
primitives,
which
means
the
signed,
unsigned,
integers,
char
and
boolean.
B
So
you
know
the
sort
of
primitive
types
that
are
just
a
single
primitive,
so
not
a
compound
type
and
then
also
not
floating
point
right
or
reference,
or
anything
like
that.
They're
just
a
set
of
bits
that
has
a
defined
meaning,
I
guess
so
sort
of
floating
points,
but
they
don't
have
to
deal
with
nan
and
also
the
bigger,
like
the
sort
of
bigger
restrictions.
B
B
Any
sort
of
anything
you
could
use
like
create
a
const
right
now
you
can
use
that
and
then
you
can
also
use
like
if
you
have.
If
your
input
is
parametrized
by
n,
you
can
use
n,
but
you
can't
do
something
like
n
times,
two
or
n,
plus
n
or
n
plus
another
const
parameter,
and
you
also
can't
do
things
like
size
of
t
where
t
is
like
a
type
that
is
an
input
to
this
function.
B
B
A
C
Okay,
so
to
clarify,
based
on
what
I'd
seen
written
elsewhere,
you
can
either
have
an
existing
type
parameter
verbatim
like
in
or
you
can
have
a
constant
expression
that
can
be
arbitrary.
That
can't
include
any
generic
parameter.
You
can't
have
an
expression
that
operates
on
a
generic
parameter,
yeah
exactly.
C
D
B
Yeah
basically-
and
so
it's
supposed
to
be-
you
know
we're
feeding
in
to
the
system.
You
can
feed
contents
into
the
system
or
you
can
just
have
a
tree
where
they
eventually
get
go
down
to
an
array
length
or
something
deep
inside
a
nested
struct
or
something.
But
you
can't
be
doing
this
kind
of
math
on
them
as
they're
passing
through
the
type
system.
B
B
And
I
mean
that's
it,
so
we
would
just
need
to
like
have
that
subset
under
a
separate
feature.
Gate
have
good
error
images,
documentation,
tests,
everything
and
then
we
can
stabilize
it.
E
B
B
Yeah
currently
require
constants
to
come
last,
and
I
think
we
currently
also
still
allow
you
to
have
a
default
type
parameter
before
the
const,
but
we
should
not
like
in
the
long
term.
We
probably
want
a
freeform
order
where
constants
income
in
between
before
type
parameters,
but
that
all
the
defaults
have
to
be.
You
cannot
have
any
non-default
to
the
right
of
a
default.
A
C
B
A
I
wanted
to
like
talk
a
bit
more
about
characterizing,
the
set
of
things
that
don't
depend
on
parameters
like
both
from
an
implementation
perspective,
maybe
but
also
like
syntax.
How
do
we
aim
to?
How
do
we
that's
looking
for
whether
there's
like
a
free
type,
free
variable.
B
So
it's
almost
enough,
but
here.
B
B
B
B
A
B
So
right
now
this
compiles
because
in
the
context
the
const
is
evaluated
in
only
the
inputs
that
are
in
scope
from
the
module
right
from
this
crate,
which
can
only
find
the
input
for
crate
parameterized
by
unit.
But
it
should
also
find
the
t
and
u
and
therefore
find
the
set
to
be
ambiguous.
B
So
this
like,
like
will
be
like
there'll,
be
more,
there
will
be
more
cost
parameters,
and
so
this
kind
of
problem
will
be
more
pernicious
by
stabling,
constant
generics,
but
it
doesn't
introduce
any
new
scenario
and
the
problem
is
already
like
the
only
thing
we
could
find
that's
allowed
in
a
cost
context
that
could
depend
on
dispatch
in
this
way
is
these
kinds
of
associated
consts,
and
so
this
feels
like
a
pretty
like
something
that
we
might
need
to
have.
A
B
But
so
it
seems
like
for
now
we
can
just
syntactically
exclude
free
parameters
like
just.
If
the
ast
contains
a
reference
to
one,
then
this
allowed.
B
B
What
to
a
like,
yeah,
like
by
free
variable,
I
mean
yeah
when
it's
like.
You
know
on
a
nipple
block,
whatever
it's
like,
currently
an
unknown
type
or
a
constant.
B
A
A
So
parkour
writes
hardware,
I'm
not
sure
we
can
probably
allow
aggregate
data
types,
eg,
tuples
of
u32,
and
so
we're
just
saying
in
terms
of
the
set
of
types
that
we
accept.
Can
we
do
so
without
having
integer
trees.
E
D
Yeah,
I
think
I
was
conditional
on
getting
into
the
trees,
because
ollie
suggested
that
to
be
worth
blocking
conch
generics
on
the
entity
trees.
Can
you
say
a
bit
more
about
integer
trees?
D
D
E
B
B
A
E
D
C
One
of
the
big
uses-
I
know
people
want
strings
for
is
something
that
won't
even
work
until
you
have
more
complex
expression,
manipulation
because
with
what
we're
describing
eve
and
the
limitations
of
it,
even
if
we
had
strings
you
couldn't
invent
heterogeneous
lists.
I
believe.
A
Okay,
so
gosh
this
was
in
regard
to
the
discussion.
Your
question
here
that
was
in.
C
Yes,
I
wanted
to
double
check
on
the
limitations
here
that
if
you
can
have
a
generic
parameter,
but
no
expression
on
it
or
an
expression
that
contains
no
generic
parameters,
what
about
a
reference
to
a
generic
parameter
that
has
an
associated
constant?
Are
you
allowed
to
do
that
as
long
as
it's
not
in
an
expression,
or
is
that
not
allowed
yeah.
C
C
A
B
C
C
B
B
Well,
we
don't,
I
mean,
I
think
the
thing
about
it
is
that
the
main
use
case,
one
of
the
big
use
cases
for
the
type
stuff
right
now
is
this
like
crypto
hash
stuff,
where
there's
a
hash.
Trade
and
different
limitations
have
different
lengths
of
hash
outputs
and
that
will
not
be
supported
by
the
mvp,
so
they
will
still
have
to.
B
B
No,
like
crypto
hash,
like
cryptographic,
cache
like
the
libraries
that
the
cryptographic
people
in
blending
craft
cache
uses
like
that
library
uses
an
interface
that
is
abstract
over
all
hashes
and
then
each
implementation
chooses
a
length.
I
actually
don't
know.
If
there's
anyone
like
what
the
use
case
for
that
abstraction
is,
I
think
that
it
might
kind
of
be
a
bad
choice
but,
like
you,
could
just
have
different
hash
traits
for
different
lengths,
but.
B
Yeah
so
like
that,
isn't
supported
by
the
mvp,
because
it
would
feature
like
a
function
that
returns
an
array
of
an
associated
constant
length
and
that
is
not
being
allowed
by
the
mvp.
C
I
can
see
what
the
use
case
for
having
that
abstract
interface
would
be
if
you
want
to
support
an
arbitrary
hash
function.
But
you
need
to
know
how
big
the
length
is,
so
that
you
can
manipulate
values
of
that
type.
Write
them
out
that
kind
of
thing
without
having
to
deal
with
variables
at
one
time
yeah.
I'm.
B
B
C
So
what
I'm
wondering
is
we
are
preventing
people
from
doing
math
on
constants
is
what
we're
doing
going
to
push
people
towards
doing
type
level
math
themselves
by
inventing
piano
numbers
or
similar.
C
I
don't
want
to
end
up
in
a
scenario
where
we,
our
minimum
constant
mechanism,
is
useful
for
certain
things,
but
people
can
always
get
the
full
power
in
a
much
more
complicated
way,
and
this
makes
them
inclined
to
go
invent
complex
type
level
number
libraries
which,
by
the
way,
already
exist.
B
Right
right
I
mean
that's,
I
think,
that's
why
we
were
talking
about
the
crypto
hash
stuff,
because
they
do
use
piano
number.
They
use
technum
right
right,
and
so
we
won't
support
those
people
like
that's.
I
think
the
most
prominent
example
in
in
the
ecosystem
of
stone
is
currently
using
type
them
who
won't
be
able
to
switch
to
using
con
generics
with
the
mvp.
C
Right,
I
think
what
I'm
trying
to
ask
is:
does
anybody
feel
like
because
we
are
providing
some
useful
things
you
can
do
with
constant
generics?
This
will
push
people
towards
wanting
generics
more
and
then,
if
they
find
they're
in
the
subset
we
don't
support.
There
will
then
be
more
usage
of
type
level
numbers.
C
A
A
A
I
just
wanted
to
bring
up
this
idea
because
we
periodically
hit
upon,
like
we've,
we've
had
this
long
unresolved
notion
of
thinking
about
equality
and
matched
expressions,
thinking
about
equality
in
other
contexts
and
every
once
in
a
while.
We
we
talked
about
it
and
I
don't
know
I.
I
would
like
us
to
start
moving
towards
the
resolution.
At
some
point.
I
know
I
don't
intend
to
block
any.
A
I
don't
think
we
should
block
any
effort
to
make
progress
here,
but
since
we're
talking
about
constants,
I
thought
it'd
be
useful
to
ask
if,
like
kind
of
go
over
the
topic
again
and
see
if
we,
where
the
current
feeling
is.
A
A
A
Yeah
yeah
this
so.
A
I
think
kind
of
three
notions
where
equality
kind
of
winds
up
becoming
relevant
or
like,
like
there's,
obviously
dynamic
quality.
When
you
compare
things
using
the
equals
operator
which
dispatches
to
partial,
eq
or
eq,
when
they're
sort
of
when
you
match
on
something
match
on
a
constant.
A
Equal
to
each
other
and
there's
optional
opportunities
have
like
relationships
between
them.
I
don't
know
I'm
wondering
if
someone
wants
to
kind
of
summarize
the
state
of
play.
D
A
A
A
D
B
So
yeah
I
mean.
B
B
A
So,
in
terms
of
it
doesn't
seem
like
there's
a
lot
of
descent
on
this.
A
What
I,
what
are
the
next
steps
you
mentioned?
I
mean
we
have
to
make
sort
of
a
stabilization
report.
Obviously,
but
are
there
other
steps.
B
So
yeah
there's
a
here's.
The
yeah
there's
a
compiler
in
mcp
on
creating
the
feature.
D
B
A
A
The
one
that
really
stands
out
to
me
was.
We
realized
like
the
lifetime.
Religion
was
totally
wrong.
I
don't
know
if
we
expect
anything
here,
but
I
feel
like.
A
I
would
like
some
more
confidence
that
we're
actually
trying
to
use
constants
in
all
the
places
you
could
try
to
use
constants
and
we
looked
at
those
and
thought
about
it.
Maybe
that's
part
of
the
carving
out
of
the
feature,
though,
and
maybe
those
tests
already
exist,
I'm
not
I'm
not
sure.
D
B
You
know
the
stood
traits
all
exist,
so
that's
some
use
at
least,
but
but
I
think
that
async
awaited
this
like
at
this
point
last
year,
like
no
one
was
actually
using
musical
weight
in
reality.
I
think
you
know
so
like
it
wasn't
surprising.
I
guess
google
was
using
it,
but.
A
A
B
A
B
A
D
A
Okay,
any
other
comments
or
thoughts.
People
want
to
share.
I
guess
next,
the
only
other
question
is:
you
know
who's
going
to
do
some
of
this
work,
but
I
think
we'll
work
that
out
on
zulu.
You
know
to
work
out
in
the
sync
meeting
and
I
know
there's
a
lot
of
people
in
the
you
know:
who've
been
pretty
active
in
the
compiler
side
on
this
column.
C
Is
there
substantial
overlap
between
the
const
generics
minimum
subset
that
we
are
proposing
to
try
to
stabilize
and
compile
time
function
evaluation
in
so
far
as
we
should
make
sure
that
the
two
sets
of
people
are
talking
to
each
other.
C
B
But
also,
I
think
it's
worth
pointing
out
that,
like
the
way
that
they
connect
is
that
you
can
use
anything
you
can.
Constant
valve
can
now
be
used
as
an
input
right
to
a
type,
because
you
can
use
it
in
a
constant
parameter
position,
but
that
was
that's
always
been
true
for
array
length.
So
like
right,
you
can
call
a
constant
n
to
get
an
array
link
already.
E
D
B
A
Yeah,
the
only
thing
I
want
to
say
is
that,
just
generally
I
like
this,
I'm
inspired
by
this
approach.
You
know,
and
I
think
we
should
look
into
where
else
we
can
apply
it
like
I've,
been
thinking
about
a
similar
thing,
the
idea
of
carving
out
a
subset
that
is
to
make
progress.
I
know
it's,
you
know
it's
a
standard
tactic
in
our
arsenal,
but
sometimes
we
forget
yeah
do
it
for
infiltrate
in
particular,
now
we've
been
matthew,
jasper,
myself
and
a
few
others
recently
had
a
meeting
talking
about
that.
A
A
I
don't
know
I
was
thinking
about
that
question,
as
I
spoke.
I
think
maybe
like
I
don't
it's
not
quite
I
we'd
have
to
go.
I'd
have
to
go
review
exactly
what
it's
implementing
and
before
for
sure,
but
I
think
there
are.
There
certainly
is
a
one.
You
imagine
a
minimal
form
of
specialization
that
could
be
extracted,
and
that
was
like.
B
A
A
Because
it
I
want
to
make
sure
we
don't
want
to
consider
some
other
approach,
we're
happy
with
it.
I
think
we
probably
are
like
we.
In
other
words,
there
was
this
idea
of
like
well
we're
going
to
introduce
we're
going
to
allow
you
to
have
kind
of
where
clauses
and
make
choose
between
impulse,
based
on
where
clauses,
but
only
considering
the
subset
of
impulse.
They
meet
the
specialization
criteria
and
I
feel
like
we
never
fully
talk
about
that
path
and
make
sure
we're
happy
heading
down
it.
A
A
B
B
D
One
thing
I've
just
recalled
that
would
be
worth
looking
over
before
we
think
about
stabilizing.
Is
the
paper
cut
issues,
because
I
think
there
are
some
diagnostics
issues
and
there's
certainly
there's
a
problem
where,
if
you
have
types
and
constants
of
the
same
name,
for
instance,
the
flash?
Actually
this
isn't
going
to
affect
the
mvp,
but
maybe
another
similar
issue.
D
Will
the
implementation
sometimes
can't
distinguish
between
a
type
and
a
constant
with
the
same
name,
even
if
it's
in
an
ambiguous
position,
so
it'd
be
good
just
to
check
diagnostics,
to
make
sure
that
users
aren't
going
to
encounter
weird
issues
like
that.