Add support for namespaced map syntax (#577)

* Add support for namespaced map syntax

* Shut up, Mypy!

Author: chrisrink10

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 ### Added
  * Added support for auto-resolving namespaces for keyword from the current namespace using the `::kw` syntax (#576)
+ * Added support for namespaced map syntax (#577)
 
 ## [v0.1.dev14] - 2020-06-18
 ### Added

src/basilisp/lang/reader.py

@@ -14,6 +14,7 @@
     Collection,
     Deque,
     Dict,
+    Hashable,
     Iterable,
     List,
     MutableMapping,
@@ -470,9 +471,9 @@ def _with_loc(f: W) -> W:
     information along with relevant forms."""
 
     @functools.wraps(f)
-    def with_lineno_and_col(ctx):
+    def with_lineno_and_col(ctx, **kwargs):
         line, col = ctx.reader.line, ctx.reader.col
-        v = f(ctx)
+        v = f(ctx, **kwargs)  # type: ignore[call-arg]
         if isinstance(v, IWithMeta):
             new_meta = lmap.map({READER_LINE_KW: line, READER_COL_KW: col})
             old_meta = v.meta
@@ -643,15 +644,42 @@ def __read_map_elems(ctx: ReaderContext) -> Iterable[RawReaderForm]:
             yield v
 
 
+def _map_key_processor(namespace: Optional[str],) -> Callable[[Hashable], Hashable]:
+    """Return a map key processor.
+
+    If no `namespace` is provided, return an identity function. If a `namespace`
+    is given, return a function that can apply namespaces to un-namespaced
+    keyword and symbol values."""
+    if namespace is None:
+        return lambda v: v
+
+    def process_key(k: Any) -> Any:
+        if isinstance(k, keyword.Keyword):
+            if k.ns is None:
+                return keyword.keyword(k.name, ns=namespace)
+            if k.ns == "_":
+                return keyword.keyword(k.name)
+        if isinstance(k, symbol.Symbol):
+            if k.ns is None:
+                return symbol.symbol(k.name, ns=namespace)
+            if k.ns == "_":
+                return symbol.symbol(k.name)
+        return k
+
+    return process_key
+
+
 @_with_loc
-def _read_map(ctx: ReaderContext) -> lmap.Map:
+def _read_map(ctx: ReaderContext, namespace: Optional[str] = None) -> lmap.Map:
     """Return a map from the input stream."""
     reader = ctx.reader
     start = reader.advance()
     assert start == "{"
     d: MutableMapping[Any, Any] = {}
+    process_key = _map_key_processor(namespace)
     try:
         for k, v in partition(list(__read_map_elems(ctx)), 2):
+            k = process_key(k)
             if k in d:
                 raise ctx.syntax_error(f"Duplicate key '{k}' in map literal")
             d[k] = v
@@ -661,6 +689,30 @@ def _read_map(ctx: ReaderContext) -> lmap.Map:
         return lmap.map(d)
 
 
+def _read_namespaced_map(ctx: ReaderContext) -> lmap.Map:
+    """Read a namespaced map from the input stream."""
+    start = ctx.reader.peek()
+    assert start == ":"
+    ctx.reader.advance()
+    if ctx.reader.peek() == ":":
+        ctx.reader.advance()
+        current_ns = get_current_ns()
+        map_ns = current_ns.name
+    else:
+        kw_ns, map_ns = _read_namespaced(ctx)
+        if kw_ns is not None:
+            raise ctx.syntax_error(
+                f"Invalid map namespace '{kw_ns}/{map_ns}'; namespaces for maps must "
+                "be specified as keywords without namespaces"
+            )
+
+    token = ctx.reader.peek()
+    while whitespace_chars.match(token):
+        token = ctx.reader.next_token()
+
+    return _read_map(ctx, namespace=map_ns)
+
+
 # Due to some ambiguities that arise in parsing symbols, numbers, and the
 # special keywords `true`, `false`, and `nil`, we have to have a looser
 # type defined for the return from these reader functions.
@@ -835,8 +887,7 @@ def _read_kw(ctx: ReaderContext) -> keyword.Keyword:
     """Return a keyword from the input stream."""
     start = ctx.reader.advance()
     assert start == ":"
-    token = ctx.reader.peek()
-    if token == ":":
+    if ctx.reader.peek() == ":":
         ctx.reader.advance()
         should_autoresolve = True
     else:
@@ -1290,6 +1341,8 @@ def _read_reader_macro(ctx: ReaderContext) -> LispReaderForm:
         return _read_set(ctx)
     elif token == "(":
         return _read_function(ctx)
+    elif token == ":":
+        return _read_namespaced_map(ctx)
     elif token == "'":
         ctx.reader.advance()
         s = _read_sym(ctx)

tests/basilisp/reader_test.py

@@ -529,6 +529,74 @@ def test_map():
         read_str_first("{:a 1 :b}")
 
 
+def test_namespaced_map(test_ns: str, ns: runtime.Namespace):
+    assert lmap.map(
+        {
+            kw.keyword("name", ns="member"): "Chris",
+            kw.keyword("gender", ns="person"): "M",
+            kw.keyword("id"): 15,
+        }
+    ) == read_str_first('#:person {:member/name "Chris" :gender "M" :_/id 15}')
+    assert lmap.map(
+        {
+            sym.symbol("name", ns="member"): "Chris",
+            sym.symbol("gender", ns="person"): "M",
+            sym.symbol("id"): 15,
+        }
+    ) == read_str_first('#:person{member/name "Chris" gender "M" _/id 15}')
+
+    with pytest.raises(reader.SyntaxError):
+        read_str_first('#:person/thing {member/name "Chris" gender "M" _/id 15}')
+
+    assert lmap.map(
+        {
+            kw.keyword("name", ns="member"): "Chris",
+            kw.keyword("gender", ns=test_ns): "M",
+            kw.keyword("id"): 15,
+        }
+    ) == read_str_first('#:: {:member/name "Chris" :gender "M" :_/id 15}')
+    assert lmap.map(
+        {
+            sym.symbol("name", ns="member"): "Chris",
+            sym.symbol("gender", ns=test_ns): "M",
+            sym.symbol("id"): 15,
+        }
+    ) == read_str_first('#::{member/name "Chris" gender "M" _/id 15}')
+
+    assert lmap.map(
+        {
+            kw.keyword("name", ns="member"): "Chris",
+            kw.keyword("gender", ns="person"): "M",
+            kw.keyword("id"): 15,
+            kw.keyword("address", ns="person"): lmap.map(
+                {kw.keyword("city"): "New York"}
+            ),
+        }
+    ) == read_str_first(
+        """
+        #:person {:member/name "Chris"
+                  :gender "M"
+                  :_/id 15
+                  :address {:city "New York"}}"""
+    )
+    assert lmap.map(
+        {
+            kw.keyword("name", ns="member"): "Chris",
+            kw.keyword("gender", ns="person"): "M",
+            kw.keyword("id"): 15,
+            kw.keyword("address", ns="person"): lmap.map(
+                {kw.keyword("city", ns="address"): "New York"}
+            ),
+        }
+    ) == read_str_first(
+        """
+            #:person {:member/name "Chris"
+                      :gender "M"
+                      :_/id 15
+                      :address #:address{:city "New York"}}"""
+    )
+
+
 def test_quoted():
     assert read_str_first("'a") == llist.l(sym.symbol("quote"), sym.symbol("a"))
     assert read_str_first("'some.ns/sym") == llist.l(