features of and declaring Mapping|Set|Hash values|variables

Lately I've been wanting to cross-apply features of the Set type to 
the Mapping type, as well as of the Hash type to both of those, as I 
see all of these as being very similar to each other conceptually and 
in some cases interchangeable.

1. Looking at the language in Synopsis 6 for data types, I see:

     Set         Unordered Seqs that allow no duplicates
     Junction    Sets with additional behaviours
     Pair        Seq of two elements that serves as an one-element Mapping
     Mapping     Pairs with no duplicate keys

I would like to know if Mapping.does(Set) and whether I could use the 
full range of Set operators on them, as I would like to do?

My impression is that it be reasonable to define a generic Mapping as 
being a Set whose elements are all constrained to be Pairs, and 
further that all keys of those pairs are distinct; eg:

   subset Mapping of Set where {
     all(.members).does(Pair) and +all(.members.map:{.key}) == +all(.members)
   };

If this is true, then I suggest rewording the above line in Synopsis 
6 to better clarify the situation, like this:

     Mapping     Set of Pairs that allow no duplicate Pair keys

It would be very useful to employ Set operations like subset() or 
union() or difference() etc on Mappings, that return Mappings.  With 
such binary operators, each Mapping element has to match entirely as 
a whole Pair, having both the same key and same value.  In the case 
of union(), if any source Pairs have the same keys but different 
values, the union() would fail due to the unique key constraint, with 
similar force to dividing by zero in a non-NaN setting.

2. Similarly, I would like to know if Hash.does(Mapping) and so that 
we can therefore use all the Set and Mapping operators on Hashes, but 
that their output is Hashes.  Likewise very useful.

3. I missed the syntax for declaring anonymous Set or Mapping in the 
Synopsis.  Has it been defined yet?

Something that is distinct from:

   [1,2] # Array
   (1,2) # Seq
   {1=>2,3=>4} # Hash
   (1=>2) # Pair in positional context
   1=>2 # Pair in named context
   all(1,2,3) # Junction

Eg, do we need to use keywords:

   set(1,2,3)
   mapping(1=>2,3=>4)

Or can this be accomplished without such keywords?

I am assuming we don't have to invoke some new() because these are 
built-in basic types.

4. Since they are already known to be unique, is it possible to get 
an actual Set returned when invoking something akin to .keys or 
.pairs or a Mapping or Hash?  Or do we need to always construct such 
ourself by wrapping the call with a set() or all(), in order to use 
set operations on them?  Would the latter case be inefficient or 
verbose?

5. I'm wondering about syntax for using Sets like Junctions.  Eg, if 
I want to see if one set is a proper subset of another, can I say 
this:

   all($s1) === any($s2)

Or do I have to rewrap their members into explicit Junctions first like this:

   all($s1.members) === any($s2.members)

I am ignoring for the moment that Set probably declares named 
operators that let me do this:

   $s2.subset($s1)

I don't want to have to use the second syntax if I don't have to, 
since I like consistency with Junction syntax.

The same questions apply to using Mappings and Hashes as Sets.

6. From on my readings of Synopsis 6,9,12, it looks like you can 
declare a Hash whose keys are restricted to non-empty strings like 
this:

   subset FooName of Str where { $^n ne '' };
   subset FooHash of Hash{FooName} of Bar;

or

   subset FooHash of Hash{Str where { $^n ne '' }} of Bar;

Then if you declare a variable or routine parameter of type FooHash, 
someone can assign/pass only a Hash value to it whose keys are all 
non-empty strings.

So is that a reasonable interpretation?

7. If so, then can I use the same syntax with a Mapping, which looks 
like a Hash but that it is immutable; eg:

   subset FooMap of Mapping{FooName} of Bar;

Then if you declare a variable or routine parameter of type FooMap, 
someone can assign/pass only a Mapping value to it whose keys are all 
non-empty strings.

8. Similar question but with a Set:

   subset FooSet of Set{FooName};

Will this work to make a Set that can only have non-empty strings as members?

9. If you declare a parameter of a type that does Foo, and you pass 
an argument that is a different type that does Foo, but neither of 
them is of type Foo, will the compiler accept the binding (though it 
may fail at runtime)?

Thanks. -- Darren Duncan

• features of and declaring Mapping|Set|Hash values|variables by Darren Duncan
• Re: features of and declaring Mapping|Set|Hash values|variables by Sam Vilain