Improve docs on set-theoretic syntax reference

Author: josevalim

lib/elixir/pages/cheatsheets/types-cheat.cheatmd

@@ -82,6 +82,9 @@ empty_map()
 
 # Has the keys name and age and may have other keys (open map)
 %{..., name: binary(), age: integer()}
+
+# Has the key name, may have other keys, but age is not set
+%{..., name: binary(), age: not_set()}
 ```
 
 #### Maps with domain keys (domain keys are always treated as optional)
@@ -94,6 +97,18 @@ empty_map()
 %{..., atom() => binary(), binary() => binary()}
 ```
 
+#### Maps with mixed keys
+
+```elixir
+# Has atom keys with binary values but a `:root` key of type integer
+%{atom() => binary(), root: integer()}
+
+# Has atom keys with binary values but a `:root` key of type integer, and may have other keys
+%{..., atom() => binary(), root: integer()}
+```
+
+#### Domain keys are `atom()`, `binary()`, `integer()`, `float()`, `fun()`, `list()`, `map()`, `pid()`, `port()`, `reference()`, `tuple()`
+
 ### Non-empty lists
 
 #### Proper lists

lib/elixir/pages/references/gradual-set-theoretic-types.md

@@ -118,14 +118,30 @@ Currently, the type system only tracks the top of each individial type as the do
 %{list(integer()) => integer(), list(binary()) => binary()}
 ```
 
-That's the same as:
+That's the same as specifying all lists:
 
 ```elixir
-%{list(term()) => integer() or binary()}
+%{list() => integer() or binary()}
 ```
 
+The supported domain keys are `atom()`, `binary()`, `integer()`, `float()`, `fun()`, `list()`, `map()`, `pid()`, `port()`, `reference()`, and `tuple()`.
+
 Furthermore, it is important to note that domain keys are, by definition, optional. Whenever you have a `%{integer() => integer()}`and you try to fetch a key, we must assume the key may not exist (after all, it is not possible to store all integers as map keys as they are infinite).
 
+#### Mixed keys
+
+It is also possible to mix domain and atom keys. For example, the following map says that all atom keys are of type `binary()`, except the `:root` key, which has type `integer()`:
+
+```elixir
+# Closed map
+%{atom() => binary(), root: integer()}
+
+# Open map
+%{..., atom() => binary(), root: integer()}
+```
+
+The order of the keys is of increasing precision. `:root` is more precise than `atom()`, therefore it comes later. This mirrors the runtime semantics of maps, where duplicate keys override the value of earlier ones.
+
 ### Functions
 
 You can represent all functions as `function()`.  However, in practice, most functions are represented as arrows. For example, a function that receives an integer and return boolean would be written as `(integer() -> boolean())`. A function that receives two integers and return a string (i.e. a binary) would be written as `(integer(), integer() -> binary())`.