How is `RelShared`

intended on being used in CanCan? (It’s not fully implemented so I can only guess what the intentions are.)

The non-shared `Rel`

type is defined as:

```
public type Rel<X, Y> = {
forw : Trie.Trie2D<X, Y, ()> ;
back : Trie.Trie2D<Y, X, ()> ;
hash : HashPair<X, Y> ;
equal : EqualPair<X, Y> ;
};
```

Whereas `RelShared`

is defined as:

```
public type RelShared<X, Y> = {
forw : Trie.Trie2D<X, Y, ()> ;
//
// No HO functions, and no backward direction:
// In a serialized message form, the backward direction is redundant
// and can be recomputed in linear time from the forw field.
//
// back : Trie.Trie2D<Y, X, ()> ;
};
```

^ I’m not sure what HO means here—is it the hash and equal functions?

Also, does `RelShared`

omit the `back`

field because `RelShared`

is intended only to be used as persistent `stable`

storage with all of the actual query logic instead going to a `Rel`

data structure that’s initialized from `RelShared`

during canister creation? This way, the `back`

field in `Rel`

can be initialized from the `forw`

field in `RelShared`

in the same pass over `RelShared`

.

Related to this… I’ve heard that a canister’s stable storage limit will be increased from 4 GB to something much larger in the near future. If this is the case, then how would a, say, 80 GB stable `RelShared`

initialize a non-stable `Rel`

, if a canister’s non-stable, linear memory is still capped at 4 GB?

Thanks!