►
From YouTube: OCapN & Agoric: Layers and Orders
Description
As presented to the OCapN standards meeting, May 23, 2023
A
Provide
the
the
big
picture
from
a
gorick's
point
of
view,
how
it
is
that
agoric
got
to
the
particular
stance
that
we
have
with
regard
to
the
the
layering
of
abstractions,
that
that
touch
on
all
the
things
that
we're
talking
about
standardizing
together
as
well
as
many
other
things
that
are
peculiar
to
agoric.
A
So
so
this
is
going
to
be
really
very
much
an
agoric-centric
presentation,
but
for
the
purpose
of
orientation
for
our
continued
collaboration
with
the
rest
of
this
group,
and
the
main
thing
is
the
layering
of
extractions
and
how
the
ordering
not
at
not
message
ordering,
but
but
ordering
of
data
types,
is
layered
through
our
system
and
what
use
we
make
of
it.
A
A
This
represents
a
concrete
description
of
an
invitation
to
join
a
option,
a
covered
call
option,
as
represented
in
our
system
of
digital
assets,
ertp
the
electronic
rights
transfer
protocol
on
up,
none
of
which
are
going
to
be
explicit
again
in
the
rest
of
the
talk,
but
this
is
a
concrete
description
of
an
individual
option
when
Fred
in
this
scenario
is
wants
to
express
what
kind
of
option
Fred
wants
such
that
someone
can
give
him
an
option
that
he
wants.
A
He
might
want
to
make
a
more
generic
expression
of
what
he
wants,
such
that
several
different,
concrete
options
might
satisfy
it,
and
this
is
this
is
a
kind
of
issue
that
comes
up
not
not
just
for
for
options
but
for
assets
in
general.
That,
rather
than
saying
specifically
I
want
this
particular
concrete
asset.
A
You
might
want
to
to
state
something
more
General,
so
we
introduce
so
in
particular,
these
the
highlighted
aspects
here
are
too
specific,
so
we've
introduced
a
pattern
language
where
Fred
can
express
that
he
doesn't
care
what
particular
instance
of
the
option
contract
he's
interested
in.
That's
why
the
mnes
here!
Oh,
can
people
see
my
mouse
move
here?
A
A
This
concrete
covered
call
code,
which
is
the
installation
and
then,
with
regard
to
the
underlying
assets,
the
one
that's
he's
trying
to
get
an
option,
for
he
might
say
instead
of
saying,
I
want
to
buy
at
exactly
three
Moolah
he's
saying:
I
want
any
amount
of
Moolah,
that's
greater
than
or
equal
to
three.
A
Okay,
if
the
if
the
expiration
date
is
in
that
interval,
so
the
important
thing
about
about
these
patterns
is
that
we'd
like
to
to
turn
these
patterns
into
queries
against
large
data
stores,
so
we'd
like
to
be
able
to
turn
them
into
queries
where
we
can
efficiently
look
up
the
subset
of
of
options
like
this
that
an
exchange
might
have
that
would
match
this
particular
query.
A
Okay,
so
so
so
the
the
elements
of
this
will
come
back
shortly.
A
Oh
sorry,
and
one
additional
thing
is
that,
instead
of
the
the
greater
than
or
equal
to
three
Mula,
three,
the
the
when
the
things
like
you
see
a
three
molar
or
a
seven
simoleons,
those
are
for
fungible
assets.
Our
system
also
has
non-fungible
and
semi-fungible
assets,
and
these
these
inequalities
like
greater
than
or
equal
to
apply
to
the
non-fungible
and
semi-fungible
assets
so
and
these
invitations
that
you're
seeing
here
are
themselves
non-fungible
or
semi-fungible
assets,
so
the
so.
A
The
underlying
that
you
might
be
asking
for
is
greater
than
or
equal
to
of
a
description
of
a
set
where
these
inequalities
over
sets
are
in
terms
of
subset
and
superset.
You're
saying
it
has
to
include
at
least
the
elements
of
this
set,
but
any
superset
of
this
set
is
also
perfectly
acceptable,
as
the
underlying
I
would
be
purchasing
and
the
important
thing
about
subsets
or
supersets
of
sets
is
that's
a
partial
order.
So
these
inequalities
in
general
can
be
partial
orders
over
the
underlying
data
type
that
they're
about.
A
A
So
the
bottom
layer
is
of
our
system
is
represented
by
the
package
with
the
package
name:
Endo,
slash
past
style,
so
the
on
the
underline
is
the
package
name,
and
this
is
the
taxonomy
of
passables,
and
this
is
really
the
core
of
what
we've
been
negotiating
and
what
I
will
continue
to
claim
is
really
the
only
thing
where
we
really
need
a
a
very,
very
strong
notion
of
interoperability.
A
We
need
these
things
to
round
trip
robustly
through
our
systems
in
order
for
us
to
get
the
interoperability
of
systems
that
we
need,
but
in
order
to
motivate
the
particular
choices
that
we've
made
here,
the
orientation
in
this
talk
will
show
what
we've
built
on
top
of
it
and
how
much
interoperation
we
get
with
those
higher
layers
is
something
that
we
should
still
explore:
the
more
interoperation,
the
better
other
things
being
equal,
but
those
are
separate
negotiations
from
the
negotiation
that
we're
currently
engaged
in
of
interoperation.
At
this
level.
A
So
the
the
next
layer
built
on
top
of
it
is
the
Endo
slash
Marshall
package,
which
defines
a
concrete
serialization
of
the
possible
data
types
into
a
serialized
form,
that's
useful
for
for
for
for
transmission
and
reception
across
different
systems.
A
The
oak
happen.
Data
types
which
correspond
to
this
passable
taxonomy
is
abstractly,
what's
supposed
to
be
language,
reasonably
language
independent,
but
with
the
the
mild
biases
towards
JavaScript
that
we've
been
talking
about
there's
some
leakage
like
the
like
the
two
bottoms.
A
And
the
make
Marshall
is
parameterized
by
two
functions:
slot
to
vowel
and
Val
to
slot,
which
is
with
regard
to
the
capability
passing
so
built
on
top
of
make
so
make.
Marshall
is
really
focused
on
the
serialized
form
for
the
data
component
of
this
passable's
taxonomy
and
is
parameterized
with
regard
to
the
capability
component,
and
then
the
capability
component
is
the
the
pro
the
cap.
A
Tp
layer
then
makes
use
of
Marshall
for
all
the
sealless
manipulation
in
order
to
do
ocap
messages
messages
over
ocaps
carrying
ocaps,
and
this
is
where
a
lot
of
the
you
know
the
the
other
crucial
thing
that
that
that
that
we
need
agreement
on
that
which
is
interoperation
at
the
level
of
capability
messages
and
preserving
capability
security.
A
This
is
where
a
lot
of
the
progress
that
you
guys
have
made
that
we
have
not
on
things
like
three-party
handoff,
come
up
at
this
layer,
and
so
so
so
let
me
let
me
just
do
a
a
correction
which
is
the
critical
things
we
need
interoperation
under
the
semantics
of
this
and
the
semantics
of
this,
and
then
the
rest
could
be
done
by
so.
A
For
example,
disagreement
on
concrete
representation
could
be
done
by
adapters
if
we
need
to,
but
but
we,
but
in
order
to
have
a
shared
notion
of
capability
security,
we
do
still
need
agreement
on
the
abstract
properties
of
of
this
and
I
think
nothing
that
I'm
saying
so
far
should
be
controversial.
A
The
sum
of
the
containers
that
we
all
want
like
sets
and
maps,
we
postponed
that
to
this
patterns
level,
because
sets
and
Maps
require
a
notion
of
comparable
equality
for
the
keys
of
the
maps
or
the
elements
of
the
set
in
order
for
a
set
to
have
a
cardinality.
A
You
have
to
know
whether
two
elements
in
this
the
elements
in
the
set
to
all
be
different
from
each
other
by
some
well-defined
notion
of
equality
by
postponing
sets
and
maps
to
this
pattern
level,
we
also
get
to
postpone
any
strong
stance
of
what
is
comparable
equality
to
this
level.
A
A
So
over
here,
the
the
we
have
a
further
taxonomy.
That's
that
that's
given
by
our
kind
of
function.
So
so
the
code
font
here
are
are
basically
representing
the
the
the
apis
that
represent
the
Core
Concepts
at
each
of
these
levels.
So
kind
of
and
compare
Keys
is
compare.
A
Keys
is
the
partial
order
that
the
patterns
are
using
and
we
have
this
capital
M
that
you
saw
on
the
previous
slide,
which
is
the
the
the
namespace
for
things
like
m
dot,
any
or
m
dot
greater
than
they're
equal
to
for
expressing
the
patterns.
A
And
then
a
representational
so
so
I'm
about
to
get
into
the
issue
of
representational
tricks
and
what
I
mean
by
representational
tricks?
Is
many
systems?
Choose
concrete
representations
that,
besides
having
the
necessary
properties
of
concretely
representing
the
abstract
semantics,
they
also
choose
a
concrete
representation
that
has
other
nice
properties
so,
for
example,
the
IEEE
floating
Point
representation,
the
concrete
representation?
A
If
you
flip
the
sign
bit,
it's
order
preserving
and
that
was
not
a
necessary
choice,
but
it
was
a
very
nice
choice,
so
it
makes
a
comparison
of
a
floating
Point
values
for
magnitude
comparison
able
to
reuse
the
ALU
comparison
logic
in
a
very
direct
manner.
Likewise,
utf-8
is
order
preserving
for
Unicode
cess
u8ces
u8
is
order
preserving
for
utf-16.
A
So
when
so,
given
that
that
there's
many
degrees
of
freedom
in
choosing
a
concrete
representation,
if
you
can,
within
those
degrees
of
freedom
without
undue
cost,
make
a
choice
that
has
nice
algebraic
properties
with
regard
to
higher
level
properties,
then
you
get
to
sort
of
collapse,
semantic
apps
issues
in
a
pleasing
manner.
A
A
rank
order
is
a
full
order
with
ties
so
whenever
anybody
talks
about
a
sort
algorithm
being
stable,
they're
implicitly,
assuming
that
the
comparison
function
for
the
sort
algorithm
is
not
just
a
full
order,
but
a
full
order
with
ties,
because
if
you
can't
have
two
different
things
tied
for
the
full
order,
then
the
notion
of
a
stable
sort
is
not
a
meaningful
concept.
A
So,
for
example,
zero
and
minus
zero.
A
We
can't
order
capabilities
in
a
permissionless
system
because,
as
the
messages
go
through,
one
C
list
after
another,
the
concrete
representation
in
terms
of
c-list
assignment
changes
and
abstractly
to
order
capabilities
created
in
different
places
in
a
permissionless
system
would
reveal
information.
That
is
no
one's
business.
So
we
have
to
consider
all
cable.
So
at
the
the
compare
Keys
level,
the
partial
order
where
things
are
meaningful,
we
want
to
say
that
two
capabilities
with
identity.
A
So,
at
the
compare
rank
level,
we
say
that
all
remotables,
all
capabilities
with
identity,
are
at
the
same
Rank
and
therefore
sorting
them
will
just
put
them
put
them
all
next
to
each
other,
separate
from
all
of
the
other
things
that
that
that
you're
sorting
and
then
a
further
representational
trick
that
we
use
oh
and
I'm
sorry
and
then
the
the
the
the
representational
trick
is
the
invariance
between
the
partial
order,
key
comparison,
which
is
the
one
that's
that
has
a
semantics
useful
to
the
application
programmer
like
the
inequalities,
the
invariance
between
that
and
the
rank
order.
A
The
further
representational
trick
is
that
one
of
the
forms
of
serialization
provided
by
the
Marshall
package
is
the
encode
passable
that
Richard
is
working
on
which
serializes
the
possible
types
into
Strings,
or
rather
into
byte
strings
in
an
in
a
rank
order
preserving
Manner,
and
that's
that's
really
a
rather
amazing
representational
trick,
and
this
is
why,
if
we
can
demonstrate
which-
which
we
hope
to
next
next
time,
we
meet
that.
There's,
no
unreasonable
cost
of
this
concrete
encoding
compared
to
other
concrete
binary
encodings.
Then
it's
very
nice
that
this
is
rank
order.
A
Preserving
as
a
choice
of
binary
cut
encoding,
then
Above
This.
A
We
have
our
system
of
defining
defensible
remotables,
which
are
remotables
protected
by
interfaces
described
with
these
patterns,
which
is
for
defensibility,
so
that
by
using
these
declarative
patterns,
we
can
filter
incoming
messages
according
to
essentially
type
like
constraints,
but
because
these
are
are
Dynamic,
including
things
like
inequalities.
A
These
constraints
can
be
somewhat
more
specific
and
messages
that
are
coming
in
that
violate
those
type-like
interface.
Constraints
can
be
rejected
before
they
hit
the
co,
the
the
raw
methods
being
of
these
remotables.
So
that's
just
nice
to
have
the
main
thing
about
these.
These
EXO
abstractions
is
they're
defined
for
virtual
they're
they're
designed
for
virtualization,
so
that
higher
levels
which
we'll
see
in
a
moment
can
can
Implement.
A
These
EXO
object,
defining
abstraction
to
define
a
large
number
of
objects,
in
particular
objects
that
spill
l
of
the
language
Heap
onto
other
data
storage
mechanisms
that
are
outside
of
the
language,
and
likewise
we
have
our
store
package,
which
is
for
mutable
tables
things
like
map
stores
and
set
Stores
which
are-
and
these
are
as
well
designed
for
virtualization
and
the
map
store,
is
a
mutable
map
in
which
the
keys
can
be
any
anything
classified
by
the
patterns
level
as
a
key
and
the
values
can
be
any
passable
value,
and
this
again
is
design
designed
for
virtualization
and
then
outside
of
the
Endo
repository
in
the
Beautiful.
A
You
define
what
virtualization
is,
because
you
yeah
I'm,
not
sure
perfect,
perfect
segue,
for
for
what
live
slots
does
so
live
slots,
which
is
part
of
the
swing
set
system.
It's
essentially
the
lib
C
of
the
swing
set
kernel.
The
swing
set
kernel
is
the
operating
system
that
we're
running,
especially
for
on-chain
computation
such
that
within
the
chain.
It
connects
multiple
Vats
directly
through
the
cap,
TP
message
passing
semantics.
A
Is
a
cryptographic
protocol
is
so
important,
but
but
within
the
kernel
between
vast
and
the
kernel,
we
just
connect
with
within
the
kernel
without
without
intra
chain
crypto,
protecting
it
with
with
more
OS
techniques
protecting
it
and
the
virtualization
is
where
you
can
have
a
size
of
data.
That
is
a
cardinality
of
data
that
exceeds
what
is
reasonable
to
store
in
the
language
heap
of
most
programming,
language
implementations
and,
in
particular,
of
the
JavaScript
implementations
that
were
running
on
chain
and
that
we're
also
running
off
chain
on
other
platforms.
A
So
Endo
runs
JavaScript,
you
know,
runs
on
any
standards,
conforming
JavaScript,
a
swing
set
which
doing
the
virtualization
specifically
uses
the
XS
JavaScript,
so
that
it
can
get
the
orthogonal
persistence.
But
part
of
our
overall
persistence
is
that
the
high
cardinality
data,
the
high
cardinality
stores,
the
stores
that
are
big.
A
The
total
number
of
instances
can
vastly
exceed
what
you
can
store
in
the
language
Heap,
but
from
the
point
of
view
of
the
application
programmer.
They
can
use
these
just
as
if
they
are
instances
in
the
language
Heap
and
that
they're
paged
in
and
out
transparently,
in
both
cases,
preserving
the
capabilities,
all
the
capability
security
properties
and
that
also
works
with
the
virtualization
of
the
c-list
management
in
the
live
slots.
A
So
very
concretely,
I
think
everybody
here
is
probably
familiar
with
the
old
make
mint
example
from
E
going
back
forever.
The
our
concrete
implementation
of
ertp
in
our
system
has
the
purses
are
virtualized.
So
you,
the
total
number
of
purses
implemented
by
a
given
mint,
can
be
huge
because
every
account
for
a
given
currency
is
a
purse
of
that
currency.
A
So
all
of
these
need
to
be
transparently
paged
out,
but
without
losing
the
capability
security
nature
of
each
individual
purse
is
designated
by
a
separate
capability
that
can
be
separately
remotely
helped.
A
A
Queries
on
this
that
can
be
efficiently
looked
up
where
the
range
query
gives
you
a
cover,
meaning
that
every
everything
that
would
match
the
pattern
is
within
the
range
according
to
the
comp
to
the,
and
that's
where
this,
the
invariant
between
compare
keys
and
compare
ranks
come
in
is
that
everything
within
the
the
inequality
interval
range
is
the
cover
contains
all
of
the
candidates.
A
But
then
the
candidates
have
to
be
further
filtered
to
see
if
they
actually
match
the
pattern.
But
that's
sort
of
the
the
normal
thing
with
any
large
data
system
is
you
have
to
have
some
kind
of
bounding
box,
some
kind
of
cover
to
efficiently
get
rid
of
the
vast
majority
of
things
that
are
that
are
known
to
be
irrelevant
such
that
you
can
then
afford
to
do
a
more
expensive,
expensive
filtering
of
the
remaining
candidates.
A
A
Here,
we've
taken
pains
to
design
them
in
very
neutral
ways
at
this
level,
there's
not
yet
any
concept
of
ertp
or
assets
or
or
or
you
know,
fungible
and
non-fungible
rights
or
invitations
or
or
any
of
that
at
this
level,
it's
still
all
defined
in
terms
of
of
of
very
widely
reusable
Concepts
that
I'm,
hoping
you'll
all
see
the
utility
of
reusing
okay.
So
so
you
know
for
for
our
system
there's.
A
Basically,
these
three
levels
of
abstraction,
where
the
kind
of
level
is
really
the
level
at
which
the
we're
doing
most
of
our
application
programming,
where
it
kind
of,
is
giving
us
a
finer
taxonomy
than
past
style
is
giving
us.
The
kind
of
is
for
the
the
patterns
level
that
we
saw
the
past
style
of
is
the
past.
Is
the
pastile
level
with
compare
rank
coming
from
that
that
Marshall
ordering
package.
A
A
According
to
the
past,
the
strings
returned
by
past
style
of
this
is
the
corresponding
JavaScript
type
of
which,
if
you're
not
a
JavaScript
programmer,
you
won't
care
about.
These
are
just
some
notes
with
regard
to
how
they
map
onto
JavaScript
and
I'll,
just
mention
some
things
the
TBD
here
is.
A
We
don't
have
support
for
the
byte
string
that
we've
all,
but
we've
all
agreed
that
the
byte
string
or
whatever
name
just
a
a
sequence
of
octets,
is
go
something
we're
going
to
support
and
we
also
have
yet
to
to
decide
what
the
string
is
for
us
and
what
the
concrete
jobs
for
representation
is.
We've
also
filed
an
issue
on
the
GitHub
that
precisely
what
the
semantics
of
the
greed
strings
are
is
not
quite
yet
settled
down,
although,
except
for
this
surrogate
issue,
I
think
we're
we're.
A
You
know,
we
know
what
we
want.
Float64
I
think
we've
all
agreed
only
one
zero,
and
only
one
Nan,
or
at
least
there
hasn't
been
any
controversy
expressed
about
that
symbols.
Agoric
has
a
mess
to
be
worked
out.
A
That
we've
also
filed
a
issue
on,
but
I
think
we've
all
agreed
about
what
the
interoperation
properties
are
here
and
then
the
occapping
capabilities
for
us
divide
into
the
very
distinct
promise
and
remotable
and
I'm
going
to
take
the
opportunity
of
this
three-part
distinction
for
remotable
to
introduce
the
notion
of
pass
invariant
the
a
lot
of
what's
happening
at
both
the
past
style
of
level.
A
And
you
know
the
and
the
patterns
level.
The
the
kind
of
level
is
to
Define
Concepts
that
are
pass
invariant
so
that
if
key
K
is
key
less
than
key
B,
as
as
the
keys
are
at
one
site
that,
if
you
pass
the
keys
from
here
to
another
site
that
the
keys
as
they
arrive
at
the
other
site
when
compared
will
have
the
same
comparison.
A
So
if
you
take
a
far
object,
a
local
far
object
with
methods
and
you
pass
it
to
a
remote
site.
It
arrives
at
the
remote
site
as
a
remote
presence.
If
you
pass
the
remote
presence
back
to
the
original
originating
site,
it
arrives
as
the
far
object.
The
JavaScript
programmer
will
see
these
for
several
purposes
as
different
things,
but
this
difference
between
local
and
remote
is
not
pass
invariant.
A
So
the
past
style
of
is
only
making
a
pass.
Invariant
classification
and
for
us
promises
are
past
invariant,
but
local
promise
versus
remote
promise
is
also
something
that
happens
on
passing,
but
the
the,
but
that
difference
is
again
not
pass
invariance
so
for
us
they're
both
classified
as
promises.
A
And
there's
useful
emerging
classification
classification
in
terms
of
higher
level
properties
over
these
possible
types
that
are
transitive
through
the
containers,
so
the
containers
form
a
containment
tree.
A
a
containment
tree
that
does
not
contain
any
remotables
or
promises
is
classified
as
just
data.
It
has
no
Authority,
it
has
no
unforgeable
identity,
anything
that
is
transitively
through
con
the
containment
tree.
Just
these
elements
conveys
only
information.
A
Okay,
now
this
is
where
this
notion
of
tagged
comes
in
and
where
the
layering
comes
in.
That
explains
why
the
tag
for
us
is
a
abstraction
that
has
very
particular
properties
that
might
have
been
surprising,
which
I
didn't
even
notice.
There
was
a
surprise
lurking
there
until
Ian
asked
his
question
on
the
GitHub
thread,
which
is
at
the
past
style
of
level.
A
We
have
a
JavaScript
object,
which
is
recognized
as
a
tagged
and
the
O
Captain
tag.
Let
me
actually
back
up
here.
The
oak
happen.
Tagged
corresponds
to
the
to
the
Past
style
of
tag,
which
is
a
particular
JavaScript
object.
We
refer
to
as
a
tagged
object,
so
at
the
past
style
of
level
of
abstraction.
The
tag
is
completely
uninterpreted,
it's
just
beyond
being
a
JavaScript
object.
That
has
a
tag
name
and
a
payload,
and
it's
left
only
to
the
higher
layers,
like
the
patterns
layer,
to
interpret
it.
A
So
the
patterns
layer,
the
the
kind
of
interpretation,
then
looks
at
the
tag
name
and
makes
a
determination.
Is
this
a
kind
of
tag
that
I
understand
and
to
understand
it?
It
has
to
have
a
tag
name
that
it's
that
it
knows
to
look
for,
like
the
tag
name
copy
set,
but
Simply
Having.
The
name
is
not
adequate
for
it
to
be
considered
for
this
tagged
to
be
classified
by
kind
of
as
a
copy
set.
A
In
addition,
the
payload,
the
value
associated
with
you
know,
portion
of
the
tagged-
has
to
obey
the
very
precise
invariance
that
this
patterns
level
is
looking
for.
That
needs
to
be
obeyed
for
it
to
actually
be
a
copy
set.
If
it
doesn't
satisfy
the
invariance,
then,
even
if
it
has
the
tag
name
copy
set,
it's
the
resulting
tagged
is
considered
to
just
be
attacked
kind
of
just
returns,
undefined,
rather
than
a
string,
giving
it
a
kind
taxonomy
so
another,
and
the
undefined
means
that
it's
not
understood
to
have
a
kind.
A
A
So
if
Alice,
who
understands
let's
say
the
patterns
and
the
keys
and
patterns
encoding,
the
coding
according
to
Eric,
the
agoric
kind
of
if
it
sees
a
tag,
that's
understood
as
a
copy
set
and
it
passes
it
to
Bob
and
Bob-
does
not
recognize
this
higher
level
kind
of
encoding
into
the
tagged.
Bob
will
still
just
treat
it
as
an
opaque.
Tagged,
object,
not
understood
to
have
a
kind,
but
will
preserve
the
representation
such
that.
If
Bob
then
passes
that
on
to
Carol.
A
That
does
understand
the
kind
of
the
kind
of
interpretation
of
it
is.
The
is
the
same
as
the
as
the
interpretation
that
Alice
had,
because
these
kind
names
is
a
shared
namespace.
We
all
know
the
the
hazards
of
share
Global
namespaces,
the
coordination.
That's
why
we
take
we
we
make
the
stringent
requirement
that
it
has
to
have
not
just
the
name,
but
the
very
precise
invariants
have
to
be
satisfied.
A
That
could
also
happen
accidentally,
but
if
it
does,
then
it
will
still
be
the
case
that
we
recognize
it
to
be
a
copy
set
now
at
this
level.
So
over
here
the
the
collections,
the
ocapin
collections,
are
divided
into
the
containers
which
are
copy,
set,
copy
bag
and
copy
map,
or
the
other
things
encoded
into
tag
which
are
somebody.
Somebody
has
background
noise.
Could
you
mute
please,
so
the
keys
are
defined
over
this
classification
as
anything?
A
That's
primitive
data
or
or
remotables
remotables
have
identity,
so
there
are
considered
keys,
because
they're,
comparable
keys
are
the
things
that
can
be
keys
of
maps
or
elements
of
sets
or
bags,
and
that's
why
the
notion
of
key
is
so
important.
Key
is
also
the
thing
that
you
can
do.
Inequalities
with
with
compare
keys,
so
they
have
the
Primitive,
datas
or
remotables
at
the
leaves
of
the
containment
hierarchy
or
arrays
records,
sets
bags
or
Maps
as
the
internal
nodes
of
the
containment
hierarchy.
A
So
anything
that's
transitive
through
the
keys
ending
in
just
primitive
data
or
remotables
are
considered
to
be
keys,
and
then
what
the
matchers
are
about
is
anything
you
know
the
same
kind
of
thing.
Anything
that's
a
tree
of
containers
in
which
the
leaves
are
primitive
data,
remotables
or
matchers.
Where
matchers
are
these
things
like
m
dot,
any
they're,
the
things
that
we
were
or
m
dot
greater
than
or
equal
to
a
given
key?
These
are
things
that
a
matcher
is
also
encoded
into
a
tag.
So
we
use
the
same
tagged
extension
thing.
A
Each
matcher
type
again
has
very
very
particular
invariance
for
it
to
be
that
particular
match
or
type,
and
each
one
has
a
tag
name
and
that's
that's
how
that's
how
we
encode
patterns-
and
the
result
is
that
our
patterns
are
also
passable,
they're,
also
passable
by
copy
and
the
matching
of
patterns
over
keys,
including
the
inequality
matching,
is
again
defined
to
be
pass
invariant.
A
A
And
then
this
weird,
this
weird
I'm
just
gonna,
let
you
know
by
the
way
that
we
are
15
minutes
over
the
meeting
time.
Oh
my
God
I
am
very
sorry.
A
This
is
actually
just
about
my
last
slide,
so
this
is
showing
the
compare
rank,
treats
the
tagged
as
opaque.
It's
doing
a
rank
ordering
of
the
tagged
without
understanding
what
the
tagged
encodes
and
therefore
is
something
that
can
be
done
at
all.
Sites,
whether
you
understand
the
higher
level,
meaning
that's
being
recognized
or
not.
Compare
Keys
is
defined
only
at
this
higher
level.
A
It's
giving
this
this
inequality
mapping,
but
it's
encoding
the
key
into
the
tagged
in
such
a
way
as
to
preserve
the
invariance
such
that
the
further
encoding
of
the
passable
data
type,
including
the
tagged
into
the
string
by
the
encode
passable,
again
preserves
the
inequality
allowing
the
efficient
lookup
by
inequalities
over
compare
keys.