"^open" and "open:" now use aliases instead of prefixes, the same way as module aliases.

author: Eduardo Julian 2018-07-20 23:43:59 -0400
committer: Eduardo Julian 2018-07-20 23:43:59 -0400
commit: b0914546f8e8ea5ef970c1f92dbb0072aa22be63 (patch)
tree: f8ca4bf6bc4b3e8703ff1cb752a4e18b8973d3d5 /stdlib
parent: 518a7467c4e0ef904afa8c59cff3594d6f63c552 (diff)
166 files changed, 494 insertions, 506 deletions
diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux
index 392d3a504..f96062238 100644
--- a/stdlib/source/lux.lux
+++ b/stdlib/source/lux.lux
@@ -4158,6 +4158,10 @@
     #.None
     template))
 
+(def: de-alias
+  (-> Text Text Text)
+  (replace-all "."))
+
 (def: (count-ups ups input)
   (-> Nat Text Nat)
   (case ("lux text index" input "/" ups)
@@ -4245,7 +4249,7 @@
                                    #let [[openings extra] openings+extra]
                                    sub-imports (parse-imports #1 import-name extra)]
                                   (wrap (list& {#import-name import-name
-                                                #import-alias (#Some (replace-all "." m-name alias))
+                                                #import-alias (#Some (de-alias m-name alias))
                                                 #import-refer {#refer-defs referral
                                                                #refer-open openings}}
                                                sub-imports)))
@@ -4487,22 +4491,17 @@
 
 (macro: #export (^open tokens)
   {#.doc "## Same as the \"open\" macro, but meant to be used as a pattern-matching macro for generating local bindings.
-          ## Can optionally take a \"prefix\" text for the generated local bindings.
-          (def: #export (range (^open) from to)
+          ## Takes an \"alias\" text for the generated local bindings.
+          (def: #export (range (^open \".\") from to)
             (All [a] (-> (Enum a) a a (List a)))
             (range' <= succ from to))"}
   (case tokens
-    (^ (list& [_ (#Form (list))] body branches))
+    (^ (list& [_ (#Form (list [_ (#Text alias)]))] body branches))
     (do Monad<Meta>
       [g!temp (gensym "temp")]
-      (wrap (list& g!temp (` (..^open (~ g!temp) "" (~ body))) branches)))
+      (wrap (list& g!temp (` (..^open (~ g!temp) (~ (text$ alias)) (~ body))) branches)))
 
-    (^ (list& [_ (#Form (list [_ (#Text prefix)]))] body branches))
-    (do Monad<Meta>
-      [g!temp (gensym "temp")]
-      (wrap (list& g!temp (` (..^open (~ g!temp) (~ (text$ prefix)) (~ body))) branches)))
-
-    (^ (list [_ (#Symbol name)] [_ (#Text prefix)] body))
+    (^ (list [_ (#Symbol name)] [_ (#Text alias)] body))
     (do Monad<Meta>
       [init-type (find-type name)
        struct-evidence (resolve-type-tags init-type)]
@@ -4516,7 +4515,7 @@
                          (function (recur source [tags members] target)
                            (let [pattern (record$ (list/map (function (_ [t-module t-name])
                                                               [(tag$ [t-module t-name])
-                                                               (symbol$ ["" (text/compose prefix t-name)])])
+                                                               (symbol$ ["" (de-alias t-name alias)])])
                                                             tags))]
                              (do Monad<Meta>
                                [enhanced-target (monad/fold Monad<Meta>
@@ -4525,7 +4524,7 @@
                                                                 [m-structure (resolve-type-tags m-type)]
                                                                 (case m-structure
                                                                   (#Some m-tags&members)
-                                                                  (recur ["" (text/compose prefix m-name)]
+                                                                  (recur ["" (de-alias m-name alias)]
                                                                          m-tags&members
                                                                          enhanced-target)
 
@@ -4622,7 +4621,7 @@
     _
     (fail "Wrong syntax for get@")))
 
-(def: (open-field prefix [module name] source type)
+(def: (open-field alias [module name] source type)
   (-> Text Ident Code Type (Meta (List Code)))
   (do Monad<Meta>
     [output (resolve-type-tags type)
@@ -4632,67 +4631,53 @@
       (do Monad<Meta>
         [decls' (monad/map Monad<Meta>
                            (: (-> [Ident Type] (Meta (List Code)))
-                              (function (_ [sname stype]) (open-field prefix sname source+ stype)))
+                              (function (_ [sname stype]) (open-field alias sname source+ stype)))
                            (zip2 tags members))]
         (return (list/join decls')))
 
       _
-      (return (list (` ("lux def" (~ (symbol$ ["" (text/compose prefix name)])) (~ source+)
+      (return (list (` ("lux def" (~ (symbol$ ["" (de-alias name alias)]))
+                        (~ source+)
                         [(~ cursor-code) (#.Record #Nil)])))))))
 
 (macro: #export (open: tokens)
   {#.doc "## Opens a structure and generates a definition for each of its members (including nested members).
           ## For example:
-          (open: \"i:\" Number<Int>)
+          (open: \"i:.\" Number<Int>)
           ## Will generate:
           (def: i:+ (:: Number<Int> +))
           (def: i:- (:: Number<Int> -))
           (def: i:* (:: Number<Int> *))
-          ...
-
-          ## However, the prefix is optional.
-          ## For example:
-          (open: Number<Int>)
-          ## Will generate:
-          (def: + (:: Number<Int> +))
-          (def: - (:: Number<Int> -))
-          (def: * (:: Number<Int> *))
           ..."}
-  (let [[prefix tokens'] (case tokens
-                           (^ (list& [_ (#Text prefix)] tokens'))
-                           [prefix tokens']
-
-                           tokens'
-                           ["" tokens'])]
-    (case tokens'
-      (^ (list struct))
-      (case struct
-        [_ (#Symbol struct-name)]
-        (do Monad<Meta>
-          [struct-type (find-type struct-name)
-           output (resolve-type-tags struct-type)
-           #let [source (symbol$ struct-name)]]
-          (case output
-            (#Some [tags members])
-            (do Monad<Meta>
-              [decls' (monad/map Monad<Meta> (: (-> [Ident Type] (Meta (List Code)))
-                                                (function (_ [sname stype])
-                                                  (open-field prefix sname source stype)))
-                                 (zip2 tags members))]
-              (return (list/join decls')))
-
-            _
-            (fail (text/compose "Can only \"open:\" structs: " (type/show struct-type)))))
+  (case tokens
+    (^ (list [_ (#Text alias)] struct))
+    (case struct
+      [_ (#Symbol struct-name)]
+      (do Monad<Meta>
+        [struct-type (find-type struct-name)
+         output (resolve-type-tags struct-type)
+         #let [source (symbol$ struct-name)]]
+        (case output
+          (#Some [tags members])
+          (do Monad<Meta>
+            [decls' (monad/map Monad<Meta> (: (-> [Ident Type] (Meta (List Code)))
+                                              (function (_ [sname stype])
+                                                (open-field alias sname source stype)))
+                               (zip2 tags members))]
+            (return (list/join decls')))
 
-        _
-        (do Monad<Meta>
-          [g!struct (gensym "struct")]
-          (return (list (` ("lux def" (~ g!struct) (~ struct)
-                            [(~ cursor-code) (#.Record #Nil)]))
-                        (` (..open: (~ (text$ prefix)) (~ g!struct)))))))
+          _
+          (fail (text/compose "Can only \"open:\" structs: " (type/show struct-type)))))
 
       _
-      (fail "Wrong syntax for open:"))))
+      (do Monad<Meta>
+        [g!struct (gensym "struct")]
+        (return (list (` ("lux def" (~ g!struct) (~ struct)
+                          [(~ cursor-code) (#.Record #Nil)]))
+                      (` (..open: (~ (text$ alias)) (~ g!struct)))))))
+
+    _
+    (fail "Wrong syntax for open:")))
 
 (macro: #export (|>> tokens)
   {#.doc "## Similar to the piping macro, but rather than taking an initial object to work on, creates a function for taking it.
@@ -4797,9 +4782,9 @@
                                                      #Nil))]))))
                           defs')
            openings (join-map (: (-> Openings (List Code))
-                                 (function (_ [prefix structs])
+                                 (function (_ [alias structs])
                                    (list/map (function (_ name)
-                                               (` (open: (~ (text$ prefix)) (~ (symbol$ [module-name name])))))
+                                               (` (open: (~ (text$ alias)) (~ (symbol$ [module-name name])))))
                                              structs)))
                               r-opens)]]
     (wrap (list/compose defs openings))
@@ -4830,8 +4815,8 @@
                            
                            #Nothing
                            (list)))
-        openings (list/map (function (_ [prefix structs])
-                             (form$ (list& (text$ prefix) (list/map local-symbol$ structs))))
+        openings (list/map (function (_ [alias structs])
+                             (form$ (list& (text$ alias) (list/map local-symbol$ structs))))
                            r-opens)]
     (` (..refer (~ (text$ module-name))
                 (~+ localizations)
@@ -4896,10 +4881,10 @@
           (:: Codec<Text,Int> encode 123)"}
   (case tokens
     (^ (list struct [_ (#Symbol member)]))
-    (return (list (` (let [(^open) (~ struct)] (~ (symbol$ member))))))
+    (return (list (` (let [(^open ".") (~ struct)] (~ (symbol$ member))))))
 
     (^ (list& struct [_ (#Symbol member)] args))
-    (return (list (` ((let [(^open) (~ struct)] (~ (symbol$ member))) (~+ args)))))
+    (return (list (` ((let [(^open ".") (~ struct)] (~ (symbol$ member))) (~+ args)))))
     
     _
     (fail "Wrong syntax for ::")))
diff --git a/stdlib/source/lux/cli.lux b/stdlib/source/lux/cli.lux
index 10b225077..9dc6a10ce 100644
--- a/stdlib/source/lux/cli.lux
+++ b/stdlib/source/lux/cli.lux
@@ -5,8 +5,8 @@
     ["p" parser]]
    [data
     [collection
-     [list ("list/" Monoid<List> Monad<List>)]]
-    ["." text ("text/" Equivalence<Text>)
+     [list ("list/." Monoid<List> Monad<List>)]]
+    ["." text ("text/." Equivalence<Text>)
      format]
     ["E" error]]
    ["." io]
diff --git a/stdlib/source/lux/concurrency/actor.lux b/stdlib/source/lux/concurrency/actor.lux
index 971bbe01e..52bf7621d 100644
--- a/stdlib/source/lux/concurrency/actor.lux
+++ b/stdlib/source/lux/concurrency/actor.lux
@@ -3,14 +3,14 @@
    [control monad
     ["p" parser]
     ["ex" exception (#+ exception:)]]
-   ["." io (#- run) ("io/" Monad<IO>)]
+   ["." io (#- run) ("io/." Monad<IO>)]
    [data
     ["." product]
     ["e" error]
     [text
      format]
     [collection
-     ["." list ("list/" Monoid<List> Monad<List> Fold<List>)]]]
+     ["." list ("list/." Monoid<List> Monad<List> Fold<List>)]]]
    ["." macro (#+ with-gensyms Monad<Meta>)
     ["." code]
     ["s" syntax (#+ syntax: Syntax)]
@@ -23,7 +23,7 @@
     abstract]]
   [//
    ["." atom (#+ Atom atom)]
-   ["." promise (#+ Promise promise) ("promise/" Monad<Promise>)]
+   ["." promise (#+ Promise promise) ("promise/." Monad<Promise>)]
    ["." task (#+ Task)]])
 
 (exception: #export poisoned)
diff --git a/stdlib/source/lux/concurrency/frp.lux b/stdlib/source/lux/concurrency/frp.lux
index 0e777ce7a..d188a90da 100644
--- a/stdlib/source/lux/concurrency/frp.lux
+++ b/stdlib/source/lux/concurrency/frp.lux
@@ -7,7 +7,7 @@
    ["." io (#+ IO io)]
    [data
     [collection
-     [list ("list/" Monoid<List>)]]]
+     [list ("list/." Monoid<List>)]]]
    [type
     abstract]]
   [//
diff --git a/stdlib/source/lux/concurrency/stm.lux b/stdlib/source/lux/concurrency/stm.lux
index b19188a86..d736baf2e 100644
--- a/stdlib/source/lux/concurrency/stm.lux
+++ b/stdlib/source/lux/concurrency/stm.lux
@@ -9,11 +9,11 @@
     ["." product]
     ["." maybe]
     [collection
-     ["." list ("list/" Functor<List> Fold<List>)]]]
+     ["." list ("list/." Functor<List> Fold<List>)]]]
    [concurrency
     ["." atom (#+ Atom atom)]
     ["." promise (#+ Promise promise)]
-    ["." frp ("frp/" Functor<Channel>)]]
+    ["." frp ("frp/." Functor<Channel>)]]
    [type
     abstract]])
 
diff --git a/stdlib/source/lux/control/comonad.lux b/stdlib/source/lux/control/comonad.lux
index 4e294d00e..397d41f55 100644
--- a/stdlib/source/lux/control/comonad.lux
+++ b/stdlib/source/lux/control/comonad.lux
@@ -2,7 +2,7 @@
   [lux #*
    [data
     [collection
-     ["." list ("list/" Fold<List>)]]]]
+     ["." list ("list/." Fold<List>)]]]]
   [//
    ["F" functor]])
 
diff --git a/stdlib/source/lux/control/concatenative.lux b/stdlib/source/lux/control/concatenative.lux
index 7eb662a2e..f52ff2353 100644
--- a/stdlib/source/lux/control/concatenative.lux
+++ b/stdlib/source/lux/control/concatenative.lux
@@ -5,14 +5,14 @@
            r/+ r/- r/* r// r/% r/= r/< r/<= r/> r/>=
            f/+ f/- f/* f// f/% f/= f/< f/<= f/> f/>=)
    [control
-    ["p" parser ("parser/" Monad<Parser>)]
+    ["p" parser ("parser/." Monad<Parser>)]
     ["." monad]]
    [data
     ["." text
      format]
-    ["." maybe ("maybe/" Monad<Maybe>)]
+    ["." maybe ("maybe/." Monad<Maybe>)]
     [collection
-     ["." list ("list/" Fold<List> Functor<List>)]]]
+     ["." list ("list/." Fold<List> Functor<List>)]]]
    ["." macro (#+ with-gensyms Monad<Meta>)
     ["." code]
     ["s" syntax (#+ syntax:)]
diff --git a/stdlib/source/lux/control/enum.lux b/stdlib/source/lux/control/enum.lux
index 4dc825508..b5b69faf1 100644
--- a/stdlib/source/lux/control/enum.lux
+++ b/stdlib/source/lux/control/enum.lux
@@ -17,7 +17,7 @@
     (#.Cons from (range' <= succ (succ from) to))
     #.Nil))
 
-(def: #export (range (^open) from to)
+(def: #export (range (^open ".") from to)
   {#.doc "An inclusive [from, to] range of values."}
   (All [a] (-> (Enum a) a a (List a)))
   (range' <= succ from to))
diff --git a/stdlib/source/lux/control/exception.lux b/stdlib/source/lux/control/exception.lux
index 9983a7ce4..f2635b6b2 100644
--- a/stdlib/source/lux/control/exception.lux
+++ b/stdlib/source/lux/control/exception.lux
@@ -7,9 +7,9 @@
     ["/" error (#+ Error)]
     ["." maybe]
     ["." product]
-    ["." text ("text/" Monoid<Text>)]
+    ["." text ("text/." Monoid<Text>)]
     [collection
-     ["." list ("list/" Functor<List> Fold<List>)]]]
+     ["." list ("list/." Functor<List> Fold<List>)]]]
    ["." macro
     ["." code]
     ["s" syntax (#+ syntax: Syntax)]
diff --git a/stdlib/source/lux/control/interval.lux b/stdlib/source/lux/control/interval.lux
index a7de8246f..5e94aea90 100644
--- a/stdlib/source/lux/control/interval.lux
+++ b/stdlib/source/lux/control/interval.lux
@@ -32,7 +32,7 @@
 (do-template [<name> <comp>]
   [(def: #export (<name> interval)
      (All [a] (-> (Interval a) Bit))
-     (let [(^open) interval]
+     (let [(^open ".") interval]
        (<comp> bottom top)))]
 
   [inner?     >]
@@ -42,7 +42,7 @@
 
 (def: #export (within? interval elem)
   (All [a] (-> (Interval a) a Bit))
-  (let [(^open) interval]
+  (let [(^open ".") interval]
     (cond (inner? interval)
           (and (>= bottom elem)
                (<= top elem))
@@ -58,7 +58,7 @@
 (do-template [<name> <limit>]
   [(def: #export (<name> elem interval)
      (All [a] (-> a (Interval a) Bit))
-     (let [(^open) interval]
+     (let [(^open ".") interval]
        (= <limit> elem)))]
 
   [starts-with? bottom]
@@ -84,14 +84,14 @@
 
 (def: #export (complement interval)
   (All [a] (-> (Interval a) (Interval a)))
-  (let [(^open) interval]
+  (let [(^open ".") interval]
     (structure (def: enum (get@ #enum interval))
                (def: bottom (succ top))
                (def: top (pred bottom)))))
 
 (def: #export (precedes? reference sample)
   (All [a] (-> (Interval a) (Interval a) Bit))
-  (let [(^open) reference
+  (let [(^open ".") reference
         limit (:: reference bottom)]
     (and (< limit (:: sample bottom))
          (< limit (:: sample top)))))
@@ -102,7 +102,7 @@
 
 (def: #export (meets? reference sample)
   (All [a] (-> (Interval a) (Interval a) Bit))
-  (let [(^open) reference
+  (let [(^open ".") reference
         limit (:: reference bottom)]
     (and (<= limit (:: sample bottom))
          (= limit (:: sample top)))))
@@ -115,7 +115,7 @@
 (do-template [<name> <eq-side> <ineq> <ineq-side>]
   [(def: #export (<name> reference sample)
      (All [a] (-> (Interval a) (Interval a) Bit))
-     (let [(^open) reference]
+     (let [(^open ".") reference]
        (and (=      (:: reference <eq-side>)   (:: sample <eq-side>))
             (<ineq> (:: reference <ineq-side>) (:: sample <ineq-side>)))))]
 
@@ -126,7 +126,7 @@
 (do-template [<name> <comp>]
   [(def: #export (<name> reference sample)
      (All [a] (-> a (Interval a) Bit))
-     (let [(^open) sample]
+     (let [(^open ".") sample]
        (and (<comp> reference bottom)
             (<comp> reference top))))]
 
@@ -136,7 +136,7 @@
 
 (structure: #export Equivalence<Interval> (All [a] (Equivalence (Interval a)))
   (def: (= reference sample)
-    (let [(^open) reference]
+    (let [(^open ".") reference]
       (and (= bottom (:: sample bottom))
            (= top (:: sample top))))))
 
@@ -145,7 +145,7 @@
   (cond (or (singleton? sample)
             (and (inner? reference) (inner? sample))
             (and (outer? reference) (outer? sample)))
-        (let [(^open) reference]
+        (let [(^open ".") reference]
           (and (>= (:: reference bottom) (:: sample bottom))
                (<= (:: reference top) (:: sample top))))
 
@@ -154,7 +154,7 @@
         #0
 
         ## (and (outer? reference) (inner? sample))
-        (let [(^open) reference]
+        (let [(^open ".") reference]
           (or (and (>= (:: reference bottom) (:: sample bottom))
                    (> (:: reference bottom) (:: sample top)))
               (and (< (:: reference top) (:: sample bottom))
@@ -163,7 +163,7 @@
 
 (def: #export (overlaps? reference sample)
   (All [a] (-> (Interval a) (Interval a) Bit))
-  (let [(^open) reference]
+  (let [(^open ".") reference]
     (and (not (:: Equivalence<Interval> = reference sample))
          (cond (singleton? sample)
                #0
diff --git a/stdlib/source/lux/control/monad/indexed.lux b/stdlib/source/lux/control/monad/indexed.lux
index 576428512..af83464d4 100644
--- a/stdlib/source/lux/control/monad/indexed.lux
+++ b/stdlib/source/lux/control/monad/indexed.lux
@@ -5,7 +5,7 @@
     ["p" parser]]
    [data
     [collection
-     ["." list ("list/" Functor<List> Fold<List>)]]]
+     ["." list ("list/." Functor<List> Fold<List>)]]]
    ["." macro
     ["s" syntax (#+ Syntax syntax:)]]])
 
diff --git a/stdlib/source/lux/control/monoid.lux b/stdlib/source/lux/control/monoid.lux
index b841043ab..4976830b6 100644
--- a/stdlib/source/lux/control/monoid.lux
+++ b/stdlib/source/lux/control/monoid.lux
@@ -22,5 +22,5 @@
 
 (def: #export (fold Monoid<a> Fold<F> data)
   (All [a F] (-> (Monoid a) (Fold F) (F a) a))
-  (let [(^open "a/") Monoid<a>]
+  (let [(^open "a/.") Monoid<a>]
     (:: Fold<F> fold a/compose a/identity data)))
diff --git a/stdlib/source/lux/control/parser.lux b/stdlib/source/lux/control/parser.lux
index 369e4a193..2f25d13da 100644
--- a/stdlib/source/lux/control/parser.lux
+++ b/stdlib/source/lux/control/parser.lux
@@ -7,7 +7,7 @@
     [codec (#+ Codec)]]
    [data
     [collection
-     ["." list ("list/" Functor<List> Monoid<List>)]]
+     ["." list ("list/." Functor<List> Monoid<List>)]]
     ["." product]
     ["e" error (#+ Error)]]])
 
diff --git a/stdlib/source/lux/control/pipe.lux b/stdlib/source/lux/control/pipe.lux
index 2a6f4804c..a8fefb938 100644
--- a/stdlib/source/lux/control/pipe.lux
+++ b/stdlib/source/lux/control/pipe.lux
@@ -6,7 +6,7 @@
    [data
     ["e" error]
     [collection
-     ["." list ("list/" Fold<List> Monad<List>)]]]
+     ["." list ("list/." Fold<List> Monad<List>)]]]
    [macro (#+ with-gensyms)
     ["s" syntax (#+ syntax: Syntax)]
     ["." code]]])
diff --git a/stdlib/source/lux/control/region.lux b/stdlib/source/lux/control/region.lux
index 8b0b15a69..7bd43bd09 100644
--- a/stdlib/source/lux/control/region.lux
+++ b/stdlib/source/lux/control/region.lux
@@ -10,7 +10,7 @@
     [text
      format]
     [collection
-     [list ("list/" Fold<List>)]]]])
+     [list ("list/." Fold<List>)]]]])
 
 (type: (Cleaner r m)
   (-> r (m (Error Any))))
diff --git a/stdlib/source/lux/data/collection/array.lux b/stdlib/source/lux/data/collection/array.lux
index 451e4c5f2..1a9e191a8 100644
--- a/stdlib/source/lux/data/collection/array.lux
+++ b/stdlib/source/lux/data/collection/array.lux
@@ -8,7 +8,7 @@
     [predicate (#+ Predicate)]]
    [data
     [collection
-     ["." list ("list/" Fold<List>)]]
+     ["." list ("list/." Fold<List>)]]
     ["." product]]])
 
 (def: #export (new size)
diff --git a/stdlib/source/lux/data/collection/bits.lux b/stdlib/source/lux/data/collection/bits.lux
index 803654c6c..988a5b1dc 100644
--- a/stdlib/source/lux/data/collection/bits.lux
+++ b/stdlib/source/lux/data/collection/bits.lux
@@ -10,7 +10,7 @@
     [text
      format]
     [collection
-     ["." array ("array/" Fold<Array>)]]]])
+     ["." array ("array/." Fold<Array>)]]]])
 
 (type: #export Chunk I64)
 
diff --git a/stdlib/source/lux/data/collection/dictionary.lux b/stdlib/source/lux/data/collection/dictionary.lux
index adea785cf..49465c123 100644
--- a/stdlib/source/lux/data/collection/dictionary.lux
+++ b/stdlib/source/lux/data/collection/dictionary.lux
@@ -9,8 +9,8 @@
     ["." number
      ["." i64]]
     [collection
-     ["." list ("list/" Fold<List> Functor<List> Monoid<List>)]
-     ["." array ("array/" Functor<Array> Fold<Array>)]]]
+     ["." list ("list/." Fold<List> Functor<List> Monoid<List>)]
+     ["." array ("array/." Functor<Array> Fold<Array>)]]]
    ])
 
 ## This implementation of Hash Array Mapped Trie (HAMT) is based on
diff --git a/stdlib/source/lux/data/collection/dictionary/ordered.lux b/stdlib/source/lux/data/collection/dictionary/ordered.lux
index 96e989300..9e9a2ea8d 100644
--- a/stdlib/source/lux/data/collection/dictionary/ordered.lux
+++ b/stdlib/source/lux/data/collection/dictionary/ordered.lux
@@ -8,7 +8,7 @@
     ["p" product]
     ["." maybe]
     [collection
-     [list ("list/" Monoid<List> Fold<List>)]]]
+     [list ("list/." Monoid<List> Fold<List>)]]]
    ["." macro
     ["." code]
     ["s" syntax (#+ syntax: Syntax)]]])
@@ -50,7 +50,7 @@
 ## TODO: Must improve it as soon as bug is fixed.
 (def: #export (get key dict)
   (All [k v] (-> k (Dictionary k v) (Maybe v)))
-  (let [## (^open "T/") (get@ #order dict)
+  (let [## (^open "T/.") (get@ #order dict)
         ]
     (loop [node (get@ #root dict)]
       (case node
@@ -73,7 +73,7 @@
 
 (def: #export (contains? key dict)
   (All [k v] (-> k (Dictionary k v) Bit))
-  (let [## (^open "T/") (get@ #order dict)
+  (let [## (^open "T/.") (get@ #order dict)
         ]
     (loop [node (get@ #root dict)]
       (case node
@@ -246,7 +246,7 @@
 
 (def: #export (put key value dict)
   (All [k v] (-> k v (Dictionary k v) (Dictionary k v)))
-  (let [(^open "T/") (get@ #order dict)
+  (let [(^open "T/.") (get@ #order dict)
         root' (loop [?root (get@ #root dict)]
                 (case ?root
                   #.None
@@ -469,7 +469,7 @@
 
 (def: #export (remove key dict)
   (All [k v] (-> k (Dictionary k v) (Dictionary k v)))
-  (let [(^open "T/") (get@ #order dict)
+  (let [(^open "T/.") (get@ #order dict)
         [?root found?] (loop [?root (get@ #root dict)]
                          (case ?root
                            #.None
diff --git a/stdlib/source/lux/data/collection/dictionary/plist.lux b/stdlib/source/lux/data/collection/dictionary/plist.lux
index 1f16dcd77..8b2bef218 100644
--- a/stdlib/source/lux/data/collection/dictionary/plist.lux
+++ b/stdlib/source/lux/data/collection/dictionary/plist.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    [data
-    [text ("text/" Equivalence<Text>)]]])
+    [text ("text/." Equivalence<Text>)]]])
 
 (type: #export (PList a)
   (List [Text a]))
diff --git a/stdlib/source/lux/data/collection/list.lux b/stdlib/source/lux/data/collection/list.lux
index 9746fdfae..671fbfe42 100644
--- a/stdlib/source/lux/data/collection/list.lux
+++ b/stdlib/source/lux/data/collection/list.lux
@@ -26,7 +26,7 @@
       (#.Cons [x xs'])
       (fold f (f x init) xs'))))
 
-(open: Fold<List>)
+(open: "." Fold<List>)
 
 (def: #export (reverse xs)
   (All [a]
@@ -289,7 +289,7 @@
       #.Nil          ys
       (#.Cons x xs') (#.Cons x (compose xs' ys)))))
 
-(open: Monoid<List>)
+(open: "." Monoid<List>)
 
 (structure: #export _ (Functor List)
   (def: (map f ma)
@@ -297,7 +297,7 @@
       #.Nil          #.Nil
       (#.Cons a ma') (#.Cons (f a) (map f ma')))))
 
-(open: Functor<List>)
+(open: "." Functor<List>)
 
 (structure: #export _ (Apply List)
   (def: functor Functor<List>)
@@ -414,7 +414,7 @@
   (case tokens
     (^ (list [_ (#.Nat num-lists)]))
     (if (n/> +0 num-lists)
-      (let [(^open) Functor<List>
+      (let [(^open ".") Functor<List>
             indices (n/range +0 (dec num-lists))
             type-vars (: (List Code) (map (|>> nat/encode symbol$) indices))
             zip-type (` (All [(~+ type-vars)]
@@ -458,7 +458,7 @@
   (case tokens
     (^ (list [_ (#.Nat num-lists)]))
     (if (n/> +0 num-lists)
-      (let [(^open) Functor<List>
+      (let [(^open ".") Functor<List>
             indices (n/range +0 (dec num-lists))
             g!return-type (symbol$ "\treturn-type\t")
             g!func (symbol$ "\tfunc\t")
diff --git a/stdlib/source/lux/data/collection/queue.lux b/stdlib/source/lux/data/collection/queue.lux
index 76aed3a63..4973b925e 100644
--- a/stdlib/source/lux/data/collection/queue.lux
+++ b/stdlib/source/lux/data/collection/queue.lux
@@ -5,7 +5,7 @@
     ["F" functor]]
    [data
     [collection
-     ["." list ("list/" Monoid<List> Functor<List>)]]]])
+     ["." list ("list/." Monoid<List> Functor<List>)]]]])
 
 (type: #export (Queue a)
   {#front (List a)
diff --git a/stdlib/source/lux/data/collection/queue/priority.lux b/stdlib/source/lux/data/collection/queue/priority.lux
index 0e86ae070..ee1e5c1ca 100644
--- a/stdlib/source/lux/data/collection/queue/priority.lux
+++ b/stdlib/source/lux/data/collection/queue/priority.lux
@@ -5,7 +5,7 @@
     [monad (#+ do Monad)]]
    [data
     ["." maybe]
-    ["." number ("nat/" Interval<Nat>)]
+    ["." number ("nat/." Interval<Nat>)]
     [collection
      [tree
       ["." finger (#+ Tree)]]]]])
diff --git a/stdlib/source/lux/data/collection/row.lux b/stdlib/source/lux/data/collection/row.lux
index 7974c4a90..1a12e3d9f 100644
--- a/stdlib/source/lux/data/collection/row.lux
+++ b/stdlib/source/lux/data/collection/row.lux
@@ -15,8 +15,8 @@
     [number
      ["." i64]]
     [collection
-     ["." list ("list/" Fold<List> Functor<List> Monoid<List>)]
-     ["." array ("array/" Functor<Array> Fold<Array>)]]]
+     ["." list ("list/." Fold<List> Functor<List> Monoid<List>)]
+     ["." array ("array/." Functor<Array> Fold<Array>)]]]
    [macro (#+ with-gensyms)
     ["." code]
     ["s" syntax (#+ syntax: Syntax)]]])
@@ -362,7 +362,7 @@
 (structure: #export (Equivalence<Row> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Row a))))
   (def: (= v1 v2)
     (and (n/= (get@ #size v1) (get@ #size v2))
-         (let [(^open "Node/") (Equivalence<Node> Equivalence<a>)]
+         (let [(^open "Node/.") (Equivalence<Node> Equivalence<a>)]
            (and (Node/= (#Base (get@ #tail v1))
                         (#Base (get@ #tail v2)))
                 (Node/= (#Hierarchy (get@ #root v1))
@@ -382,7 +382,7 @@
 
 (structure: #export _ (Fold Row)
   (def: (fold f init xs)
-    (let [(^open) Fold<Node>]
+    (let [(^open ".") Fold<Node>]
       (fold f
             (fold f
                   init
@@ -417,9 +417,9 @@
   (def: functor Functor<Row>)
 
   (def: (apply ff fa)
-    (let [(^open) Functor<Row>
-          (^open) Fold<Row>
-          (^open) Monoid<Row>
+    (let [(^open ".") Functor<Row>
+          (^open ".") Fold<Row>
+          (^open ".") Monoid<Row>
           results (map (function (_ f) (map f fa))
                        ff)]
       (fold compose identity results))))
@@ -430,14 +430,14 @@
   (def: wrap (|>> row))
 
   (def: join
-    (let [(^open) Fold<Row>
-          (^open) Monoid<Row>]
+    (let [(^open ".") Fold<Row>
+          (^open ".") Monoid<Row>]
       (fold (function (_ post pre) (compose pre post)) identity))))
 
 (def: #export reverse
   (All [a] (-> (Row a) (Row a)))
-  (let [(^open) Fold<Row>
-        (^open) Monoid<Row>]
+  (let [(^open ".") Fold<Row>
+        (^open ".") Monoid<Row>]
     (fold add identity)))
 
 (do-template [<name> <array> <init> <op>]
diff --git a/stdlib/source/lux/data/collection/sequence.lux b/stdlib/source/lux/data/collection/sequence.lux
index d68116ae4..2f9cf3722 100644
--- a/stdlib/source/lux/data/collection/sequence.lux
+++ b/stdlib/source/lux/data/collection/sequence.lux
@@ -12,7 +12,7 @@
    [data
     bit
     [collection
-     [list ("list/" Monad<List>)]]]])
+     [list ("list/." Monad<List>)]]]])
 
 ## [Types]
 (type: #export (Sequence a)
diff --git a/stdlib/source/lux/data/collection/set.lux b/stdlib/source/lux/data/collection/set.lux
index 00c02fabe..ef39c98e0 100644
--- a/stdlib/source/lux/data/collection/set.lux
+++ b/stdlib/source/lux/data/collection/set.lux
@@ -7,7 +7,7 @@
    [data
     [collection
      ["dict" dictionary (#+ Dictionary)]
-     ["." list ("list/" Fold<List>)]]]
+     ["." list ("list/." Fold<List>)]]]
    [type
     abstract]])
 
diff --git a/stdlib/source/lux/data/collection/set/multi.lux b/stdlib/source/lux/data/collection/set/multi.lux
index e29cb126b..c4d67b8fe 100644
--- a/stdlib/source/lux/data/collection/set/multi.lux
+++ b/stdlib/source/lux/data/collection/set/multi.lux
@@ -12,7 +12,7 @@
   [////
    ["." maybe]]
   [///
-   ["." list ("list/" Fold<List>)]
+   ["." list ("list/." Fold<List>)]
    ["." dictionary (#+ Dictionary)]]
   ["." //])
 
diff --git a/stdlib/source/lux/data/collection/set/ordered.lux b/stdlib/source/lux/data/collection/set/ordered.lux
index cccfb2768..02b0307f9 100644
--- a/stdlib/source/lux/data/collection/set/ordered.lux
+++ b/stdlib/source/lux/data/collection/set/ordered.lux
@@ -5,8 +5,9 @@
     [order (#+ Order)]]
    [data
     [collection
-     ["." list ("list/" Fold<List>)]
-     [dictionary ["//" ordered]]]]
+     ["." list ("list/." Fold<List>)]
+     [dictionary
+      ["//" ordered]]]]
    [type
     abstract]])
 
diff --git a/stdlib/source/lux/data/collection/tree/rose.lux b/stdlib/source/lux/data/collection/tree/rose.lux
index 6732c0da4..414f44f31 100644
--- a/stdlib/source/lux/data/collection/tree/rose.lux
+++ b/stdlib/source/lux/data/collection/tree/rose.lux
@@ -8,7 +8,7 @@
     fold]
    [data
     [collection
-     ["." list ("list/" Monad<List> Fold<List>)]]]
+     ["." list ("list/." Monad<List> Fold<List>)]]]
    ["." macro
     ["." code]
     ["s" syntax (#+ syntax: Syntax)]]])
diff --git a/stdlib/source/lux/data/collection/tree/rose/zipper.lux b/stdlib/source/lux/data/collection/tree/rose/zipper.lux
index 7d8412985..4181bd406 100644
--- a/stdlib/source/lux/data/collection/tree/rose/zipper.lux
+++ b/stdlib/source/lux/data/collection/tree/rose/zipper.lux
@@ -4,14 +4,14 @@
     functor
     comonad]
    [data
-    ["." maybe ("maybe/" Monad<Maybe>)]
+    ["." maybe ("maybe/." Monad<Maybe>)]
     [collection
-     ["." list ("list/" Functor<List> Fold<List> Monoid<List>)]
+     ["." list ("list/." Functor<List> Fold<List> Monoid<List>)]
      ["." stack (#+ Stack)]]]
    ["." macro
     ["." code]
     ["s" syntax (#+ syntax: Syntax)]]]
-  ["." // (#+ Tree) ("tree/" Functor<Tree>)])
+  ["." // (#+ Tree) ("tree/." Functor<Tree>)])
 
 ## Adapted from the clojure.zip namespace in the Clojure standard library.
 
diff --git a/stdlib/source/lux/data/color.lux b/stdlib/source/lux/data/color.lux
index 50beed6d9..8ff70f96c 100644
--- a/stdlib/source/lux/data/color.lux
+++ b/stdlib/source/lux/data/color.lux
@@ -3,7 +3,7 @@
    [control ["eq" equivalence]]
    [data
     [collection
-     ["." list ("list/" Functor<List>)]]]
+     ["." list ("list/." Functor<List>)]]]
    ["." math]
    [type
     abstract]])
diff --git a/stdlib/source/lux/data/format/css.lux b/stdlib/source/lux/data/format/css.lux
index e2b2737d2..133beac38 100644
--- a/stdlib/source/lux/data/format/css.lux
+++ b/stdlib/source/lux/data/format/css.lux
@@ -6,7 +6,7 @@
     ["." text
      format]
     [collection
-     ["." list ("list/" Functor<List> Monoid<List>)]]]])
+     ["." list ("list/." Functor<List> Monoid<List>)]]]])
 
 (type: #export Selector
   Text)
diff --git a/stdlib/source/lux/data/format/html.lux b/stdlib/source/lux/data/format/html.lux
index b63993b3b..cc5e6d0e9 100644
--- a/stdlib/source/lux/data/format/html.lux
+++ b/stdlib/source/lux/data/format/html.lux
@@ -3,7 +3,7 @@
    [data
     ["." text
      format]
-    [collection [list ("list/" Functor<List>)]]]])
+    [collection [list ("list/." Functor<List>)]]]])
 
 (type: #export Attributes
   {#.doc "Attributes for an HTML tag."}
diff --git a/stdlib/source/lux/data/format/json.lux b/stdlib/source/lux/data/format/json.lux
index 764beab83..79510cb5c 100644
--- a/stdlib/source/lux/data/format/json.lux
+++ b/stdlib/source/lux/data/format/json.lux
@@ -6,19 +6,19 @@
     ["." monad (#+ do Monad)]
     [equivalence (#+ Equivalence)]
     codec
-    ["p" parser ("parser/" Monad<Parser>)]]
+    ["p" parser ("parser/." Monad<Parser>)]]
    [data
     ["." bit]
     ["." maybe]
     ["e" error]
     ["." sum]
     ["." product]
-    ["." number ("frac/" Codec<Text,Frac>) ("nat/" Codec<Text,Nat>)]
-    ["." text ("text/" Equivalence<Text> Monoid<Text>)
+    ["." number ("frac/." Codec<Text,Frac>) ("nat/." Codec<Text,Nat>)]
+    ["." text ("text/." Equivalence<Text> Monoid<Text>)
      ["l" lexer]]
     [collection
-     ["." list ("list/" Fold<List> Monad<List>)]
-     ["." row (#+ Row row) ("row/" Monad<Row>)]
+     ["." list ("list/." Fold<List> Monad<List>)]
+     ["." row (#+ Row row) ("row/." Monad<Row>)]
      ["dict" dictionary (#+ Dictionary)]]]
    ["." macro (#+ Monad<Meta> with-gensyms)
     ["s" syntax (#+ syntax:)]
@@ -61,7 +61,7 @@
               (json ["this" "is" "an" "array"])
               (json {"this" "is"
                      "an" "object"}))}
-  (let [(^open) Monad<Meta>
+  (let [(^open ".") Monad<Meta>
         wrapper (function (_ x) (` (..json (~ x))))]
     (case token
       (^template [<ast-tag> <ctor> <json-tag>]
diff --git a/stdlib/source/lux/data/format/xml.lux b/stdlib/source/lux/data/format/xml.lux
index e58a29c96..5e92de080 100644
--- a/stdlib/source/lux/data/format/xml.lux
+++ b/stdlib/source/lux/data/format/xml.lux
@@ -4,17 +4,17 @@
     monad
     [equivalence (#+ Equivalence)]
     codec
-    ["p" parser ("parser/" Monad<Parser>)]
+    ["p" parser ("parser/." Monad<Parser>)]
     ["ex" exception (#+ exception:)]]
    [data
     ["." number]
     ["E" error]
     ["." product]
-    ["." ident ("ident/" Equivalence<Ident> Codec<Text,Ident>)]
-    ["." text ("text/" Equivalence<Text> Monoid<Text>)
+    ["." ident ("ident/." Equivalence<Ident> Codec<Text,Ident>)]
+    ["." text ("text/." Equivalence<Text> Monoid<Text>)
      ["l" lexer]]
     [collection
-     ["." list ("list/" Monad<List>)]
+     ["." list ("list/." Monad<List>)]
      ["d" dictionary]]]])
 
 (type: #export Tag Ident)
diff --git a/stdlib/source/lux/data/ident.lux b/stdlib/source/lux/data/ident.lux
index ab8f30ab6..27d45227f 100644
--- a/stdlib/source/lux/data/ident.lux
+++ b/stdlib/source/lux/data/ident.lux
@@ -5,7 +5,7 @@
     [codec (#+ Codec)]
     hash]
    [data
-    ["." text ("text/" Monoid<Text> Hash<Text>)]]])
+    ["." text ("text/." Monoid<Text> Hash<Text>)]]])
 
 ## [Types]
 ## (type: Ident
diff --git a/stdlib/source/lux/data/number/complex.lux b/stdlib/source/lux/data/number/complex.lux
index 496116755..cc725925b 100644
--- a/stdlib/source/lux/data/number/complex.lux
+++ b/stdlib/source/lux/data/number/complex.lux
@@ -9,10 +9,10 @@
     ["p" parser]]
    [data
     ["." maybe]
-    ["." number ("frac/" Number<Frac>)]
-    [text ("text/" Monoid<Text>)]
+    ["." number ("frac/." Number<Frac>)]
+    [text ("text/." Monoid<Text>)]
     [collection
-     ["." list ("list/" Functor<List>)]]]
+     ["." list ("list/." Functor<List>)]]]
    ["." macro
     ["." code]
     ["s" syntax (#+ syntax: Syntax)]]])
diff --git a/stdlib/source/lux/data/number/ratio.lux b/stdlib/source/lux/data/number/ratio.lux
index ffa4432a5..0562dec72 100644
--- a/stdlib/source/lux/data/number/ratio.lux
+++ b/stdlib/source/lux/data/number/ratio.lux
@@ -11,8 +11,8 @@
     ["E" error]
     ["." product]
     ["." maybe]
-    [number ("nat/" Codec<Text,Nat>)]
-    ["." text ("text/" Monoid<Text>)
+    [number ("nat/." Codec<Text,Nat>)]
+    ["." text ("text/." Monoid<Text>)
      format]]
    ["." math]
    ["." macro
diff --git a/stdlib/source/lux/data/text.lux b/stdlib/source/lux/data/text.lux
index 940349f05..c29783146 100644
--- a/stdlib/source/lux/data/text.lux
+++ b/stdlib/source/lux/data/text.lux
@@ -12,7 +12,7 @@
     [number
      ["." i64]]
     [collection
-     ["." list ("list/" Fold<List>)]]]
+     ["." list ("list/." Fold<List>)]]]
    [language
     ["." host]]])
 
@@ -192,7 +192,7 @@
 
 (def: #export concat
   (-> (List Text) Text)
-  (let [(^open) Monoid<Text>]
+  (let [(^open ".") Monoid<Text>]
     (|>> list.reverse (list/fold compose identity))))
 
 (def: #export (join-with sep texts)
@@ -208,7 +208,7 @@
 (def: #export (enclose [left right] content)
   {#.doc "Surrounds the given content text with left and right side additions."}
   (-> [Text Text] Text Text)
-  (let [(^open) Monoid<Text>]
+  (let [(^open ".") Monoid<Text>]
     ($_ "lux text concat" left content right)))
 
 (def: #export (enclose' boundary content)
diff --git a/stdlib/source/lux/data/text/buffer.lux b/stdlib/source/lux/data/text/buffer.lux
index a27015f7e..a7d3da76a 100644
--- a/stdlib/source/lux/data/text/buffer.lux
+++ b/stdlib/source/lux/data/text/buffer.lux
@@ -5,7 +5,7 @@
     [text
      format]
     [collection
-     ["." row (#+ Row) ("row/" Fold<Row>)]]]
+     ["." row (#+ Row) ("row/." Fold<Row>)]]]
    [language
     ["_" host]]
    [type
diff --git a/stdlib/source/lux/data/text/format.lux b/stdlib/source/lux/data/text/format.lux
index af2b8beab..acab4c72b 100644
--- a/stdlib/source/lux/data/text/format.lux
+++ b/stdlib/source/lux/data/text/format.lux
@@ -12,7 +12,7 @@
      ["." xml]
      ["." json]]
     [collection
-     [list ("list/" Monad<List>)]]]
+     [list ("list/." Monad<List>)]]]
    [time
     ["." instant]
     ["." duration]
diff --git a/stdlib/source/lux/data/text/lexer.lux b/stdlib/source/lux/data/text/lexer.lux
index 83e732471..bd7a0ff98 100644
--- a/stdlib/source/lux/data/text/lexer.lux
+++ b/stdlib/source/lux/data/text/lexer.lux
@@ -4,7 +4,7 @@
     [monad (#+ do Monad)]
     ["p" parser]]
    [data
-    ["." text ("text/" Monoid<Text>)]
+    ["." text ("text/." Monoid<Text>)]
     ["." product]
     ["." maybe]
     ["e" error]
diff --git a/stdlib/source/lux/data/text/regex.lux b/stdlib/source/lux/data/text/regex.lux
index c7cba31c8..34505d157 100644
--- a/stdlib/source/lux/data/text/regex.lux
+++ b/stdlib/source/lux/data/text/regex.lux
@@ -2,17 +2,17 @@
   [lux #*
    [control
     monad
-    ["p" parser ("parser/" Monad<Parser>)]]
+    ["p" parser ("parser/." Monad<Parser>)]]
    [data
     ["." product]
     ["e" error]
     ["." maybe]
-    ["." number ("int/" Codec<Text,Int>)]
+    ["." number ("int/." Codec<Text,Int>)]
     ["." text
      ["l" lexer]
      format]
     [collection
-     ["." list ("list/" Fold<List> Monad<List>)]]]
+     ["." list ("list/." Fold<List> Monad<List>)]]]
    ["." macro (#+ with-gensyms)
     ["." code]
     ["s" syntax (#+ syntax:)]]])
diff --git a/stdlib/source/lux/data/text/unicode.lux b/stdlib/source/lux/data/text/unicode.lux
index a865fea1d..c9796158d 100644
--- a/stdlib/source/lux/data/text/unicode.lux
+++ b/stdlib/source/lux/data/text/unicode.lux
@@ -4,7 +4,7 @@
     ["." interval (#+ Interval)]
     [monoid (#+ Monoid)]]
    [data
-    ["." number (#+ hex) ("nat/" Interval<Nat>)]
+    ["." number (#+ hex) ("nat/." Interval<Nat>)]
     [collection
      ["." list]
      [tree
diff --git a/stdlib/source/lux/host.js.lux b/stdlib/source/lux/host.js.lux
index 022394f21..4958e0d29 100644
--- a/stdlib/source/lux/host.js.lux
+++ b/stdlib/source/lux/host.js.lux
@@ -1,13 +1,14 @@
 (.module:
-  [lux (#+)
+  [lux #*
    [control
     monad
     ["p" parser]]
-   [data [collection [list #* ("list/" Fold<List>)]]]
+   [data
+    [collection
+     [list #* ("list/." Fold<List>)]]]
    [macro (#+ with-gensyms)
-    [code]
-    ["s" syntax (#+ syntax: Syntax)]]
-   ])
+    ["." code]
+    ["s" syntax (#+ syntax: Syntax)]]])
 
 (do-template [<name> <type>]
   [(type: #export <name> (#.Primitive <type> #.Nil))]
diff --git a/stdlib/source/lux/host.jvm.lux b/stdlib/source/lux/host.jvm.lux
index acccabc77..fe72467bf 100644
--- a/stdlib/source/lux/host.jvm.lux
+++ b/stdlib/source/lux/host.jvm.lux
@@ -10,17 +10,17 @@
     ["." maybe]
     ["." product]
     ["." error (#+ Error)]
-    [bit ("bit/" Codec<Text,Bit>)]
+    [bit ("bit/." Codec<Text,Bit>)]
     number
-    ["." text ("text/" Equivalence<Text> Monoid<Text>)
+    ["." text ("text/." Equivalence<Text> Monoid<Text>)
      format]
     [collection
-     ["." list ("list/" Monad<List> Fold<List> Monoid<List>)]]]
+     ["." list ("list/." Monad<List> Fold<List> Monoid<List>)]]]
    ["." macro (#+ with-gensyms Functor<Meta> Monad<Meta>)
     ["." code]
     ["s" syntax (#+ syntax: Syntax)]]
    [language
-    ["." type ("type/" Equivalence<Type>)]]
+    ["." type ("type/." Equivalence<Type>)]]
    ])
 
 (do-template [<name> <op> <from> <to>]
@@ -641,7 +641,7 @@
 
 (def: privacy-modifier^
   (Syntax PrivacyModifier)
-  (let [(^open) p.Monad<Parser>]
+  (let [(^open ".") p.Monad<Parser>]
     ($_ p.alt
         (s.this (' #public))
         (s.this (' #private))
@@ -650,7 +650,7 @@
 
 (def: inheritance-modifier^
   (Syntax InheritanceModifier)
-  (let [(^open) p.Monad<Parser>]
+  (let [(^open ".") p.Monad<Parser>]
     ($_ p.alt
         (s.this (' #final))
         (s.this (' #abstract))
@@ -1119,7 +1119,7 @@
   (-> Type-Paramameter JVM-Code)
   (format "(" name " " (spaced (list/map generic-type$ bounds)) ")"))
 
-(def: (class-decl$ (^open))
+(def: (class-decl$ (^open "."))
   (-> Class-Declaration JVM-Code)
   (format "(" (sanitize class-name) " " (spaced (list/map type-param$ class-params)) ")"))
 
@@ -1771,7 +1771,7 @@
 
       (#FieldAccessDecl fad)
       (do Monad<Meta>
-        [#let [(^open) fad
+        [#let [(^open ".") fad
                base-gtype (class->type import-field-mode type-params import-field-type)
                classC (class-decl-type$ class)
                typeC (if import-field-maybe?
diff --git a/stdlib/source/lux/language/compiler/analysis.lux b/stdlib/source/lux/language/compiler/analysis.lux
index 3c4a646fe..4b8a19c66 100644
--- a/stdlib/source/lux/language/compiler/analysis.lux
+++ b/stdlib/source/lux/language/compiler/analysis.lux
@@ -3,9 +3,9 @@
    [data
     ["." product]
     ["." error]
-    [text ("text/" Equivalence<Text>)]
+    [text ("text/." Equivalence<Text>)]
     [collection
-     ["." list ("list/" Fold<List>)]]]
+     ["." list ("list/." Fold<List>)]]]
    ["." function]]
   [//
    ["." extension (#+ Extension)]
diff --git a/stdlib/source/lux/language/compiler/analysis/case.lux b/stdlib/source/lux/language/compiler/analysis/case.lux
index 34a2b38d6..09a045e8c 100644
--- a/stdlib/source/lux/language/compiler/analysis/case.lux
+++ b/stdlib/source/lux/language/compiler/analysis/case.lux
@@ -10,7 +10,7 @@
     [text
      format]
     [collection
-     ["." list ("list/" Fold<List> Monoid<List> Functor<List>)]]]
+     ["." list ("list/." Fold<List> Monoid<List> Functor<List>)]]]
    ["." macro
     ["." code]]]
   ["." // (#+ Pattern Analysis Operation Compiler)
diff --git a/stdlib/source/lux/language/compiler/analysis/case/coverage.lux b/stdlib/source/lux/language/compiler/analysis/case/coverage.lux
index 5c3ff1d72..24ded5476 100644
--- a/stdlib/source/lux/language/compiler/analysis/case/coverage.lux
+++ b/stdlib/source/lux/language/compiler/analysis/case/coverage.lux
@@ -5,16 +5,16 @@
     ["ex" exception (#+ exception:)]
     equivalence]
    [data
-    [bit ("bit/" Equivalence<Bit>)]
+    [bit ("bit/." Equivalence<Bit>)]
     ["." number]
-    ["e" error ("error/" Monad<Error>)]
+    ["e" error ("error/." Monad<Error>)]
     ["." maybe]
     [text
      format]
     [collection
-     ["." list ("list/" Fold<List>)]
+     ["." list ("list/." Fold<List>)]
      ["dict" dictionary (#+ Dictionary)]]]]
-  ["." //// ("operation/" Monad<Operation>)]
+  ["." //// ("operation/." Monad<Operation>)]
   ["." /// (#+ Pattern Variant Operation)])
 
 (def: cases
@@ -175,7 +175,7 @@
       _
       #0)))
 
-(open: "coverage/" Equivalence<Coverage>)
+(open: "coverage/." Equivalence<Coverage>)
 
 ## After determining the coverage of each individual pattern, it is
 ## necessary to merge them all to figure out if the entire
diff --git a/stdlib/source/lux/language/compiler/analysis/function.lux b/stdlib/source/lux/language/compiler/analysis/function.lux
index 440c49237..cc431f9b6 100644
--- a/stdlib/source/lux/language/compiler/analysis/function.lux
+++ b/stdlib/source/lux/language/compiler/analysis/function.lux
@@ -8,7 +8,7 @@
     ["." text
      format]
     [collection
-     ["." list ("list/" Fold<List> Monoid<List> Monad<List>)]]]
+     ["." list ("list/." Fold<List> Monoid<List> Monad<List>)]]]
    ["." macro]
    [language
     ["." type
diff --git a/stdlib/source/lux/language/compiler/analysis/inference.lux b/stdlib/source/lux/language/compiler/analysis/inference.lux
index 29084ce40..e068f073a 100644
--- a/stdlib/source/lux/language/compiler/analysis/inference.lux
+++ b/stdlib/source/lux/language/compiler/analysis/inference.lux
@@ -8,12 +8,12 @@
     ["." text
      format]
     [collection
-     ["." list ("list/" Functor<List>)]]]
+     ["." list ("list/." Functor<List>)]]]
    ["." macro]]
   [////
    ["." type
     ["tc" check]]]
-  ["." /// ("operation/" Monad<Operation>)
+  ["." /// ("operation/." Monad<Operation>)
    ["." extension]]
   [// (#+ Tag Analysis Operation Compiler)]
   ["." //type])
diff --git a/stdlib/source/lux/language/compiler/analysis/module.lux b/stdlib/source/lux/language/compiler/analysis/module.lux
index 7c21724bb..adc442c1f 100644
--- a/stdlib/source/lux/language/compiler/analysis/module.lux
+++ b/stdlib/source/lux/language/compiler/analysis/module.lux
@@ -5,11 +5,11 @@
     ["ex" exception (#+ exception:)]
     pipe]
    [data
-    ["." text ("text/" Equivalence<Text>)
+    ["." text ("text/." Equivalence<Text>)
      format]
     ["." error]
     [collection
-     ["." list ("list/" Fold<List> Functor<List>)]
+     ["." list ("list/." Fold<List> Functor<List>)]
      [dictionary
       ["." plist]]]]
    ["." macro]]
diff --git a/stdlib/source/lux/language/compiler/analysis/reference.lux b/stdlib/source/lux/language/compiler/analysis/reference.lux
index 5949c0036..4fdbde5c2 100644
--- a/stdlib/source/lux/language/compiler/analysis/reference.lux
+++ b/stdlib/source/lux/language/compiler/analysis/reference.lux
@@ -8,7 +8,7 @@
     [type
      ["tc" check]]]
    [data
-    [text ("text/" Equivalence<Text>)
+    [text ("text/." Equivalence<Text>)
      format]]]
   ["." // (#+ Analysis Operation)
    ["." scope]
diff --git a/stdlib/source/lux/language/compiler/analysis/scope.lux b/stdlib/source/lux/language/compiler/analysis/scope.lux
index a10ed6e58..108e450e1 100644
--- a/stdlib/source/lux/language/compiler/analysis/scope.lux
+++ b/stdlib/source/lux/language/compiler/analysis/scope.lux
@@ -3,13 +3,13 @@
    [control
     monad]
    [data
-    [text ("text/" Equivalence<Text>)
+    [text ("text/." Equivalence<Text>)
      format]
-    ["." maybe ("maybe/" Monad<Maybe>)]
+    ["." maybe ("maybe/." Monad<Maybe>)]
     ["." product]
     ["e" error]
     [collection
-     ["." list ("list/" Functor<List> Fold<List> Monoid<List>)]
+     ["." list ("list/." Functor<List> Fold<List> Monoid<List>)]
      [dictionary
       ["." plist]]]]]
   [// (#+ Operation Compiler)
@@ -121,7 +121,7 @@
                            output]))
 
             _
-            (error! "Invalid scope alteration/"))
+            (error! "Invalid scope alteration."))
 
           (#e.Error error)
           (#e.Error error)))
diff --git a/stdlib/source/lux/language/compiler/analysis/structure.lux b/stdlib/source/lux/language/compiler/analysis/structure.lux
index d3ce95cdd..77a0487c5 100644
--- a/stdlib/source/lux/language/compiler/analysis/structure.lux
+++ b/stdlib/source/lux/language/compiler/analysis/structure.lux
@@ -11,7 +11,7 @@
     [text
      format]
     [collection
-     ["." list ("list/" Functor<List>)]
+     ["." list ("list/." Functor<List>)]
      ["dict" dictionary (#+ Dictionary)]]]
    ["." macro
     ["." code]]]
diff --git a/stdlib/source/lux/language/compiler/extension/analysis/common.lux b/stdlib/source/lux/language/compiler/extension/analysis/common.lux
index 0dc405438..7f3c4d947 100644
--- a/stdlib/source/lux/language/compiler/extension/analysis/common.lux
+++ b/stdlib/source/lux/language/compiler/extension/analysis/common.lux
@@ -10,11 +10,12 @@
     ["." text
      format]
     [collection
-     ["." list ("list/" Functor<List>)]
+     ["." list ("list/." Functor<List>)]
      ["." array]
      ["dict" dictionary (#+ Dictionary)]]]
    ["." language
-    [type ["tc" check]]]
+    [type
+     ["tc" check]]]
    [io (#+ IO)]]
   ["." ////
    ["." analysis (#+ Analysis Handler Bundle)
diff --git a/stdlib/source/lux/language/compiler/extension/analysis/host.jvm.lux b/stdlib/source/lux/language/compiler/extension/analysis/host.jvm.lux
index ef5e9317f..24d3948b0 100644
--- a/stdlib/source/lux/language/compiler/extension/analysis/host.jvm.lux
+++ b/stdlib/source/lux/language/compiler/extension/analysis/host.jvm.lux
@@ -9,10 +9,10 @@
     ["e" error]
     ["." maybe]
     ["." product]
-    ["." text ("text/" Equivalence<Text>)
+    ["." text ("text/." Equivalence<Text>)
      format]
     [collection
-     ["." list ("list/" Fold<List> Functor<List> Monoid<List>)]
+     ["." list ("list/." Fold<List> Functor<List> Monoid<List>)]
      ["." array]
      ["." dictionary (#+ Dictionary)]]]
    ["." macro
@@ -25,7 +25,7 @@
    ["." common]
    ["/." //
     ["." bundle]
-    ["//." // ("operation/" Monad<Operation>)
+    ["//." // ("operation/." Monad<Operation>)
      ["." analysis (#+ Analysis Operation Handler Bundle)
       [".A" type]
       [".A" inference]]]]]
diff --git a/stdlib/source/lux/language/compiler/extension/bundle.lux b/stdlib/source/lux/language/compiler/extension/bundle.lux
index dce95cfb1..e2d36fa73 100644
--- a/stdlib/source/lux/language/compiler/extension/bundle.lux
+++ b/stdlib/source/lux/language/compiler/extension/bundle.lux
@@ -7,7 +7,7 @@
     ["." text
      format]
     [collection
-     [list ("list/" Functor<List>)]
+     [list ("list/." Functor<List>)]
      ["dict" dictionary (#+ Dictionary)]]]]
   [// (#+ Handler Bundle)])
 
diff --git a/stdlib/source/lux/language/compiler/meta/cache.lux b/stdlib/source/lux/language/compiler/meta/cache.lux
index 59d2f3c3b..bacd339a9 100644
--- a/stdlib/source/lux/language/compiler/meta/cache.lux
+++ b/stdlib/source/lux/language/compiler/meta/cache.lux
@@ -5,7 +5,7 @@
     ["ex" exception (#+ exception:)]
     pipe]
    [data
-    ["." bit ("bit/" Equivalence<Bit>)]
+    ["." bit ("bit/." Equivalence<Bit>)]
     ["." maybe]
     ["." error]
     ["." product]
@@ -14,7 +14,7 @@
     ["." text
      format]
     [collection
-     ["." list ("list/" Functor<List> Fold<List>)]
+     ["." list ("list/." Functor<List> Fold<List>)]
      ["dict" dictionary (#+ Dictionary)]
      ["." set (#+ Set)]]]
    [world
diff --git a/stdlib/source/lux/language/compiler/meta/cache/dependency.lux b/stdlib/source/lux/language/compiler/meta/cache/dependency.lux
index 6f7994c92..e63fa192b 100644
--- a/stdlib/source/lux/language/compiler/meta/cache/dependency.lux
+++ b/stdlib/source/lux/language/compiler/meta/cache/dependency.lux
@@ -3,7 +3,7 @@
    [data
     ["." text]
     [collection
-     [list ("list/" Functor<List> Fold<List>)]
+     [list ("list/." Functor<List> Fold<List>)]
      ["dict" dictionary (#+ Dictionary)]]]]
   [///io (#+ Module)]
   [///archive (#+ Archive)])
diff --git a/stdlib/source/lux/language/compiler/synthesis/case.lux b/stdlib/source/lux/language/compiler/synthesis/case.lux
index 8301e11aa..2ef9b735e 100644
--- a/stdlib/source/lux/language/compiler/synthesis/case.lux
+++ b/stdlib/source/lux/language/compiler/synthesis/case.lux
@@ -6,15 +6,15 @@
     ["." monad (#+ do)]]
    [data
     ["." product]
-    [bit ("bit/" Equivalence<Bit>)]
-    [text ("text/" Equivalence<Text>)
+    [bit ("bit/." Equivalence<Bit>)]
+    [text ("text/." Equivalence<Text>)
      format]
-    [number ("frac/" Equivalence<Frac>)]
+    [number ("frac/." Equivalence<Frac>)]
     [collection
-     ["." list ("list/" Fold<List> Monoid<List>)]]]]
+     ["." list ("list/." Fold<List> Monoid<List>)]]]]
   ["." // (#+ Path Synthesis Operation Compiler)
    ["." function]
-   ["/." // ("operation/" Monad<Operation>)
+   ["/." // ("operation/." Monad<Operation>)
     ["." analysis (#+ Pattern Match Analysis)]
     [//
      ["." reference]]]])
diff --git a/stdlib/source/lux/language/compiler/synthesis/expression.lux b/stdlib/source/lux/language/compiler/synthesis/expression.lux
index e122afc32..64f802089 100644
--- a/stdlib/source/lux/language/compiler/synthesis/expression.lux
+++ b/stdlib/source/lux/language/compiler/synthesis/expression.lux
@@ -5,12 +5,12 @@
    [data
     ["." maybe]
     [collection
-     ["." list ("list/" Functor<List>)]
+     ["." list ("list/." Functor<List>)]
      ["dict" dictionary (#+ Dictionary)]]]]
   ["." // (#+ Synthesis Compiler)
    ["." function]
    ["." case]
-   ["/." // ("operation/" Monad<Operation>)
+   ["/." // ("operation/." Monad<Operation>)
     ["." analysis (#+ Analysis)]
     ["." extension]
     [//
diff --git a/stdlib/source/lux/language/compiler/synthesis/function.lux b/stdlib/source/lux/language/compiler/synthesis/function.lux
index 05f1c2e96..4e72c022f 100644
--- a/stdlib/source/lux/language/compiler/synthesis/function.lux
+++ b/stdlib/source/lux/language/compiler/synthesis/function.lux
@@ -6,10 +6,10 @@
     pipe
     ["ex" exception (#+ exception:)]]
    [data
-    ["." maybe ("maybe/" Monad<Maybe>)]
+    ["." maybe ("maybe/." Monad<Maybe>)]
     ["." error]
     [collection
-     ["." list ("list/" Functor<List> Monoid<List> Fold<List>)]
+     ["." list ("list/." Functor<List> Monoid<List> Fold<List>)]
      ["dict" dictionary (#+ Dictionary)]]]]
   ["." // (#+ Synthesis Operation Compiler)
    ["." loop (#+ Transform)]
diff --git a/stdlib/source/lux/language/compiler/synthesis/loop.lux b/stdlib/source/lux/language/compiler/synthesis/loop.lux
index 033d5e70e..661d29a83 100644
--- a/stdlib/source/lux/language/compiler/synthesis/loop.lux
+++ b/stdlib/source/lux/language/compiler/synthesis/loop.lux
@@ -4,9 +4,9 @@
     ["." monad (#+ do)]
     ["p" parser]]
    [data
-    ["." maybe ("maybe/" Monad<Maybe>)]
+    ["." maybe ("maybe/." Monad<Maybe>)]
     [collection
-     ["." list ("list/" Functor<List>)]]]
+     ["." list ("list/." Functor<List>)]]]
    [macro
     ["." code]
     ["." syntax]]]
diff --git a/stdlib/source/lux/language/compiler/translation.lux b/stdlib/source/lux/language/compiler/translation.lux
index 462c61ec5..32c8fb601 100644
--- a/stdlib/source/lux/language/compiler/translation.lux
+++ b/stdlib/source/lux/language/compiler/translation.lux
@@ -6,7 +6,7 @@
    [data
     ["." product]
     ["." error (#+ Error)]
-    [ident ("ident/" Equivalence<Ident> Codec<Text,Ident>)]
+    [ident ("ident/." Equivalence<Ident> Codec<Text,Ident>)]
     ["." text
      format]
     [collection
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/case.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/case.jvm.lux
index d2e9d8d98..11c6f3e3d 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/case.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/case.jvm.lux
@@ -8,12 +8,12 @@
     ["." text
      format]
     [collection
-     [list ("list/" Functor<List> Fold<List>)]
+     [list ("list/." Functor<List> Fold<List>)]
      [set (#+ Set)]]]]
   [//
    ["." runtime (#+ Operation Compiler)]
    ["." reference]
-   ["/." /// ("operation/" Monad<Operation>)
+   ["/." /// ("operation/." Monad<Operation>)
     ["." synthesis (#+ Synthesis Path)]
     [//
      [reference (#+ Register)]
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/extension/common.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/extension/common.jvm.lux
index 289634a4b..786b82280 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/extension/common.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/extension/common.jvm.lux
@@ -10,7 +10,7 @@
      format]
     [number (#+ hex)]
     [collection
-     ["." list ("list/" Functor<List>)]
+     ["." list ("list/." Functor<List>)]
      ["dict" dictionary (#+ Dictionary)]]]
    ["." macro (#+ with-gensyms)
     ["." code]
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/function.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/function.jvm.lux
index 01531069e..17022587c 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/function.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/function.jvm.lux
@@ -8,12 +8,12 @@
     [text
      format]
     [collection
-     ["." list ("list/" Functor<List>)]]]]
+     ["." list ("list/." Functor<List>)]]]]
   [//
    ["." runtime (#+ Operation Compiler)]
    ["." reference]
    ["/." //
-    ["//." // ("operation/" Monad<Operation>)
+    ["//." // ("operation/." Monad<Operation>)
      [analysis (#+ Variant Tuple Environment Arity Abstraction Application Analysis)]
      [synthesis (#+ Synthesis)]
      [//
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/loop.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/loop.jvm.lux
index 9863cf4ed..8c73f77e4 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/loop.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/loop.jvm.lux
@@ -7,7 +7,7 @@
     ["." text
      format]
     [collection
-     ["." list ("list/" Functor<List>)]]]]
+     ["." list ("list/." Functor<List>)]]]]
   [//
    [runtime (#+ Operation Compiler)]
    ["." reference]
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/primitive.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/primitive.jvm.lux
index 9c64aad05..a8fa6326f 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/primitive.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/primitive.jvm.lux
@@ -4,7 +4,7 @@
   [/////
    [host
     ["_" scheme (#+ Expression)]]
-   [compiler ("operation/" Monad<Operation>)]]
+   [compiler ("operation/." Monad<Operation>)]]
   [//runtime (#+ Operation)])
 
 (def: #export bit
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/reference.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/reference.jvm.lux
index 6828f6d14..db56d8937 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/reference.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/reference.jvm.lux
@@ -7,7 +7,7 @@
      format]]]
   [//
    [runtime (#+ Operation)]
-   [/// ("operation/" Monad<Operation>)
+   [/// ("operation/." Monad<Operation>)
     [analysis (#+ Variant Tuple)]
     [synthesis (#+ Synthesis)]
     [//
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/runtime.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/runtime.jvm.lux
index a2f2250ef..565cbeabd 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/runtime.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/runtime.jvm.lux
@@ -1,14 +1,14 @@
 (.module:
   [lux #*
    [control
-    ["p" parser ("parser/" Monad<Parser>)]
+    ["p" parser ("parser/." Monad<Parser>)]
     [monad (#+ do)]]
    [data
     [number (#+ hex)]
     [text
      format]
     [collection
-     ["." list ("list/" Monad<List>)]]]
+     ["." list ("list/." Monad<List>)]]]
    ["." function]
    [macro
     ["." code]
diff --git a/stdlib/source/lux/language/host/scheme.lux b/stdlib/source/lux/language/host/scheme.lux
index bdcd64990..8d5cbdbcd 100644
--- a/stdlib/source/lux/language/host/scheme.lux
+++ b/stdlib/source/lux/language/host/scheme.lux
@@ -7,7 +7,7 @@
     ["." text
      format]
     [collection
-     ["." list ("list/" Functor<List> Fold<List>)]]]
+     ["." list ("list/." Functor<List> Fold<List>)]]]
    [type
     abstract]])
 
diff --git a/stdlib/source/lux/language/syntax.lux b/stdlib/source/lux/language/syntax.lux
index ebe2c3511..41c11ee2d 100644
--- a/stdlib/source/lux/language/syntax.lux
+++ b/stdlib/source/lux/language/syntax.lux
@@ -28,7 +28,7 @@
   [lux (#- nat int rev)
    [control
     monad
-    ["p" parser ("parser/" Monad<Parser>)]
+    ["p" parser ("parser/." Monad<Parser>)]
     ["ex" exception (#+ exception:)]]
    [data
     ["e" error]
diff --git a/stdlib/source/lux/language/type.lux b/stdlib/source/lux/language/type.lux
index a3ae7aa91..9d774198d 100644
--- a/stdlib/source/lux/language/type.lux
+++ b/stdlib/source/lux/language/type.lux
@@ -5,12 +5,12 @@
     [monad (#+ do Monad)]
     ["p" parser]]
    [data
-    ["." text ("text/" Monoid<Text> Equivalence<Text>)]
-    [ident ("ident/" Equivalence<Ident> Codec<Text,Ident>)]
-    [number ("nat/" Codec<Text,Nat>)]
+    ["." text ("text/." Monoid<Text> Equivalence<Text>)]
+    [ident ("ident/." Equivalence<Ident> Codec<Text,Ident>)]
+    [number ("nat/." Codec<Text,Nat>)]
     ["." maybe]
     [collection
-     ["." list ("list/" Functor<List> Monoid<List> Fold<List>)]]]
+     ["." list ("list/." Functor<List> Monoid<List> Fold<List>)]]]
    ["." macro
     ["." code]
     ["s" syntax (#+ Syntax syntax:)]]])
diff --git a/stdlib/source/lux/language/type/check.lux b/stdlib/source/lux/language/type/check.lux
index 990a0261c..3f9812d0b 100644
--- a/stdlib/source/lux/language/type/check.lux
+++ b/stdlib/source/lux/language/type/check.lux
@@ -9,13 +9,13 @@
     ["." maybe]
     ["." product]
     ["e" error]
-    ["." number ("nat/" Codec<Text,Nat>)]
-    [text ("text/" Monoid<Text> Equivalence<Text>)]
+    ["." number ("nat/." Codec<Text,Nat>)]
+    [text ("text/." Monoid<Text> Equivalence<Text>)]
     [collection
      ["." list]
      ["." set (#+ Set)]]]
    [language
-    ["." type ("type/" Equivalence<Type>)]]
+    ["." type ("type/." Equivalence<Type>)]]
    ])
 
 (exception: #export (unknown-type-var {id Nat})
@@ -101,7 +101,7 @@
         )))
   )
 
-(open: "check/" Monad<Check>)
+(open: "check/." Monad<Check>)
 
 (def: (var::get id plist)
   (-> Var Type-Vars (Maybe (Maybe Type)))
diff --git a/stdlib/source/lux/macro.lux b/stdlib/source/lux/macro.lux
index bbe93cbd1..64dfcff24 100644
--- a/stdlib/source/lux/macro.lux
+++ b/stdlib/source/lux/macro.lux
@@ -6,13 +6,13 @@
     ["." monad (#+ do Monad)]]
    [data
     ["." product]
-    [ident ("ident/" Codec<Text,Ident> Equivalence<Ident>)]
+    [ident ("ident/." Codec<Text,Ident> Equivalence<Ident>)]
     ["." maybe]
     ["e" error]
-    ["." number ("nat/" Codec<Text,Nat>)]
-    ["." text ("text/" Monoid<Text> Equivalence<Text>)]
+    ["." number ("nat/." Codec<Text,Nat>)]
+    ["." text ("text/." Monoid<Text> Equivalence<Text>)]
     [collection
-     ["." list ("list/" Monoid<List> Monad<List>)]]]]
+     ["." list ("list/." Monoid<List> Monad<List>)]]]]
   [/
    ["." code]])
 
@@ -616,7 +616,7 @@
 
 (def: #export (imported? import)
   (-> Text (Meta Bit))
-  (let [(^open) Monad<Meta>]
+  (let [(^open ".") Monad<Meta>]
     (|> current-module-name
         (map find-module) join
         (map (|>> (get@ #.imports) (list.any? (text/= import)))))))
diff --git a/stdlib/source/lux/macro/code.lux b/stdlib/source/lux/macro/code.lux
index a53804630..de6f1fd50 100644
--- a/stdlib/source/lux/macro/code.lux
+++ b/stdlib/source/lux/macro/code.lux
@@ -6,9 +6,9 @@
     bit
     number
     ident
-    ["." text (#+ Equivalence<Text>) ("text/" Monoid<Text>)]
+    ["." text (#+ Equivalence<Text>) ("text/." Monoid<Text>)]
     [collection
-     ["." list ("list/" Functor<List> Fold<List>)]]]])
+     ["." list ("list/." Functor<List> Fold<List>)]]]])
 
 ## [Types]
 ## (type: (Code' w)
diff --git a/stdlib/source/lux/macro/poly.lux b/stdlib/source/lux/macro/poly.lux
index b40d1a3ff..96d806c81 100644
--- a/stdlib/source/lux/macro/poly.lux
+++ b/stdlib/source/lux/macro/poly.lux
@@ -10,12 +10,12 @@
     ["." product]
     ["." bit]
     ["." maybe]
-    [ident ("ident/" Equivalence<Ident> Codec<Text,Ident>)]
+    [ident ("ident/." Equivalence<Ident> Codec<Text,Ident>)]
     ["e" error]
-    ["." number ("nat/" Codec<Text,Nat>)]
-    ["." text ("text/" Monoid<Text>)]
+    ["." number ("nat/." Codec<Text,Nat>)]
+    ["." text ("text/." Monoid<Text>)]
     [collection
-     ["." list ("list/" Fold<List> Monad<List> Monoid<List>)]
+     ["." list ("list/." Fold<List> Monad<List> Monoid<List>)]
      ["dict" dictionary (#+ Dictionary)]]]
    ["." macro (#+ with-gensyms)
     ["." code]
@@ -26,7 +26,7 @@
       ["csr" reader]
       ["csw" writer]]]]
    [language
-    ["." type ("type/" Equivalence<Type>)
+    ["." type ("type/." Equivalence<Type>)
      ["." check]]]
    ])
 
diff --git a/stdlib/source/lux/macro/poly/equivalence.lux b/stdlib/source/lux/macro/poly/equivalence.lux
index 126a2f607..1dd8757e4 100644
--- a/stdlib/source/lux/macro/poly/equivalence.lux
+++ b/stdlib/source/lux/macro/poly/equivalence.lux
@@ -8,11 +8,11 @@
     ["." product]
     ["." bit]
     ["." maybe]
-    ["." number ("nat/" Codec<Text,Nat>)]
-    ["." text ("text/" Monoid<Text>)
+    ["." number ("nat/." Codec<Text,Nat>)]
+    ["." text ("text/." Monoid<Text>)
      format]
     [collection
-     ["." list ("list/" Monad<List>)]
+     ["." list ("list/." Monad<List>)]
      ["." row]
      ["." array]
      ["." queue]
diff --git a/stdlib/source/lux/macro/poly/functor.lux b/stdlib/source/lux/macro/poly/functor.lux
index 824a6ce19..45cf169f7 100644
--- a/stdlib/source/lux/macro/poly/functor.lux
+++ b/stdlib/source/lux/macro/poly/functor.lux
@@ -9,7 +9,7 @@
     ["." text
      format]
     [collection
-     ["." list ("list/" Monad<List> Monoid<List>)]]]
+     ["." list ("list/." Monad<List> Monoid<List>)]]]
    ["." macro
     ["." code]
     [syntax (#+ syntax: Syntax)
diff --git a/stdlib/source/lux/macro/poly/json.lux b/stdlib/source/lux/macro/poly/json.lux
index ace84fcb3..66014ae56 100644
--- a/stdlib/source/lux/macro/poly/json.lux
+++ b/stdlib/source/lux/macro/poly/json.lux
@@ -11,16 +11,16 @@
     ["e" error]
     ["." sum]
     ["." product]
-    [number ("frac/" Codec<Text,Frac>) ("nat/" Codec<Text,Nat>)
+    [number ("frac/." Codec<Text,Frac>) ("nat/." Codec<Text,Nat>)
      ["." i64]]
-    ["." text ("text/" Equivalence<Text>)
+    ["." text ("text/." Equivalence<Text>)
      ["l" lexer]
      format]
     [format
      ["//" json (#+ JSON)]]
     [collection
-     ["." list ("list/" Fold<List> Monad<List>)]
-     ["." row (#+ Row row) ("row/" Monad<Row>)]
+     ["." list ("list/." Fold<List> Monad<List>)]
+     ["." row (#+ Row row) ("row/." Monad<Row>)]
      ["d" dictionary]]]
    [time
     ## ["i" instant]
diff --git a/stdlib/source/lux/macro/syntax.lux b/stdlib/source/lux/macro/syntax.lux
index 1b9229309..5bf0f21b0 100644
--- a/stdlib/source/lux/macro/syntax.lux
+++ b/stdlib/source/lux/macro/syntax.lux
@@ -10,11 +10,11 @@
     ["." maybe]
     ["." error (#+ Error)]
     ["." number]
-    ["." text ("text/" Monoid<Text>)]
+    ["." text ("text/." Monoid<Text>)]
     [collection
-     ["." list ("list/" Functor<List>)]]]]
+     ["." list ("list/." Functor<List>)]]]]
   ["." // (#+ with-gensyms)
-   ["." code ("code/" Equivalence<Code>)]])
+   ["." code ("code/." Equivalence<Code>)]])
 
 ## [Utils]
 (def: (join-pairs pairs)
diff --git a/stdlib/source/lux/macro/syntax/common/reader.lux b/stdlib/source/lux/macro/syntax/common/reader.lux
index 22a785049..818320a1a 100644
--- a/stdlib/source/lux/macro/syntax/common/reader.lux
+++ b/stdlib/source/lux/macro/syntax/common/reader.lux
@@ -2,9 +2,9 @@
   [lux #*
    [control
     monad
-    ["p" parser ("parser/" Monad<Parser>)]]
+    ["p" parser ("parser/." Monad<Parser>)]]
    [data
-    [ident ("ident/" Equivalence<Ident>)]
+    [ident ("ident/." Equivalence<Ident>)]
     ["." product]
     ["." maybe]
     [collection
diff --git a/stdlib/source/lux/macro/syntax/common/writer.lux b/stdlib/source/lux/macro/syntax/common/writer.lux
index 150cd7e52..114a41505 100644
--- a/stdlib/source/lux/macro/syntax/common/writer.lux
+++ b/stdlib/source/lux/macro/syntax/common/writer.lux
@@ -3,7 +3,7 @@
   [lux #*
    [data
     [collection
-     [list ("list/" Functor<List>)]]
+     [list ("list/." Functor<List>)]]
     ["." product]]
    [macro
     ["." code]]]
diff --git a/stdlib/source/lux/math.lux b/stdlib/source/lux/math.lux
index f29eafe63..8692449a1 100644
--- a/stdlib/source/lux/math.lux
+++ b/stdlib/source/lux/math.lux
@@ -2,12 +2,12 @@
   [lux #*
    [control
     monad
-    ["p" parser ("parser/" Functor<Parser>)]]
+    ["p" parser ("parser/." Functor<Parser>)]]
    [data
     ["." product]
     ["." number]
     [collection
-     [list ("list/" Fold<List>)]]]
+     [list ("list/." Fold<List>)]]]
    ["." macro
     ["s" syntax (#+ syntax: Syntax)]
     ["." code]]])
diff --git a/stdlib/source/lux/math/logic/continuous.lux b/stdlib/source/lux/math/logic/continuous.lux
index a6fe71bb6..edc31f2a7 100644
--- a/stdlib/source/lux/math/logic/continuous.lux
+++ b/stdlib/source/lux/math/logic/continuous.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux (#- false true or and not)
-   [data [number ("rev/" Interval<Rev>)]]])
+   [data [number ("rev/." Interval<Rev>)]]])
 
 (def: #export true  Rev rev/top)
 (def: #export false Rev rev/bottom)
diff --git a/stdlib/source/lux/math/modular.lux b/stdlib/source/lux/math/modular.lux
index 8fda63467..749eca38b 100644
--- a/stdlib/source/lux/math/modular.lux
+++ b/stdlib/source/lux/math/modular.lux
@@ -7,8 +7,8 @@
     [monad (#+ do)]]
    [data
     ["e" error (#+ Error)]
-    ["." number ("int/" Codec<Text,Int>)]
-    [text ("text/" Monoid<Text>)
+    ["." number ("int/." Codec<Text,Int>)]
+    [text ("text/." Monoid<Text>)
      ["l" lexer (#+ Lexer)]]]
    [type
     abstract]
diff --git a/stdlib/source/lux/math/random.lux b/stdlib/source/lux/math/random.lux
index 3f9d29d53..1d5f426c5 100644
--- a/stdlib/source/lux/math/random.lux
+++ b/stdlib/source/lux/math/random.lux
@@ -12,10 +12,10 @@
      ["." i64]
      ["r" ratio]
      ["c" complex]]
-    ["." text ("text/" Monoid<Text>)
+    ["." text ("text/." Monoid<Text>)
      ["." unicode (#+ Char Segment)]]
     [collection
-     ["." list ("list/" Fold<List>)]
+     ["." list ("list/." Fold<List>)]
      ["." array]
      ["." dictionary (#+ Dictionary)]
      ["." queue (#+ Queue)]
diff --git a/stdlib/source/lux/test.lux b/stdlib/source/lux/test.lux
index 723a1d63c..3c213e29b 100644
--- a/stdlib/source/lux/test.lux
+++ b/stdlib/source/lux/test.lux
@@ -10,7 +10,7 @@
     ["." text
      format]
     [collection
-     ["." list ("list/" Monad<List> Fold<List>)]]]
+     ["." list ("list/." Monad<List> Fold<List>)]]]
    [time
     ["." instant]
     ["." duration]]
diff --git a/stdlib/source/lux/time/date.lux b/stdlib/source/lux/time/date.lux
index 12d928a8f..ca5ea55b4 100644
--- a/stdlib/source/lux/time/date.lux
+++ b/stdlib/source/lux/time/date.lux
@@ -10,8 +10,8 @@
    [data
     ["e" error]
     ["." maybe]
-    ["." number ("int/" Codec<Text,Int>)]
-    [text ("text/" Monoid<Text>)
+    ["." number ("int/." Codec<Text,Int>)]
+    [text ("text/." Monoid<Text>)
      ["l" lexer]]
     [collection
      ["." row (#+ Row row)]]]])
diff --git a/stdlib/source/lux/time/duration.lux b/stdlib/source/lux/time/duration.lux
index 48c49e61e..75bb32154 100644
--- a/stdlib/source/lux/time/duration.lux
+++ b/stdlib/source/lux/time/duration.lux
@@ -8,8 +8,8 @@
     ["p" parser]
     [monad (#+ do)]]
    [data
-    ["." number ("int/" Codec<Text,Int> Number<Int>)]
-    [text ("text/" Monoid<Text>)
+    ["." number ("int/." Codec<Text,Int> Number<Int>)]
+    [text ("text/." Monoid<Text>)
      ["l" lexer]]
     ["e" error]]
    [type
diff --git a/stdlib/source/lux/time/instant.lux b/stdlib/source/lux/time/instant.lux
index a574ef208..ea834391e 100644
--- a/stdlib/source/lux/time/instant.lux
+++ b/stdlib/source/lux/time/instant.lux
@@ -11,16 +11,16 @@
    [data
     ["e" error]
     ["." maybe]
-    ["." number ("int/" Codec<Text,Int>)]
-    [text ("text/" Monoid<Text>)
+    ["." number ("int/." Codec<Text,Int>)]
+    [text ("text/." Monoid<Text>)
      ["l" lexer]]
     [collection
-     ["." list ("list/" Fold<List>)]
-     ["." row (#+ Row row) ("row/" Functor<Row> Fold<Row>)]]]
+     ["." list ("list/." Fold<List>)]
+     ["." row (#+ Row row) ("row/." Functor<Row> Fold<Row>)]]]
    [type
     abstract]]
   [//
-   ["." duration ("duration/" Order<Duration>)]
+   ["." duration ("duration/." Order<Duration>)]
    ["." date]])
 
 (abstract: #export Instant
diff --git a/stdlib/source/lux/type/abstract.lux b/stdlib/source/lux/type/abstract.lux
index f32f60de8..bf17562da 100644
--- a/stdlib/source/lux/type/abstract.lux
+++ b/stdlib/source/lux/type/abstract.lux
@@ -4,11 +4,11 @@
     [monad (#+ do Monad)]
     ["p" parser]]
    [data
-    [text ("text/" Equivalence<Text> Monoid<Text>)]
+    [text ("text/." Equivalence<Text> Monoid<Text>)]
     ["." error]
     [collection
-     [list ("list/" Functor<List> Monoid<List>)]]]
-   ["." macro ("meta/" Monad<Meta>)
+     [list ("list/." Functor<List> Monoid<List>)]]]
+   ["." macro ("meta/." Monad<Meta>)
     ["." code]
     ["s" syntax (#+ syntax:)]
     [syntax
diff --git a/stdlib/source/lux/type/implicit.lux b/stdlib/source/lux/type/implicit.lux
index b94eb6684..c4f025f4f 100644
--- a/stdlib/source/lux/type/implicit.lux
+++ b/stdlib/source/lux/type/implicit.lux
@@ -8,10 +8,10 @@
     ["." product]
     ["." maybe]
     ["." number]
-    ["." text ("text/" Equivalence<Text>)
+    ["." text ("text/." Equivalence<Text>)
      format]
     [collection
-     ["." list ("list/" Monad<List> Fold<List>)]
+     ["." list ("list/." Monad<List> Fold<List>)]
      ["dict" dictionary (#+ Dictionary)]]]
    ["." macro (#+ Monad<Meta>)
     ["." code]
diff --git a/stdlib/source/lux/type/object/interface.lux b/stdlib/source/lux/type/object/interface.lux
index d4d6fa518..94d42a28a 100644
--- a/stdlib/source/lux/type/object/interface.lux
+++ b/stdlib/source/lux/type/object/interface.lux
@@ -2,17 +2,17 @@
   [lux #*
    [control
     ["." monad (#+ do Monad)]
-    ["p" parser ("parser/" Monad<Parser>)]]
+    ["p" parser ("parser/." Monad<Parser>)]]
    [data
     ["." product]
     ["." maybe]
-    [ident ("ident/" Equivalence<Ident>)]
+    [ident ("ident/." Equivalence<Ident>)]
     ["." text
      format]
     [collection
-     ["." list ("list/" Functor<List> Fold<List> Monoid<List>)]
+     ["." list ("list/." Functor<List> Fold<List> Monoid<List>)]
      ["." set (#+ Set)]]]
-   ["." macro (#+ Monad<Meta>) ("meta/" Monad<Meta>)
+   ["." macro (#+ Monad<Meta>) ("meta/." Monad<Meta>)
     ["." code]
     ["s" syntax (#+ syntax:)]
     [syntax
@@ -90,7 +90,7 @@
               (s.tuple (p.some s.any))
               s.any)))
 
-(def: (declarationM g!self (^open))
+(def: (declarationM g!self (^open "."))
   (-> Code Method Code)
   (let [g!type-vars (list/map code.local-symbol type-vars)
         g!method (code.local-symbol name)]
@@ -98,7 +98,7 @@
             (-> (~+ inputs) (~ g!self) (~ output)))
           (~ g!method)))))
 
-(def: (definition export [interface parameters] g!self-object g!ext g!states (^open))
+(def: (definition export [interface parameters] g!self-object g!ext g!states (^open "."))
   (-> Bit Declaration Code Code (List Code) Method Code)
   (let [g!method (code.local-symbol name)
         g!parameters (list/map code.local-symbol parameters)
diff --git a/stdlib/source/lux/type/object/protocol.lux b/stdlib/source/lux/type/object/protocol.lux
index 64078b865..26045f50f 100644
--- a/stdlib/source/lux/type/object/protocol.lux
+++ b/stdlib/source/lux/type/object/protocol.lux
@@ -6,8 +6,8 @@
    [data
     ["." sum]
     [collection
-     [list ("list/" Functor<List>)]]]
-   ["." macro ("meta/" Monad<Meta>)
+     [list ("list/." Functor<List>)]]]
+   ["." macro ("meta/." Monad<Meta>)
     ["." code]
     ["s" syntax (#+ syntax:)]
     [syntax
diff --git a/stdlib/source/lux/type/refinement.lux b/stdlib/source/lux/type/refinement.lux
index 52a3c01be..670a3101e 100644
--- a/stdlib/source/lux/type/refinement.lux
+++ b/stdlib/source/lux/type/refinement.lux
@@ -7,7 +7,7 @@
    [data
     ["e" error (#+ Error)]]
    [language
-    ["." type ("type/" Equivalence<Type>)]]
+    ["." type ("type/." Equivalence<Type>)]]
    [type
     abstract]
    ["." macro
diff --git a/stdlib/source/lux/type/resource.lux b/stdlib/source/lux/type/resource.lux
index 7dd961ee8..c683a93cb 100644
--- a/stdlib/source/lux/type/resource.lux
+++ b/stdlib/source/lux/type/resource.lux
@@ -16,7 +16,7 @@
      ["dict" dictionary (#+ Dictionary)]
      ["." set]
      ["." row (#+ Row)]
-     ["." list ("list/" Functor<List> Fold<List>)]]]
+     ["." list ("list/." Functor<List> Fold<List>)]]]
    [concurrency
     ["." promise (#+ Promise)]]
    ["." macro ["s" syntax (#+ Syntax syntax:)]]
diff --git a/stdlib/source/lux/world/net/tcp.jvm.lux b/stdlib/source/lux/world/net/tcp.jvm.lux
index 86b19136a..6c65a92ca 100644
--- a/stdlib/source/lux/world/net/tcp.jvm.lux
+++ b/stdlib/source/lux/world/net/tcp.jvm.lux
@@ -65,7 +65,7 @@
 
   (def: #export (close self)
     (-> TCP (Task Any))
-    (let [(^open) (:representation self)]
+    (let [(^open ".") (:representation self)]
       (promise.future
        (do io.Monad<Process>
          [_ (AutoCloseable::close [] in)
diff --git a/stdlib/source/lux/world/net/udp.jvm.lux b/stdlib/source/lux/world/net/udp.jvm.lux
index b7c3533e7..82614842c 100644
--- a/stdlib/source/lux/world/net/udp.jvm.lux
+++ b/stdlib/source/lux/world/net/udp.jvm.lux
@@ -67,7 +67,7 @@
   
   (def: #export (read data offset length self)
     (-> Blob Nat Nat UDP (T.Task [Nat //.Address //.Port]))
-    (let [(^open) (:representation self)
+    (let [(^open ".") (:representation self)
           packet (DatagramPacket::new|receive [data (.int offset) (.int length)])]
       (P.future
        (do (e.ErrorT io.Monad<IO>)
@@ -82,13 +82,13 @@
     (P.future
      (do (e.ErrorT io.Monad<IO>)
        [address (resolve address)
-        #let [(^open) (:representation self)]]
+        #let [(^open ".") (:representation self)]]
        (DatagramSocket::send (DatagramPacket::new|send [data (.int offset) (.int length) address (.int port)])
                              socket))))
 
   (def: #export (close self)
     (-> UDP (T.Task Any))
-    (let [(^open) (:representation self)]
+    (let [(^open ".") (:representation self)]
       (P.future
        (AutoCloseable::close [] socket))))
 
diff --git a/stdlib/test/test/lux.lux b/stdlib/test/test/lux.lux
index 5325d9b79..65f176b87 100644
--- a/stdlib/test/test/lux.lux
+++ b/stdlib/test/test/lux.lux
@@ -6,7 +6,7 @@
     ["." maybe]
     [number
      ["." i64]]
-    [text ("text/" Equivalence<Text>)
+    [text ("text/." Equivalence<Text>)
      format]]
    ["." math
     ["r" random]]
diff --git a/stdlib/test/test/lux/cli.lux b/stdlib/test/test/lux/cli.lux
index 1504f2187..6d156d3b2 100644
--- a/stdlib/test/test/lux/cli.lux
+++ b/stdlib/test/test/lux/cli.lux
@@ -7,7 +7,7 @@
    [data
     ["E" error]
     ["." number]
-    [text ("text/" Equivalence<Text>)
+    [text ("text/." Equivalence<Text>)
      format]
     [collection
      ["." list]]]
@@ -20,7 +20,7 @@
   (<| (times +100)
       (do @
         [num-args (|> r.nat (:: @ map (n/% +10)))
-         #let [(^open "Nat/") number.Codec<Text,Nat>
+         #let [(^open "Nat/.") number.Codec<Text,Nat>
                gen-arg (:: @ map Nat/encode r.nat)]
          yes gen-arg
          #let [gen-ignore (|> (r.unicode +5) (r.filter (|>> (text/= yes) not)))]
diff --git a/stdlib/test/test/lux/concurrency/actor.lux b/stdlib/test/test/lux/concurrency/actor.lux
index a84ded979..a1e9ec549 100644
--- a/stdlib/test/test/lux/concurrency/actor.lux
+++ b/stdlib/test/test/lux/concurrency/actor.lux
@@ -9,7 +9,7 @@
     [text
      format]]
    [concurrency
-    ["P" promise ("promise/" Monad<Promise>)]
+    ["P" promise ("promise/." Monad<Promise>)]
     ["T" task]
     ["&" actor (#+ actor: message:)]]]
   lux/test)
diff --git a/stdlib/test/test/lux/concurrency/frp.lux b/stdlib/test/test/lux/concurrency/frp.lux
index db2ad4a2f..c69ae6038 100644
--- a/stdlib/test/test/lux/concurrency/frp.lux
+++ b/stdlib/test/test/lux/concurrency/frp.lux
@@ -8,7 +8,7 @@
     [collection
      ["." list]]]
    [concurrency
-    ["." promise ("promise/" Monad<Promise>)]
+    ["." promise ("promise/." Monad<Promise>)]
     ["." frp (#+ Channel)]
     ["." atom (#+ Atom atom)]]]
   lux/test)
@@ -32,7 +32,7 @@
     (wrap output)))
 
 (context: "FRP"
-  (let [(^open "list/") (list.Equivalence<List> number.Equivalence<Int>)]
+  (let [(^open "list/.") (list.Equivalence<List> number.Equivalence<Int>)]
     ($_ seq
         (wrap (do promise.Monad<Promise>
                 [#let [values (list 0 1 2 3 4 5)]
@@ -97,7 +97,7 @@
                          (do io.Monad<IO>
                            [#let [>f< (: (Channel (-> Int Int)) (frp.channel []))
                                   >a< (: (Channel Int) (frp.channel []))]
-                            output (read! (let [(^open) frp.Apply<Channel>]
+                            output (read! (let [(^open ".") frp.Apply<Channel>]
                                             (apply >f< >a<)))
                             _ (write! (list inc) >f<)
                             _ (write! (list 12345) >a<)]
diff --git a/stdlib/test/test/lux/concurrency/promise.lux b/stdlib/test/test/lux/concurrency/promise.lux
index 2ede2b349..7dda27503 100644
--- a/stdlib/test/test/lux/concurrency/promise.lux
+++ b/stdlib/test/test/lux/concurrency/promise.lux
@@ -5,7 +5,7 @@
     ["M" monad (#+ do Monad)]
     pipe]
    [concurrency
-    ["&" promise ("&/" Monad<Promise>)]]
+    ["&" promise ("&/." Monad<Promise>)]]
    [math
     ["r" random]]]
   lux/test)
diff --git a/stdlib/test/test/lux/concurrency/semaphore.lux b/stdlib/test/test/lux/concurrency/semaphore.lux
index b941654f0..df145ff82 100644
--- a/stdlib/test/test/lux/concurrency/semaphore.lux
+++ b/stdlib/test/test/lux/concurrency/semaphore.lux
@@ -4,10 +4,10 @@
     ["." monad (#+ do)]]
    [data
     ["." maybe]
-    ["." text ("text/" Equivalence<Text> Monoid<Text>)
+    ["." text ("text/." Equivalence<Text> Monoid<Text>)
      format]
     [collection
-     ["." list ("list/" Functor<List>)]]]
+     ["." list ("list/." Functor<List>)]]]
    [concurrency
     ["/" semaphore]
     ["." promise (#+ Promise)]
diff --git a/stdlib/test/test/lux/concurrency/stm.lux b/stdlib/test/test/lux/concurrency/stm.lux
index d4697cd6e..a1897b846 100644
--- a/stdlib/test/test/lux/concurrency/stm.lux
+++ b/stdlib/test/test/lux/concurrency/stm.lux
@@ -6,7 +6,7 @@
    [data
     ["." number]
     [collection
-     ["." list ("list/" Functor<List>)]]]
+     ["." list ("list/." Functor<List>)]]]
    [concurrency
     ["." atom (#+ Atom atom)]
     ["&" stm]
diff --git a/stdlib/test/test/lux/control/continuation.lux b/stdlib/test/test/lux/control/continuation.lux
index 60dfb7ac4..be7ac920c 100644
--- a/stdlib/test/test/lux/control/continuation.lux
+++ b/stdlib/test/test/lux/control/continuation.lux
@@ -14,8 +14,8 @@
   (<| (times +100)
       (do @
         [sample r.nat
-         #let [(^open "&/") &.Apply<Cont>
-               (^open "&/") &.Monad<Cont>]
+         #let [(^open "&/.") &.Apply<Cont>
+               (^open "&/.") &.Monad<Cont>]
          elems (r.list +3 r.nat)]
         ($_ seq
             (test "Can run continuations to compute their values."
@@ -55,8 +55,8 @@
                                   (wrap output))))))
 
             (test "Can use delimited continuations with shifting."
-                  (let [(^open "&/") &.Monad<Cont>
-                        (^open "L/") (list.Equivalence<List> number.Equivalence<Nat>)
+                  (let [(^open "&/.") &.Monad<Cont>
+                        (^open "L/.") (list.Equivalence<List> number.Equivalence<Nat>)
                         visit (: (-> (List Nat)
                                      (&.Cont (List Nat) (List Nat)))
                                  (function (visit xs)
diff --git a/stdlib/test/test/lux/control/interval.lux b/stdlib/test/test/lux/control/interval.lux
index 190ebce0d..ba2e3c7b3 100644
--- a/stdlib/test/test/lux/control/interval.lux
+++ b/stdlib/test/test/lux/control/interval.lux
@@ -18,7 +18,7 @@
       (do @
         [bottom r.int
          top r.int
-         #let [(^open "&/") &.Equivalence<Interval>]]
+         #let [(^open "&/.") &.Equivalence<Interval>]]
         ($_ seq
             (test "Every interval is equal to itself."
                   (and (let [self (&.between number.Enum<Int> bottom top)]
@@ -94,7 +94,7 @@
          right-singleton gen-singleton
          left-outer gen-outer
          right-outer gen-outer
-         #let [(^open "&/") &.Equivalence<Interval>]]
+         #let [(^open "&/.") &.Equivalence<Interval>]]
         ($_ seq
             (test "The union of an interval to itself yields the same interval."
                   (&/= some-interval (&.union some-interval some-interval)))
@@ -116,7 +116,7 @@
          right-singleton gen-singleton
          left-outer gen-outer
          right-outer gen-outer
-         #let [(^open "&/") &.Equivalence<Interval>]]
+         #let [(^open "&/.") &.Equivalence<Interval>]]
         ($_ seq
             (test "The intersection of an interval to itself yields the same interval."
                   (&/= some-interval (&.intersection some-interval some-interval)))
@@ -132,7 +132,7 @@
   (<| (times +100)
       (do @
         [some-interval gen-interval
-         #let [(^open "&/") &.Equivalence<Interval>]]
+         #let [(^open "&/.") &.Equivalence<Interval>]]
         ($_ seq
             (test "The complement of a complement is the same as the original."
                   (&/= some-interval (|> some-interval &.complement &.complement)))
diff --git a/stdlib/test/test/lux/control/pipe.lux b/stdlib/test/test/lux/control/pipe.lux
index d03becffc..2cc09fbf8 100644
--- a/stdlib/test/test/lux/control/pipe.lux
+++ b/stdlib/test/test/lux/control/pipe.lux
@@ -5,7 +5,7 @@
     pipe]
    [data
     identity
-    [text ("text/" Equivalence<Text>)
+    [text ("text/." Equivalence<Text>)
      format]]
    [math
     ["r" random]]]
diff --git a/stdlib/test/test/lux/control/reader.lux b/stdlib/test/test/lux/control/reader.lux
index 51b1f82f3..135cce4ee 100644
--- a/stdlib/test/test/lux/control/reader.lux
+++ b/stdlib/test/test/lux/control/reader.lux
@@ -8,8 +8,8 @@
   lux/test)
 
 (context: "Readers"
-  (let [(^open "&/") &.Apply<Reader>
-        (^open "&/") &.Monad<Reader>]
+  (let [(^open "&/.") &.Apply<Reader>
+        (^open "&/.") &.Monad<Reader>]
     ($_ seq
         (test "" (i/= 123 (&.run 123 &.ask)))
         (test "" (i/= 246 (&.run 123 (&.local (i/* 2) &.ask))))
@@ -23,7 +23,7 @@
                                       (wrap (f x y)))))))))
 
 (context: "Monad transformer"
-  (let [(^open "io/") io.Monad<IO>]
+  (let [(^open "io/.") io.Monad<IO>]
     (test "Can add reader functionality to any monad."
           (|> (: (&.Reader Text (io.IO Int))
                  (do (&.ReaderT io.Monad<IO>)
diff --git a/stdlib/test/test/lux/control/state.lux b/stdlib/test/test/lux/control/state.lux
index 2b3b3160c..e7f26bfe3 100644
--- a/stdlib/test/test/lux/control/state.lux
+++ b/stdlib/test/test/lux/control/state.lux
@@ -51,9 +51,9 @@
       (do @
         [state r.nat
          value r.nat
-         #let [(^open "&/") &.Functor<State>
-               (^open "&/") &.Apply<State>
-               (^open "&/") &.Monad<State>]]
+         #let [(^open "&/.") &.Functor<State>
+               (^open "&/.") &.Apply<State>
+               (^open "&/.") &.Monad<State>]]
         ($_ seq
             (test "Can use functor."
                   (with-conditions [state (inc state)]
@@ -80,7 +80,7 @@
         [state r.nat
          left r.nat
          right r.nat]
-        (let [(^open "io/") io.Monad<IO>]
+        (let [(^open "io/.") io.Monad<IO>]
           (test "Can add state functionality to any monad."
                 (|> (: (&.State' io.IO Nat Nat)
                        (do (&.Monad<State'> io.Monad<IO>)
diff --git a/stdlib/test/test/lux/control/writer.lux b/stdlib/test/test/lux/control/writer.lux
index 7172e865e..6b31046ea 100644
--- a/stdlib/test/test/lux/control/writer.lux
+++ b/stdlib/test/test/lux/control/writer.lux
@@ -7,12 +7,12 @@
     ["&" writer]]
    [data
     ["." product]
-    ["." text ("text/" Equivalence<Text>)]]]
+    ["." text ("text/." Equivalence<Text>)]]]
   lux/test)
 
 (context: "Writer."
-  (let [(^open "&/") (&.Monad<Writer> text.Monoid<Text>)
-        (^open "&/") (&.Apply<Writer> text.Monoid<Text>)]
+  (let [(^open "&/.") (&.Monad<Writer> text.Monoid<Text>)
+        (^open "&/.") (&.Apply<Writer> text.Monoid<Text>)]
     ($_ seq
         (test "Functor respects Writer."
               (i/= 11 (product.right (&/map inc ["" 10]))))
@@ -34,7 +34,7 @@
 
 (context: "Monad transformer"
   (let [lift (&.lift text.Monoid<Text> io.Monad<IO>)
-        (^open "io/") io.Monad<IO>]
+        (^open "io/.") io.Monad<IO>]
     (test "Can add writer functionality to any monad."
           (|> (io.run (do (&.WriterT text.Monoid<Text> io.Monad<IO>)
                         [a (lift (io/wrap 123))
diff --git a/stdlib/test/test/lux/data/collection/array.lux b/stdlib/test/test/lux/data/collection/array.lux
index a362df27b..0e42c7132 100644
--- a/stdlib/test/test/lux/data/collection/array.lux
+++ b/stdlib/test/test/lux/data/collection/array.lux
@@ -104,8 +104,8 @@
       (do @
         [size bounded-size
          array (r.array size r.nat)]
-        (let [(^open) @.Functor<Array>
-              (^open) (@.Equivalence<Array> number.Equivalence<Nat>)]
+        (let [(^open ".") @.Functor<Array>
+              (^open ".") (@.Equivalence<Array> number.Equivalence<Nat>)]
           ($_ seq
               (test "Functor shouldn't alter original array."
                     (let [copy (map id array)]
@@ -124,8 +124,8 @@
          sizeR bounded-size
          left (r.array sizeL r.nat)
          right (r.array sizeR r.nat)
-         #let [(^open) @.Monoid<Array>
-               (^open) (@.Equivalence<Array> number.Equivalence<Nat>)
+         #let [(^open ".") @.Monoid<Array>
+               (^open ".") (@.Equivalence<Array> number.Equivalence<Nat>)
                fusion (compose left right)]]
         ($_ seq
             (test "Appending two arrays should produce a new one twice as large."
diff --git a/stdlib/test/test/lux/data/collection/dictionary.lux b/stdlib/test/test/lux/data/collection/dictionary.lux
index c56bd7d42..aec463ec8 100644
--- a/stdlib/test/test/lux/data/collection/dictionary.lux
+++ b/stdlib/test/test/lux/data/collection/dictionary.lux
@@ -8,7 +8,7 @@
     ["." maybe]
     [collection
      ["&" dictionary]
-     ["." list ("list/" Fold<List> Functor<List>)]]]
+     ["." list ("list/." Fold<List> Functor<List>)]]]
    [math
     ["r" random]]]
   lux/test)
@@ -90,19 +90,19 @@
                          (n/= (dec (&.size plus)) (&.size base)))))
 
             (test "A Dictionary should equal itself & going to<->from lists shouldn't change that."
-                  (let [(^open) (&.Equivalence<Dictionary> number.Equivalence<Nat>)]
+                  (let [(^open ".") (&.Equivalence<Dictionary> number.Equivalence<Nat>)]
                     (and (= dict dict)
                          (|> dict &.entries (&.from-list number.Hash<Nat>) (= dict)))))
 
             (test "Merging a Dictionary to itself changes nothing."
-                  (let [(^open) (&.Equivalence<Dictionary> number.Equivalence<Nat>)]
+                  (let [(^open ".") (&.Equivalence<Dictionary> number.Equivalence<Nat>)]
                     (= dict (&.merge dict dict))))
 
             (test "If you merge, and the second dict has overlapping keys, it should overwrite yours."
                   (let [dict' (|> dict &.entries
                                   (list/map (function (_ [k v]) [k (inc v)]))
                                   (&.from-list number.Hash<Nat>))
-                        (^open) (&.Equivalence<Dictionary> number.Equivalence<Nat>)]
+                        (^open ".") (&.Equivalence<Dictionary> number.Equivalence<Nat>)]
                     (= dict' (&.merge dict' dict))))
 
             (test "Can merge values in such a way that they become combined."
diff --git a/stdlib/test/test/lux/data/collection/dictionary/ordered.lux b/stdlib/test/test/lux/data/collection/dictionary/ordered.lux
index b95f889b1..b3d917625 100644
--- a/stdlib/test/test/lux/data/collection/dictionary/ordered.lux
+++ b/stdlib/test/test/lux/data/collection/dictionary/ordered.lux
@@ -10,7 +10,7 @@
      ["s" set]
      ["dict" dictionary
       ["&" ordered]]
-     ["." list ("list/" Functor<List>)]]]
+     ["." list ("list/." Functor<List>)]]]
    [math
     ["r" random]]]
   lux/test)
@@ -30,7 +30,7 @@
                                          (n/< left right))
                                        pairs)
                sorted-values (list/map product.right sorted-pairs)
-               (^open "&/") (&.Equivalence<Dictionary> number.Equivalence<Nat>)]]
+               (^open "&/.") (&.Equivalence<Dictionary> number.Equivalence<Nat>)]]
         ($_ seq
             (test "Can query the size of a dictionary."
                   (n/= size (&.size sample)))
@@ -63,10 +63,10 @@
                       (&/= sample)))
 
             (test "Order is preserved."
-                  (let [(^open "list/") (list.Equivalence<List> (: (Equivalence [Nat Nat])
-                                                                   (function (_ [kr vr] [ks vs])
-                                                                     (and (n/= kr ks)
-                                                                          (n/= vr vs)))))]
+                  (let [(^open "list/.") (list.Equivalence<List> (: (Equivalence [Nat Nat])
+                                                                    (function (_ [kr vr] [ks vs])
+                                                                      (and (n/= kr ks)
+                                                                           (n/= vr vs)))))]
                     (list/= (&.entries sample)
                             sorted-pairs)))
 
diff --git a/stdlib/test/test/lux/data/collection/list.lux b/stdlib/test/test/lux/data/collection/list.lux
index 2e8ac8b0e..2afdcefe2 100644
--- a/stdlib/test/test/lux/data/collection/list.lux
+++ b/stdlib/test/test/lux/data/collection/list.lux
@@ -29,8 +29,8 @@
          other-size bounded-size
          other-sample (r.list other-size r.nat)
          separator r.nat
-         #let [(^open) (&.Equivalence<List> number.Equivalence<Nat>)
-               (^open "&/") &.Functor<List>]]
+         #let [(^open ".") (&.Equivalence<List> number.Equivalence<Nat>)
+               (^open "&/.") &.Functor<List>]]
         ($_ seq
             (test "The size function should correctly portray the size of the list."
                   (n/= size (&.size sample)))
@@ -75,8 +75,8 @@
          other-size bounded-size
          other-sample (r.list other-size r.nat)
          separator r.nat
-         #let [(^open) (&.Equivalence<List> number.Equivalence<Nat>)
-               (^open "&/") &.Functor<List>]]
+         #let [(^open ".") (&.Equivalence<List> number.Equivalence<Nat>)
+               (^open "&/.") &.Functor<List>]]
         ($_ seq
             (test "Appending the head and the tail should yield the original list."
                   (let [head (maybe.assume (&.head sample))
@@ -85,21 +85,21 @@
                        (#.Cons head tail))))
 
             (test "Appending the inits and the last should yield the original list."
-                  (let [(^open) &.Monoid<List>
+                  (let [(^open ".") &.Monoid<List>
                         inits (maybe.assume (&.inits sample))
                         last (maybe.assume (&.last sample))]
                     (= sample
                        (compose inits (list last)))))
 
             (test "Functor should go over every element of the list."
-                  (let [(^open) &.Functor<List>
+                  (let [(^open ".") &.Functor<List>
                         there (map inc sample)
                         back-again (map dec there)]
                     (and (not (= sample there))
                          (= sample back-again))))
 
             (test "Splitting a list into chunks and re-appending them should yield the original list."
-                  (let [(^open) &.Monoid<List>
+                  (let [(^open ".") &.Monoid<List>
                         [left right] (&.split idx sample)
                         [left' right'] (&.split-with n/even? sample)]
                     (and (= sample
@@ -138,22 +138,22 @@
          separator r.nat
          from (|> r.nat (:: @ map (n/% +10)))
          to (|> r.nat (:: @ map (n/% +10)))
-         #let [(^open) (&.Equivalence<List> number.Equivalence<Nat>)
-               (^open "&/") &.Functor<List>]]
+         #let [(^open ".") (&.Equivalence<List> number.Equivalence<Nat>)
+               (^open "&/.") &.Functor<List>]]
         ($_ seq
             (test "If you zip 2 lists, the result's size will be that of the smaller list."
                   (n/= (&.size (&.zip2 sample other-sample))
                        (n/min (&.size sample) (&.size other-sample))))
             
             (test "I can pair-up elements of a list in order."
-                  (let [(^open) &.Functor<List>
+                  (let [(^open ".") &.Functor<List>
                         zipped (&.zip2 sample other-sample)
                         num-zipper (&.size zipped)]
                     (and (|> zipped (map product.left) (= (&.take num-zipper sample)))
                          (|> zipped (map product.right) (= (&.take num-zipper other-sample))))))
             
             (test "You can generate indices for any size, and they will be in ascending order."
-                  (let [(^open) &.Functor<List>
+                  (let [(^open ".") &.Functor<List>
                         indices (&.indices size)]
                     (and (n/= size (&.size indices))
                          (= indices
@@ -165,14 +165,14 @@
                          )))
 
             (test "The 'interpose' function places a value between every member of a list."
-                  (let [(^open) &.Functor<List>
+                  (let [(^open ".") &.Functor<List>
                         sample+ (&.interpose separator sample)]
                     (and (n/= (|> size (n/* +2) dec)
                               (&.size sample+))
                          (|> sample+ &.as-pairs (map product.right) (&.every? (n/= separator))))))
 
             (test "List append is a monoid."
-                  (let [(^open) &.Monoid<List>]
+                  (let [(^open ".") &.Monoid<List>]
                     (and (= sample (compose identity sample))
                          (= sample (compose sample identity))
                          (let [[left right] (&.split size (compose sample other-sample))]
@@ -180,15 +180,15 @@
                                 (= other-sample right))))))
 
             (test "Apply allows you to create singleton lists, and apply lists of functions to lists of values."
-                  (let [(^open) &.Monad<List>
-                        (^open) &.Apply<List>]
+                  (let [(^open ".") &.Monad<List>
+                        (^open ".") &.Apply<List>]
                     (and (= (list separator) (wrap separator))
                          (= (map inc sample)
                             (apply (wrap inc) sample)))))
 
             (test "List concatenation is a monad."
-                  (let [(^open) &.Monad<List>
-                        (^open) &.Monoid<List>]
+                  (let [(^open ".") &.Monad<List>
+                        (^open ".") &.Monoid<List>]
                     (= (compose sample other-sample)
                        (join (list sample other-sample)))))
 
@@ -216,10 +216,10 @@
                             (&/map product.right enum-sample)))))
 
             (test "Ranges can be constructed forward and backwards."
-                  (and (let [(^open "list/") (&.Equivalence<List> number.Equivalence<Nat>)]
+                  (and (let [(^open "list/.") (&.Equivalence<List> number.Equivalence<Nat>)]
                          (list/= (&.n/range from to)
                                  (&.reverse (&.n/range to from))))
-                       (let [(^open "list/") (&.Equivalence<List> number.Equivalence<Int>)
+                       (let [(^open "list/.") (&.Equivalence<List> number.Equivalence<Int>)
                              from (.int from)
                              to (.int to)]
                          (list/= (&.i/range from to)
@@ -229,7 +229,7 @@
 ## TODO: Add again once new-luxc becomes the standard compiler.
 (context: "Monad transformer"
   (let [lift (&.lift io.Monad<IO>)
-        (^open "io/") io.Monad<IO>]
+        (^open "io/.") io.Monad<IO>]
     (test "Can add list functionality to any monad."
           (|> (io.run (do (&.ListT io.Monad<IO>)
                         [a (lift (io/wrap 123))
diff --git a/stdlib/test/test/lux/data/collection/queue.lux b/stdlib/test/test/lux/data/collection/queue.lux
index 82ea751d8..935f8f22b 100644
--- a/stdlib/test/test/lux/data/collection/queue.lux
+++ b/stdlib/test/test/lux/data/collection/queue.lux
@@ -30,7 +30,7 @@
                        (n/= size (&.size (&.pop (&.push non-member sample))))))
 
             (test "Transforming to/from list can't change the queue."
-                  (let [(^open "&/") (&.Equivalence<Queue> number.Equivalence<Nat>)]
+                  (let [(^open "&/.") (&.Equivalence<Queue> number.Equivalence<Nat>)]
                     (|> sample
                         &.to-list &.from-list
                         (&/= sample))))
diff --git a/stdlib/test/test/lux/data/collection/row.lux b/stdlib/test/test/lux/data/collection/row.lux
index ad71d0380..ec6d7659d 100644
--- a/stdlib/test/test/lux/data/collection/row.lux
+++ b/stdlib/test/test/lux/data/collection/row.lux
@@ -6,7 +6,7 @@
     ["." number]
     ["." maybe]
     [collection ["&" row]
-     [list ("list/" Fold<List>)]]]
+     [list ("list/." Fold<List>)]]]
    [math
     ["r" random]]]
   lux/test)
@@ -19,11 +19,11 @@
          sample (r.row size r.nat)
          other-sample (r.row size r.nat)
          non-member (|> r.nat (r.filter (|>> (&.member? number.Equivalence<Nat> sample) not)))
-         #let [(^open "&/") (&.Equivalence<Row> number.Equivalence<Nat>)
-               (^open "&/") &.Apply<Row>
-               (^open "&/") &.Monad<Row>
-               (^open "&/") &.Fold<Row>
-               (^open "&/") &.Monoid<Row>]]
+         #let [(^open "&/.") (&.Equivalence<Row> number.Equivalence<Nat>)
+               (^open "&/.") &.Apply<Row>
+               (^open "&/.") &.Monad<Row>
+               (^open "&/.") &.Fold<Row>
+               (^open "&/.") &.Monoid<Row>]]
         ($_ seq
             (test "Can query size of row."
                   (if (&.empty? sample)
diff --git a/stdlib/test/test/lux/data/collection/sequence.lux b/stdlib/test/test/lux/data/collection/sequence.lux
index b33882557..dd545e906 100644
--- a/stdlib/test/test/lux/data/collection/sequence.lux
+++ b/stdlib/test/test/lux/data/collection/sequence.lux
@@ -5,8 +5,8 @@
     comonad]
    [data
     ["." maybe]
-    ["." number ("nat/" Codec<Text,Nat>)]
-    ["." text ("text/" Monoid<Text>)]
+    ["." number ("nat/." Codec<Text,Nat>)]
+    ["." text ("text/." Monoid<Text>)]
     [collection
      ["." list]
      ["&" sequence]]]
@@ -23,7 +23,7 @@
          elem r.nat
          cycle-seed (r.list size r.nat)
          cycle-sample-idx (|> r.nat (:: @ map (n/% +1000)))
-         #let [(^open "List/") (list.Equivalence<List> number.Equivalence<Nat>)
+         #let [(^open "List/.") (list.Equivalence<List> number.Equivalence<Nat>)
                sample0 (&.iterate inc +0)
                sample1 (&.iterate inc offset)]]
         ($_ seq
@@ -68,7 +68,7 @@
                                    (&.nth offset odds))))))
 
             (test "Functor goes over 'all' elements in a sequence."
-                  (let [(^open "&/") &.Functor<Sequence>
+                  (let [(^open "&/.") &.Functor<Sequence>
                         there (&/map (n/* factor) sample0)
                         back-again (&/map (n// factor) there)]
                     (and (not (List/= (&.take size sample0)
@@ -77,7 +77,7 @@
                                  (&.take size back-again)))))
 
             (test "CoMonad produces a value for every element in a sequence."
-                  (let [(^open "&/") &.Functor<Sequence>]
+                  (let [(^open "&/.") &.Functor<Sequence>]
                     (List/= (&.take size (&/map (n/* factor) sample1))
                             (&.take size
                                     (be &.CoMonad<Sequence>
@@ -85,8 +85,8 @@
                                       (n/* factor (&.head inputs)))))))
 
             (test "'unfold' generalizes 'iterate'."
-                  (let [(^open "&/") &.Functor<Sequence>
-                        (^open "List/") (list.Equivalence<List> text.Equivalence<Text>)]
+                  (let [(^open "&/.") &.Functor<Sequence>
+                        (^open "List/.") (list.Equivalence<List> text.Equivalence<Text>)]
                     (List/= (&.take size
                                     (&/map nat/encode (&.iterate inc offset)))
                             (&.take size
diff --git a/stdlib/test/test/lux/data/collection/set.lux b/stdlib/test/test/lux/data/collection/set.lux
index 3db08f344..78bb1bc42 100644
--- a/stdlib/test/test/lux/data/collection/set.lux
+++ b/stdlib/test/test/lux/data/collection/set.lux
@@ -25,7 +25,7 @@
          setR (r.set number.Hash<Nat> sizeR gen-nat)
          non-member (|> gen-nat
                         (r.filter (|>> (&.member? setL) not)))
-         #let [(^open "&/") &.Equivalence<Set>]]
+         #let [(^open "&/.") &.Equivalence<Set>]]
         ($_ seq
             (test "I can query the size of a set."
                   (and (n/= sizeL (&.size setL))
diff --git a/stdlib/test/test/lux/data/collection/set/ordered.lux b/stdlib/test/test/lux/data/collection/set/ordered.lux
index d75fe3c53..fe7b3069c 100644
--- a/stdlib/test/test/lux/data/collection/set/ordered.lux
+++ b/stdlib/test/test/lux/data/collection/set/ordered.lux
@@ -26,7 +26,7 @@
          sizeR gen-nat
          listL (|> (r.set number.Hash<Nat> sizeL gen-nat) (:: @ map set.to-list))
          listR (|> (r.set number.Hash<Nat> sizeR gen-nat) (:: @ map set.to-list))
-         #let [(^open "&/") &.Equivalence<Set>
+         #let [(^open "&/.") &.Equivalence<Set>
                setL (&.from-list number.Order<Nat> listL)
                setR (&.from-list number.Order<Nat> listR)
                sortedL (list.sort n/< listL)
@@ -65,7 +65,7 @@
 
             (test "Order is preserved."
                   (let [listL (&.to-list setL)
-                        (^open "L/") (list.Equivalence<List> number.Equivalence<Nat>)]
+                        (^open "L/.") (list.Equivalence<List> number.Equivalence<Nat>)]
                     (L/= listL
                          (list.sort n/< listL))))
 
diff --git a/stdlib/test/test/lux/data/collection/tree/rose.lux b/stdlib/test/test/lux/data/collection/tree/rose.lux
index f1cb294fb..a891807b8 100644
--- a/stdlib/test/test/lux/data/collection/tree/rose.lux
+++ b/stdlib/test/test/lux/data/collection/tree/rose.lux
@@ -5,10 +5,10 @@
    [data
     ["." product]
     ["." number]
-    [text ("text/" Equivalence<Text>)
+    [text ("text/." Equivalence<Text>)
      format]
     [collection
-     ["." list ("list/" Functor<List> Fold<List>)]
+     ["." list ("list/." Functor<List> Fold<List>)]
      [tree
       ["&" rose]]]]
    [math
@@ -34,8 +34,8 @@
   (<| (times +100)
       (do @
         [[size sample] gen-tree
-         #let [(^open "&/") (&.Equivalence<Tree> number.Equivalence<Nat>)
-               (^open "&/") &.Fold<Tree>
+         #let [(^open "&/.") (&.Equivalence<Tree> number.Equivalence<Nat>)
+               (^open "&/.") &.Fold<Tree>
                concat (function (_ addition partial) (format partial (%n addition)))]]
         ($_ seq
             (test "Can compare trees for equivalence."
diff --git a/stdlib/test/test/lux/data/collection/tree/rose/zipper.lux b/stdlib/test/test/lux/data/collection/tree/rose/zipper.lux
index 1a24a805b..01ba51e80 100644
--- a/stdlib/test/test/lux/data/collection/tree/rose/zipper.lux
+++ b/stdlib/test/test/lux/data/collection/tree/rose/zipper.lux
@@ -40,8 +40,8 @@
          new-val r.nat
          pre-val r.nat
          post-val r.nat
-         #let [(^open "tree/") (rose.Equivalence<Tree> number.Equivalence<Nat>)
-               (^open "list/") (list.Equivalence<List> number.Equivalence<Nat>)]]
+         #let [(^open "tree/.") (rose.Equivalence<Tree> number.Equivalence<Nat>)
+               (^open "list/.") (list.Equivalence<List> number.Equivalence<Nat>)]]
         ($_ seq
             (test "Trees can be converted to/from zippers."
                   (|> sample
diff --git a/stdlib/test/test/lux/data/color.lux b/stdlib/test/test/lux/data/color.lux
index 246945686..d9555a79c 100644
--- a/stdlib/test/test/lux/data/color.lux
+++ b/stdlib/test/test/lux/data/color.lux
@@ -4,7 +4,7 @@
     [monad (#+ do)]]
    [data
     ["@" color]
-    [number ("frac/" Number<Frac>)]]
+    [number ("frac/." Number<Frac>)]]
    ["." math
     ["r" random]]]
   lux/test)
@@ -79,7 +79,7 @@
                              (distance (@.brighter ratio colorful) white))))
             (test "Can calculate complement."
                   (let [~any (@.complement any)
-                        (^open "@/") @.Equivalence<Color>]
+                        (^open "@/.") @.Equivalence<Color>]
                     (and (not (@/= any ~any))
                          (@/= any (@.complement ~any)))))
             (test "Can saturate color."
diff --git a/stdlib/test/test/lux/data/error.lux b/stdlib/test/test/lux/data/error.lux
index 9b69c6a80..bea6146aa 100644
--- a/stdlib/test/test/lux/data/error.lux
+++ b/stdlib/test/test/lux/data/error.lux
@@ -9,8 +9,8 @@
   lux/test)
 
 (context: "Errors"
-  (let [(^open "&/") &.Apply<Error>
-        (^open "&/") &.Monad<Error>]
+  (let [(^open "&/.") &.Apply<Error>
+        (^open "&/.") &.Monad<Error>]
     ($_ seq
         (test "Functor correctly handles both cases."
               (and (|> (: (&.Error Int) (#&.Success 10))
@@ -48,7 +48,7 @@
 
 (context: "Monad transformer"
   (let [lift (&.lift io.Monad<IO>)
-        (^open "io/") io.Monad<IO>]
+        (^open "io/.") io.Monad<IO>]
     (test "Can add error functionality to any monad."
           (|> (io.run (do (&.ErrorT io.Monad<IO>)
                         [a (lift (io/wrap 123))
diff --git a/stdlib/test/test/lux/data/format/json.lux b/stdlib/test/test/lux/data/format/json.lux
index 2183c5004..60cecbd6d 100644
--- a/stdlib/test/test/lux/data/format/json.lux
+++ b/stdlib/test/test/lux/data/format/json.lux
@@ -58,8 +58,8 @@
   (<| (times +100)
       (do @
         [sample gen-json
-         #let [(^open "@/") @.Equivalence<JSON>
-               (^open "@/") @.Codec<Text,JSON>]]
+         #let [(^open "@/.") @.Equivalence<JSON>
+               (^open "@/.") @.Codec<Text,JSON>]]
         ($_ seq
             (test "Every JSON is equal to itself."
                   (@/= sample sample))
@@ -171,8 +171,8 @@
       ## (times +100)
       (do @
         [sample gen-record
-         #let [(^open "@/") Equivalence<Record>
-               (^open "@/") Codec<JSON,Record>]]
+         #let [(^open "@/.") Equivalence<Record>
+               (^open "@/.") Codec<JSON,Record>]]
         (test "Can encode/decode arbitrary types."
               (|> sample @/encode @/decode
                   (case> (#e.Success result)
diff --git a/stdlib/test/test/lux/data/format/xml.lux b/stdlib/test/test/lux/data/format/xml.lux
index 8795e7f27..d09dc1b45 100644
--- a/stdlib/test/test/lux/data/format/xml.lux
+++ b/stdlib/test/test/lux/data/format/xml.lux
@@ -8,15 +8,15 @@
     ["." ident]
     ["E" error]
     ["." maybe]
-    ["." text ("text/" Equivalence<Text>)
+    ["." text ("text/." Equivalence<Text>)
      format]
     [format
      ["&" xml]]
     [collection
      ["dict" dictionary]
-     ["." list ("list/" Functor<List>)]]]
+     ["." list ("list/." Functor<List>)]]]
    [math
-    ["r" random ("r/" Monad<Random>)]]]
+    ["r" random ("r/." Monad<Random>)]]]
   lux/test)
 
 (def: char-range
@@ -62,8 +62,8 @@
   (<| (times +100)
       (do @
         [sample gen-xml
-         #let [(^open "&/") &.Equivalence<XML>
-               (^open "&/") &.Codec<Text,XML>]]
+         #let [(^open "&/.") &.Equivalence<XML>
+               (^open "&/.") &.Codec<Text,XML>]]
         ($_ seq
             (test "Every XML is equal to itself."
                   (&/= sample sample))
diff --git a/stdlib/test/test/lux/data/ident.lux b/stdlib/test/test/lux/data/ident.lux
index 622edf474..ed9339f01 100644
--- a/stdlib/test/test/lux/data/ident.lux
+++ b/stdlib/test/test/lux/data/ident.lux
@@ -5,7 +5,7 @@
     pipe]
    [data
     ["&" ident]
-    ["." text ("text/" Equivalence<Text>)
+    ["." text ("text/." Equivalence<Text>)
      format]]
    [math
     ["r" random]]]
@@ -30,8 +30,8 @@
          module2 (gen-part sizeM2)
          name2 (gen-part sizeN2)
          #let [ident2 [module2 name2]]
-         #let [(^open "&/") &.Equivalence<Ident>
-               (^open "&/") &.Codec<Text,Ident>]]
+         #let [(^open "&/.") &.Equivalence<Ident>
+               (^open "&/.") &.Codec<Text,Ident>]]
         ($_ seq
             (test "Can get the module & name parts of an ident."
                   (and (is? module1 (&.module ident1))
@@ -58,7 +58,7 @@
             ))))
 
 (context: "Ident-related macros."
-  (let [(^open "&/") &.Equivalence<Ident>]
+  (let [(^open "&/.") &.Equivalence<Ident>]
     ($_ seq
         (test "Can obtain Ident from symbol."
               (and (&/= ["lux" "yolo"] (ident-for .yolo))
diff --git a/stdlib/test/test/lux/data/identity.lux b/stdlib/test/test/lux/data/identity.lux
index 9fe0cb50e..c7703f24b 100644
--- a/stdlib/test/test/lux/data/identity.lux
+++ b/stdlib/test/test/lux/data/identity.lux
@@ -5,13 +5,13 @@
     comonad]
    [data
     ["&" identity]
-    [text ("text/" Monoid<Text> Equivalence<Text>)]]]
+    [text ("text/." Monoid<Text> Equivalence<Text>)]]]
   lux/test)
 
 (context: "Identity"
-  (let [(^open "&/") &.Apply<Identity>
-        (^open "&/") &.Monad<Identity>
-        (^open "&/") &.CoMonad<Identity>]
+  (let [(^open "&/.") &.Apply<Identity>
+        (^open "&/.") &.Monad<Identity>
+        (^open "&/.") &.CoMonad<Identity>]
     ($_ seq
         (test "Functor does not affect values."
               (text/= "yololol" (&/map (text/compose "yolo") "lol")))
diff --git a/stdlib/test/test/lux/data/lazy.lux b/stdlib/test/test/lux/data/lazy.lux
index 785f08719..094a1d164 100644
--- a/stdlib/test/test/lux/data/lazy.lux
+++ b/stdlib/test/test/lux/data/lazy.lux
@@ -46,8 +46,8 @@
                       (n/= (inc sample))))
             
             (test "Apply apply."
-                  (let [(^open "&/") &.Monad<Lazy>
-                        (^open "&/") &.Apply<Lazy>]
+                  (let [(^open "&/.") &.Monad<Lazy>
+                        (^open "&/.") &.Apply<Lazy>]
                     (|> (&/apply (&/wrap inc) (&/wrap sample))
                         &.thaw
                         (n/= (inc sample)))))
diff --git a/stdlib/test/test/lux/data/maybe.lux b/stdlib/test/test/lux/data/maybe.lux
index 4a1d39552..95ee39d91 100644
--- a/stdlib/test/test/lux/data/maybe.lux
+++ b/stdlib/test/test/lux/data/maybe.lux
@@ -1,18 +1,18 @@
 (.module:
   [lux #*
-   ["." io ("io/" Monad<IO>)]
+   ["." io ("io/." Monad<IO>)]
    [control
     ["M" monad (#+ do Monad)]
     pipe]
    [data
-    ["&" maybe ("&/" Monoid<Maybe>)]
-    ["." text ("text/" Monoid<Text>)]]]
+    ["&" maybe ("&/." Monoid<Maybe>)]
+    ["." text ("text/." Monoid<Text>)]]]
   lux/test)
 
 (context: "Maybe"
-  (let [(^open "&/") &.Apply<Maybe>
-        (^open "&/") &.Monad<Maybe>
-        (^open "&/") (&.Equivalence<Maybe> text.Equivalence<Text>)]
+  (let [(^open "&/.") &.Apply<Maybe>
+        (^open "&/.") &.Monad<Maybe>
+        (^open "&/.") (&.Equivalence<Maybe> text.Equivalence<Text>)]
     ($_ seq
         (test "Can compare Maybe values."
               (and (&/= #.None #.None)
diff --git a/stdlib/test/test/lux/data/number.lux b/stdlib/test/test/lux/data/number.lux
index fc96fd8ff..93c0ac68d 100644
--- a/stdlib/test/test/lux/data/number.lux
+++ b/stdlib/test/test/lux/data/number.lux
@@ -5,7 +5,7 @@
     pipe]
    [data
     number
-    [text ("text/" Equivalence<Text>)
+    [text ("text/." Equivalence<Text>)
      format]]
    [math
     ["r" random]]]
@@ -33,8 +33,8 @@
      (<| (times +100)
          (do @
            [x rand-gen
-            #let [(^open) <Number>
-                  (^open) <Order>]]
+            #let [(^open ".") <Number>
+                  (^open ".") <Order>]]
            (test "" (and (>= x (abs x))
                          ## abs(0.0) == 0.0 && negate(abs(0.0)) == -0.0
                          (or (text/= "Frac" category)
@@ -56,8 +56,8 @@
      (<| (times +100)
          (do @
            [x rand-gen]
-           (test "" (let [(^open) <Number>
-                          (^open) <Order>]
+           (test "" (let [(^open ".") <Number>
+                          (^open ".") <Order>]
                       (and (> x
                               (:: <Enum> succ x))
                            (< x
@@ -78,8 +78,8 @@
      (<| (times +100)
          (do @
            [x (|> rand-gen (r.filter <test>))
-            #let [(^open) <Number>
-                  (^open) <Order>]]
+            #let [(^open ".") <Number>
+                  (^open ".") <Order>]]
            (test "" (and (<= x (:: <Interval> bottom))
                          (>= x (:: <Interval> top)))))))]
 
@@ -95,9 +95,9 @@
      (<| (times +100)
          (do @
            [x (|> rand-gen (:: @ map (|>> (:: <Number> abs) <cap>)) (r.filter <test>))
-            #let [(^open) <Number>
-                  (^open) <Order>
-                  (^open) <Monoid>]]
+            #let [(^open ".") <Number>
+                  (^open ".") <Order>
+                  (^open ".") <Monoid>]]
            (test "Composing with identity doesn't change the value."
                  (and (= x (compose identity x))
                       (= x (compose x identity))
diff --git a/stdlib/test/test/lux/data/number/complex.lux b/stdlib/test/test/lux/data/number/complex.lux
index 838c625c6..9347b891c 100644
--- a/stdlib/test/test/lux/data/number/complex.lux
+++ b/stdlib/test/test/lux/data/number/complex.lux
@@ -4,10 +4,10 @@
     [monad (#+ do Monad)]
     pipe]
    [data
-    ["." number ("frac/" Number<Frac>)
+    ["." number ("frac/." Number<Frac>)
      ["&" complex]]
     [collection
-     ["." list ("list/" Functor<List>)]]]
+     ["." list ("list/." Functor<List>)]]]
    ["." math
     ["r" random]]]
   lux/test)
diff --git a/stdlib/test/test/lux/data/number/ratio.lux b/stdlib/test/test/lux/data/number/ratio.lux
index 32fc03e7a..8a2f1640d 100644
--- a/stdlib/test/test/lux/data/number/ratio.lux
+++ b/stdlib/test/test/lux/data/number/ratio.lux
@@ -5,7 +5,7 @@
     pipe]
    [data
     [number
-     ["&" ratio ("&/" Number<Ratio>)]]]
+     ["&" ratio ("&/." Number<Ratio>)]]]
    [math
     ["r" random]]]
   lux/test)
@@ -106,7 +106,7 @@
   (<| (times +100)
       (do @
         [sample gen-ratio
-         #let [(^open "&/") &.Codec<Text,Ratio>]]
+         #let [(^open "&/.") &.Codec<Text,Ratio>]]
         (test "Can encode/decode ratios."
               (|> sample &/encode &/decode
                   (case> (#.Right output)
diff --git a/stdlib/test/test/lux/data/sum.lux b/stdlib/test/test/lux/data/sum.lux
index 4d699581f..a771a23bb 100644
--- a/stdlib/test/test/lux/data/sum.lux
+++ b/stdlib/test/test/lux/data/sum.lux
@@ -10,7 +10,7 @@
   lux/test)
 
 (context: "Sum operations"
-  (let [(^open "List/") (list.Equivalence<List> text.Equivalence<Text>)]
+  (let [(^open "List/.") (list.Equivalence<List> text.Equivalence<Text>)]
     ($_ seq
         (test "Can inject values into Either."
               (and (|> (left "Hello") (case> (+0 "Hello") #1 _ #0))
diff --git a/stdlib/test/test/lux/data/text.lux b/stdlib/test/test/lux/data/text.lux
index bb7ee219a..e4982cab7 100644
--- a/stdlib/test/test/lux/data/text.lux
+++ b/stdlib/test/test/lux/data/text.lux
@@ -66,7 +66,7 @@
                fake-sample (&.join-with " " (list sampleL sampleR))
                dup-sample (&.join-with "" (list sampleL sampleR))
                enclosed-sample (&.enclose [sampleR sampleR] sampleL)
-               (^open) &.Equivalence<Text>]]
+               (^open ".") &.Equivalence<Text>]]
         (test "" (and (not (= sample fake-sample))
                       (= sample dup-sample)
                       (&.starts-with? sampleL sample)
@@ -114,7 +114,7 @@
          parts (r.list sizeL part-gen)
          #let [sample1 (&.concat (list.interpose sep1 parts))
                sample2 (&.concat (list.interpose sep2 parts))
-               (^open "&/") &.Equivalence<Text>]]
+               (^open "&/.") &.Equivalence<Text>]]
         ($_ seq
             (test "Can split text through a separator."
                   (n/= (list.size parts)
@@ -126,7 +126,7 @@
             ))))
 
 (context: "Structures"
-  (let [(^open "&/") &.Order<Text>]
+  (let [(^open "&/.") &.Order<Text>]
     ($_ seq
         (test "" (&/< "bcd" "abc"))
         (test "" (not (&/< "abc" "abc")))
diff --git a/stdlib/test/test/lux/data/text/format.lux b/stdlib/test/test/lux/data/text/format.lux
index eb42a088d..a66a579b6 100644
--- a/stdlib/test/test/lux/data/text/format.lux
+++ b/stdlib/test/test/lux/data/text/format.lux
@@ -8,7 +8,7 @@
   lux/test)
 
 (context: "Formatters"
-  (let [(^open "&/") text.Equivalence<Text>]
+  (let [(^open "&/.") text.Equivalence<Text>]
     ($_ seq
         (test "Can format common values simply."
               (and (&/= "#1" (%b #1))
diff --git a/stdlib/test/test/lux/data/text/lexer.lux b/stdlib/test/test/lux/data/text/lexer.lux
index d86093f3a..392b0ccc8 100644
--- a/stdlib/test/test/lux/data/text/lexer.lux
+++ b/stdlib/test/test/lux/data/text/lexer.lux
@@ -6,7 +6,7 @@
     ["p" parser]]
    [data
     ["E" error]
-    ["." text ("text/" Equivalence<Text>)
+    ["." text ("text/." Equivalence<Text>)
      format
      ["&" lexer]]
     [collection
@@ -33,7 +33,7 @@
 
 (def: (should-passL test input)
   (-> (List Text) (E.Error (List Text)) Bit)
-  (let [(^open "list/") (list.Equivalence<List> text.Equivalence<Text>)]
+  (let [(^open "list/.") (list.Equivalence<List> text.Equivalence<Text>)]
     (case input
       (#.Right output)
       (list/= test output)
diff --git a/stdlib/test/test/lux/data/text/regex.lux b/stdlib/test/test/lux/data/text/regex.lux
index c177e07a4..2b9a5b9df 100644
--- a/stdlib/test/test/lux/data/text/regex.lux
+++ b/stdlib/test/test/lux/data/text/regex.lux
@@ -5,7 +5,7 @@
     pipe
     ["p" parser]]
    [data
-    [text ("text/" Equivalence<Text>)
+    [text ("text/." Equivalence<Text>)
      format
      ["." lexer (#+ Lexer)]
      ["&" regex]]]
diff --git a/stdlib/test/test/lux/host.jvm.lux b/stdlib/test/test/lux/host.jvm.lux
index b2b88148c..400f786b0 100644
--- a/stdlib/test/test/lux/host.jvm.lux
+++ b/stdlib/test/test/lux/host.jvm.lux
@@ -4,7 +4,7 @@
     [monad (#+ do Monad)]
     pipe]
    [data
-    [text ("text/" Equivalence<Text>)]]
+    [text ("text/." Equivalence<Text>)]]
    ["&" host (#+ import: class: interface: object)]
    [math
     ["r" random]]]
diff --git a/stdlib/test/test/lux/io.lux b/stdlib/test/test/lux/io.lux
index 0fb9018a6..1cef1097d 100644
--- a/stdlib/test/test/lux/io.lux
+++ b/stdlib/test/test/lux/io.lux
@@ -5,7 +5,7 @@
     ["M" monad (#+ do Monad)]]
    [data
     [number]
-    [text ("text/" Equivalence<Text>)
+    [text ("text/." Equivalence<Text>)
      format]]]
   lux/test)
 
@@ -14,8 +14,8 @@
       (test "" (text/= "YOLO" (&.run (&.io "YOLO"))))
       (test "" (i/= 11 (&.run (:: &.Functor<IO> map inc (&.io 10)))))
       (test "" (i/= 10 (&.run (:: &.Monad<IO> wrap 10))))
-      (test "" (i/= 30 (&.run (let [(^open "&/") &.Apply<IO>
-                                    (^open "&/") &.Monad<IO>]
+      (test "" (i/= 30 (&.run (let [(^open "&/.") &.Apply<IO>
+                                    (^open "&/.") &.Monad<IO>]
                                 (&/apply (&/wrap (i/+ 10)) (&/wrap 20))))))
       (test "" (i/= 30 (&.run (do &.Monad<IO>
                                 [f (wrap i/+)
diff --git a/stdlib/test/test/lux/language/compiler/analysis/case.lux b/stdlib/test/test/lux/language/compiler/analysis/case.lux
index c15bb192a..183ae7da7 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/case.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/case.lux
@@ -6,12 +6,12 @@
    [data
     ["." product]
     ["." maybe]
-    ["." text ("text/" Equivalence<Text>)]
+    ["." text ("text/." Equivalence<Text>)]
     [collection
-     ["." list ("list/" Monad<List>)]
+     ["." list ("list/." Monad<List>)]
      ["." set]]]
    [math
-    ["r" random ("random/" Monad<Random>)]]
+    ["r" random ("random/." Monad<Random>)]]
    [macro
     ["." code]]
    [language
diff --git a/stdlib/test/test/lux/language/compiler/analysis/function.lux b/stdlib/test/test/lux/language/compiler/analysis/function.lux
index f3c7dc5b5..559a4a841 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/function.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/function.lux
@@ -7,10 +7,10 @@
     ["e" error]
     ["." maybe]
     ["." product]
-    [text ("text/" Equivalence<Text>)
+    [text ("text/." Equivalence<Text>)
      format]
     [collection
-     ["." list ("list/" Functor<List>)]]]
+     ["." list ("list/." Functor<List>)]]]
    [math
     ["r" random]]
    ["." macro
diff --git a/stdlib/test/test/lux/language/compiler/analysis/primitive.lux b/stdlib/test/test/lux/language/compiler/analysis/primitive.lux
index c5a5bee5a..e49284c1a 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/primitive.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/primitive.lux
@@ -9,11 +9,11 @@
     [text
      format]]
    [math
-    ["r" random ("random/" Monad<Random>)]]
+    ["r" random ("random/." Monad<Random>)]]
    [macro
     ["." code]]
    ["." language
-    [".L" type ("type/" Equivalence<Type>)]
+    [".L" type ("type/." Equivalence<Type>)]
     ["." compiler
      ["." init]
      ["." analysis (#+ Analysis Operation)
diff --git a/stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux b/stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux
index 82858a595..92afb7083 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux
@@ -16,7 +16,7 @@
    [macro
     ["." code]]
    [language
-    [type ("type/" Equivalence<Type>)]
+    [type ("type/." Equivalence<Type>)]
     ["." compiler
      ["." init]
      [analysis
diff --git a/stdlib/test/test/lux/language/compiler/analysis/reference.lux b/stdlib/test/test/lux/language/compiler/analysis/reference.lux
index 118b1b586..ac302db3e 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/reference.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/reference.lux
@@ -5,15 +5,15 @@
     pipe]
    [data
     ["e" error]
-    [ident ("ident/" Equivalence<Ident>)]
-    [text ("text/" Equivalence<Text>)]]
+    [ident ("ident/." Equivalence<Ident>)]
+    [text ("text/." Equivalence<Text>)]]
    [math
     ["r" random]]
    [macro
     ["." code]]
    ["." language]
    [language
-    [type ("type/" Equivalence<Type>)]
+    [type ("type/." Equivalence<Type>)]
     ["." reference]
     ["." compiler
      ["." init]
diff --git a/stdlib/test/test/lux/language/compiler/analysis/structure.lux b/stdlib/test/test/lux/language/compiler/analysis/structure.lux
index 79d040e51..c3c5a0dc2 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/structure.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/structure.lux
@@ -4,20 +4,20 @@
     [monad (#+ do)]
     pipe]
    [data
-    [bit ("bit/" Equivalence<Bit>)]
+    [bit ("bit/." Equivalence<Bit>)]
     ["e" error]
     ["." product]
     ["." maybe]
     ["." text]
     [collection
-     ["." list ("list/" Functor<List>)]
+     ["." list ("list/." Functor<List>)]
      ["." set]]]
    [math
     ["r" random]]
    [macro
     ["." code]]
    ["." language
-    ["." type ("type/" Equivalence<Type>)
+    ["." type ("type/." Equivalence<Type>)
      ["." check]]
     ["." compiler
      ["." init]
diff --git a/stdlib/test/test/lux/language/compiler/synthesis/case.lux b/stdlib/test/test/lux/language/compiler/synthesis/case.lux
index 2acde1a5b..70e13af4b 100644
--- a/stdlib/test/test/lux/language/compiler/synthesis/case.lux
+++ b/stdlib/test/test/lux/language/compiler/synthesis/case.lux
@@ -4,7 +4,7 @@
     [monad (#+ do)]
     pipe]
    [data
-    ["." error ("error/" Functor<Error>)]]
+    ["." error ("error/." Functor<Error>)]]
    [language
     ["." reference]
     ["." compiler
diff --git a/stdlib/test/test/lux/language/compiler/synthesis/function.lux b/stdlib/test/test/lux/language/compiler/synthesis/function.lux
index 35d2c4dd6..62d8c97a0 100644
--- a/stdlib/test/test/lux/language/compiler/synthesis/function.lux
+++ b/stdlib/test/test/lux/language/compiler/synthesis/function.lux
@@ -11,11 +11,11 @@
     [text
      format]
     [collection
-     ["." list ("list/" Functor<List> Fold<List>)]
+     ["." list ("list/." Functor<List> Fold<List>)]
      ["dict" dictionary (#+ Dictionary)]
      ["." set]]]
    [language
-    ["." reference (#+ Variable) ("variable/" Equivalence<Variable>)]
+    ["." reference (#+ Variable) ("variable/." Equivalence<Variable>)]
     ["." compiler
      ["." analysis (#+ Arity Analysis)]
      ["//" synthesis (#+ Synthesis)
diff --git a/stdlib/test/test/lux/language/compiler/synthesis/structure.lux b/stdlib/test/test/lux/language/compiler/synthesis/structure.lux
index 2b86e318a..dcec26fb9 100644
--- a/stdlib/test/test/lux/language/compiler/synthesis/structure.lux
+++ b/stdlib/test/test/lux/language/compiler/synthesis/structure.lux
@@ -4,7 +4,7 @@
     [monad (#+ do)]
     pipe]
    [data
-    [bit ("bit/" Equivalence<Bit>)]
+    [bit ("bit/." Equivalence<Bit>)]
     ["." product]
     ["." error]
     [collection
diff --git a/stdlib/test/test/lux/language/syntax.lux b/stdlib/test/test/lux/language/syntax.lux
index 8ead2f863..469e07c10 100644
--- a/stdlib/test/test/lux/language/syntax.lux
+++ b/stdlib/test/test/lux/language/syntax.lux
@@ -12,7 +12,7 @@
      ["." list]
      ["dict" dictionary (#+ Dictionary)]]]
    [math
-    ["r" random ("r/" Monad<Random>)]]
+    ["r" random ("r/." Monad<Random>)]]
    [macro
     ["." code]]
    [language
diff --git a/stdlib/test/test/lux/language/type.lux b/stdlib/test/test/lux/language/type.lux
index ae0b5283b..8db1c5a19 100644
--- a/stdlib/test/test/lux/language/type.lux
+++ b/stdlib/test/test/lux/language/type.lux
@@ -28,7 +28,7 @@
 
 (def: gen-type
   (r.Random Type)
-  (let [(^open "R/") r.Monad<Random>]
+  (let [(^open "R/.") r.Monad<Random>]
     (r.rec (function (_ gen-type)
              ($_ r.alt
                  (r.seq gen-name (R/wrap (list)))
@@ -95,8 +95,8 @@
                                    #1)))
                      (list.repeat size)
                      (M.seq @))
-         #let [(^open "&/") &.Equivalence<Type>
-               (^open "L/") (list.Equivalence<List> &.Equivalence<Type>)]]
+         #let [(^open "&/.") &.Equivalence<Type>
+               (^open "L/.") (list.Equivalence<List> &.Equivalence<Type>)]]
         (with-expansions
           [<struct-tests> (do-template [<desc> <ctor> <dtor> <unit>]
                             [(test (format "Can build and tear-down " <desc> " types.")
@@ -125,8 +125,8 @@
 
                                  _
                                  #1))))
-         #let [(^open "&/") &.Equivalence<Type>
-               (^open "L/") (list.Equivalence<List> &.Equivalence<Type>)]]
+         #let [(^open "&/.") &.Equivalence<Type>
+               (^open "L/.") (list.Equivalence<List> &.Equivalence<Type>)]]
         ($_ seq
             (test "Can build and tear-down function types."
                   (let [[inputs output] (|> (&.function members extra) &.flatten-function)]
@@ -150,7 +150,7 @@
 
                                  _
                                  #1))))
-         #let [(^open "&/") &.Equivalence<Type>]]
+         #let [(^open "&/.") &.Equivalence<Type>]]
         (with-expansions
           [<quant-tests> (do-template [<desc> <ctor> <dtor>]
                            [(test (format "Can build and tear-down " <desc> " types.")
diff --git a/stdlib/test/test/lux/language/type/check.lux b/stdlib/test/test/lux/language/type/check.lux
index 868039238..a8cf1963f 100644
--- a/stdlib/test/test/lux/language/type/check.lux
+++ b/stdlib/test/test/lux/language/type/check.lux
@@ -7,14 +7,14 @@
     ["." product]
     ["." maybe]
     ["." number]
-    [text ("text/" Equivalence<Text>)]
+    [text ("text/." Equivalence<Text>)]
     [collection
-     ["." list ("list/" Functor<List>)]
+     ["." list ("list/." Functor<List>)]
      ["." set]]]
    [math
     ["r" random]]
    [language
-    ["." type ("type/" Equivalence<Type>)
+    ["." type ("type/." Equivalence<Type>)
      ["@" check]]]]
   lux/test)
 
@@ -31,7 +31,7 @@
 
 (def: gen-type
   (r.Random Type)
-  (let [(^open "r/") r.Monad<Random>]
+  (let [(^open "r/.") r.Monad<Random>]
     (r.rec (function (_ gen-type)
              ($_ r.alt
                  (r.seq gen-name (r/wrap (list)))
diff --git a/stdlib/test/test/lux/macro/code.lux b/stdlib/test/test/lux/macro/code.lux
index 1a7eba2b7..735c28f64 100644
--- a/stdlib/test/test/lux/macro/code.lux
+++ b/stdlib/test/test/lux/macro/code.lux
@@ -5,7 +5,7 @@
     [monad (#+ do Monad)]]
    [data
     [number]
-    [text ("text/" Equivalence<Text>)
+    [text ("text/." Equivalence<Text>)
      format]]
    [math ["r" random]]
    [macro ["&" code]]]
diff --git a/stdlib/test/test/lux/macro/poly/equivalence.lux b/stdlib/test/test/lux/macro/poly/equivalence.lux
index d6e48ed13..3e554442b 100644
--- a/stdlib/test/test/lux/macro/poly/equivalence.lux
+++ b/stdlib/test/test/lux/macro/poly/equivalence.lux
@@ -6,7 +6,7 @@
    [data
     ["." bit]
     ["." maybe]
-    [number ("int/" Number<Int>)]
+    [number ("int/." Number<Int>)]
     ["." text
      format]
     [collection
@@ -68,6 +68,6 @@
   (<| (times +100)
       (do @
         [sample gen-record
-         #let [(^open "&/") Equivalence<Record>]]
+         #let [(^open "&/.") Equivalence<Record>]]
         (test "Every instance equals itself."
               (&/= sample sample)))))
diff --git a/stdlib/test/test/lux/math.lux b/stdlib/test/test/lux/math.lux
index ec38702ea..c20a89c60 100644
--- a/stdlib/test/test/lux/math.lux
+++ b/stdlib/test/test/lux/math.lux
@@ -3,8 +3,8 @@
    [control
     [monad (#+ do Monad)]]
    [data
-    [bit ("bit/" Equivalence<Bit>)]
-    [number ("frac/" Number<Frac>)]]
+    [bit ("bit/." Equivalence<Bit>)]
+    [number ("frac/." Number<Frac>)]]
    ["&" math
     ["r" random]]]
   lux/test)
diff --git a/stdlib/test/test/lux/math/logic/fuzzy.lux b/stdlib/test/test/lux/math/logic/fuzzy.lux
index 95c231dca..585857883 100644
--- a/stdlib/test/test/lux/math/logic/fuzzy.lux
+++ b/stdlib/test/test/lux/math/logic/fuzzy.lux
@@ -3,7 +3,7 @@
    [control
     [monad (#+ do Monad)]]
    [data
-    [bit ("bit/" Equivalence<Bit>)]
+    [bit ("bit/." Equivalence<Bit>)]
     ["." number]
     [text
      format]
diff --git a/stdlib/test/test/lux/math/modular.lux b/stdlib/test/test/lux/math/modular.lux
index cfc40fcfa..cd1f637e9 100644
--- a/stdlib/test/test/lux/math/modular.lux
+++ b/stdlib/test/test/lux/math/modular.lux
@@ -4,7 +4,7 @@
     [monad (#+ do)]]
    [data
     ["." product]
-    [bit ("bit/" Equivalence<Bit>)]
+    [bit ("bit/." Equivalence<Bit>)]
     ["e" error]
     [text
      format]]
@@ -12,7 +12,7 @@
     ["r" random]
     ["/" modular]]
    [language
-    [type ("type/" Equivalence<Type>)]]]
+    [type ("type/." Equivalence<Type>)]]]
   lux/test)
 
 (def: %3 (/.modulus 3))
@@ -116,7 +116,7 @@
                     #1))
 
             (test "Can encode/decode to text."
-                  (let [(^open "mod/") (/.Codec<Text,Mod> normalM)]
+                  (let [(^open "mod/.") (/.Codec<Text,Mod> normalM)]
                     (case (|> subject mod/encode mod/decode)
                       (#e.Success output)
                       (/.m/= subject output)
diff --git a/stdlib/test/test/lux/math/random.lux b/stdlib/test/test/lux/math/random.lux
index dfb58c46b..24f95bd30 100644
--- a/stdlib/test/test/lux/math/random.lux
+++ b/stdlib/test/test/lux/math/random.lux
@@ -51,7 +51,7 @@
             (test "Can filter values."
                   (n/<= top filtered))
             (test "Can shuffle rows."
-                  (let [(^open "v/") (row.Equivalence<Row> number.Equivalence<Nat>)
+                  (let [(^open "v/.") (row.Equivalence<Row> number.Equivalence<Nat>)
                         sorted (row.from-list sorted)]
                     (and (not (v/= sorted shuffled))
                          (v/= sorted (row.from-list re-sorted)))))
diff --git a/stdlib/test/test/lux/time/date.lux b/stdlib/test/test/lux/time/date.lux
index 72c15f4f5..ecccbc034 100644
--- a/stdlib/test/test/lux/time/date.lux
+++ b/stdlib/test/test/lux/time/date.lux
@@ -6,7 +6,7 @@
    [data
     ["." error]]
    [math
-    ["r" random ("random/" Monad<Random>)]]
+    ["r" random ("random/." Monad<Random>)]]
    [time
     ["@." instant]
     ["@" date]]]
@@ -33,7 +33,7 @@
   (<| (times +100)
       (do @
         [sample month
-         #let [(^open "@/") @.Equivalence<Month>]]
+         #let [(^open "@/.") @.Equivalence<Month>]]
         (test "Every value equals itself."
               (@/= sample sample)))))
 
@@ -42,7 +42,7 @@
       (do @
         [reference month
          sample month
-         #let [(^open "@/") @.Order<Month>]]
+         #let [(^open "@/.") @.Order<Month>]]
         (test "Valid Order."
               (and (or (@/< reference sample)
                        (@/>= reference sample))
@@ -53,7 +53,7 @@
   (<| (times +100)
       (do @
         [sample month
-         #let [(^open "@/") @.Enum<Month>]]
+         #let [(^open "@/.") @.Enum<Month>]]
         (test "Valid Enum."
               (and (not (@/= (@/succ sample)
                              sample))
@@ -76,7 +76,7 @@
   (<| (times +100)
       (do @
         [sample day
-         #let [(^open "@/") @.Equivalence<Day>]]
+         #let [(^open "@/.") @.Equivalence<Day>]]
         (test "Every value equals itself."
               (@/= sample sample)))))
 
@@ -85,7 +85,7 @@
       (do @
         [reference day
          sample day
-         #let [(^open "@/") @.Order<Day>]]
+         #let [(^open "@/.") @.Order<Day>]]
         (test "Valid Order."
               (and (or (@/< reference sample)
                        (@/>= reference sample))
@@ -96,7 +96,7 @@
   (<| (times +100)
       (do @
         [sample day
-         #let [(^open "@/") @.Enum<Day>]]
+         #let [(^open "@/.") @.Enum<Day>]]
         (test "Valid Enum."
               (and (not (@/= (@/succ sample)
                              sample))
@@ -113,7 +113,7 @@
   (<| (times +100)
       (do @
         [sample date
-         #let [(^open "@/") @.Equivalence<Date>]]
+         #let [(^open "@/.") @.Equivalence<Date>]]
         (test "Every value equals itself."
               (@/= sample sample)))))
 
@@ -122,7 +122,7 @@
       (do @
         [reference date
          sample date
-         #let [(^open "@/") @.Order<Date>]]
+         #let [(^open "@/.") @.Order<Date>]]
         (test "Valid Order."
               (and (or (@/< reference sample)
                        (@/>= reference sample))
@@ -134,8 +134,8 @@
       ## (times +100)
       (do @
         [sample date
-         #let [(^open "@/") @.Equivalence<Date>
-               (^open "@/") @.Codec<Text,Date>]]
+         #let [(^open "@/.") @.Equivalence<Date>
+               (^open "@/.") @.Codec<Text,Date>]]
         (test "Can encode/decode dates."
               (|> sample
                   @/encode
diff --git a/stdlib/test/test/lux/time/duration.lux b/stdlib/test/test/lux/time/duration.lux
index f746f9217..199eabe24 100644
--- a/stdlib/test/test/lux/time/duration.lux
+++ b/stdlib/test/test/lux/time/duration.lux
@@ -26,7 +26,7 @@
   (<| (times +100)
       (do @
         [sample duration
-         #let [(^open "@/") @.Equivalence<Duration>]]
+         #let [(^open "@/.") @.Equivalence<Duration>]]
         (test "Every duration equals itself."
               (@/= sample sample)))))
 
@@ -35,7 +35,7 @@
       (do @
         [reference duration
          sample duration
-         #let [(^open "@/") @.Order<Duration>]]
+         #let [(^open "@/.") @.Order<Duration>]]
         (test "Can compare times."
               (and (or (@/< reference sample)
                        (@/>= reference sample))
@@ -48,7 +48,7 @@
         [sample (|> duration (:: @ map (@.frame @.day)))
          frame duration
          factor (|> r.int (:: @ map (|>> (i/% 10) (i/max 1))))
-         #let [(^open "@/") @.Order<Duration>]]
+         #let [(^open "@/.") @.Order<Duration>]]
         ($_ seq
             (test "Can scale a duration."
                   (|> sample (@.scale factor) (@.query sample) (i/= factor)))
@@ -77,8 +77,8 @@
   (<| (times +100)
       (do @
         [sample duration
-         #let [(^open "@/") @.Equivalence<Duration>
-               (^open "@/") @.Codec<Text,Duration>]]
+         #let [(^open "@/.") @.Equivalence<Duration>
+               (^open "@/.") @.Codec<Text,Duration>]]
         (test "Can encode/decode durations."
               (E.default #0
                          (do E.Monad<Error>
diff --git a/stdlib/test/test/lux/time/instant.lux b/stdlib/test/test/lux/time/instant.lux
index 27161fa67..40902fa03 100644
--- a/stdlib/test/test/lux/time/instant.lux
+++ b/stdlib/test/test/lux/time/instant.lux
@@ -35,7 +35,7 @@
   (<| (times +100)
       (do @
         [sample instant
-         #let [(^open "@/") @.Equivalence<Instant>]]
+         #let [(^open "@/.") @.Equivalence<Instant>]]
         (test "Every instant equals itself."
               (@/= sample sample)))))
 
@@ -44,7 +44,7 @@
       (do @
         [reference instant
          sample instant
-         #let [(^open "@/") @.Order<Instant>]]
+         #let [(^open "@/.") @.Order<Instant>]]
         (test "Can compare instants."
               (and (or (@/< reference sample)
                        (@/>= reference sample))
@@ -55,7 +55,7 @@
   (<| (times +100)
       (do @
         [sample instant
-         #let [(^open "@/") @.Enum<Instant>]]
+         #let [(^open "@/.") @.Enum<Instant>]]
         (test "Valid Enum."
               (and (not (@/= (@/succ sample)
                              sample))
@@ -69,8 +69,8 @@
       (do @
         [sample instant
          span _duration.duration
-         #let [(^open "@/") @.Equivalence<Instant>
-               (^open "@d/") @d.Equivalence<Duration>]]
+         #let [(^open "@/.") @.Equivalence<Instant>
+               (^open "@d/.") @d.Equivalence<Duration>]]
         ($_ seq
             (test "The span of a instant and itself has an empty duration."
                   (|> sample (@.span sample) (@d/= @d.empty)))
@@ -86,8 +86,8 @@
 ##       ## (times +100)
 ##       (do @
 ##         [sample instant
-##          #let [(^open "@/") @.Equivalence<Instant>
-##                (^open "@/") @.Codec<Text,Instant>]]
+##          #let [(^open "@/.") @.Equivalence<Instant>
+##                (^open "@/.") @.Codec<Text,Instant>]]
 ##         (test "Can encode/decode instants."
 ##               (|> sample
 ##                   @/encode
diff --git a/stdlib/test/test/lux/type/implicit.lux b/stdlib/test/test/lux/type/implicit.lux
index 71e2f29c6..8bb1d0d48 100644
--- a/stdlib/test/test/lux/type/implicit.lux
+++ b/stdlib/test/test/lux/type/implicit.lux
@@ -6,7 +6,7 @@
     [functor]
     [monad (#+ do Monad)]]
    [data
-    [bit ("bit/" Equivalence<Bit>)]
+    [bit ("bit/." Equivalence<Bit>)]
     [number]
     [collection [list]]]
    [math
@@ -21,7 +21,7 @@
          y r.nat]
         ($_ seq
             (test "Can automatically select first-order structures."
-                  (let [(^open "list/") (list.Equivalence<List> number.Equivalence<Nat>)]
+                  (let [(^open "list/.") (list.Equivalence<List> number.Equivalence<Nat>)]
                     (and (bit/= (:: number.Equivalence<Nat> = x y)
                                 (::: = x y))
                          (list/= (list.n/range +1 +10)
diff --git a/stdlib/test/test/lux/world/net/tcp.lux b/stdlib/test/test/lux/world/net/tcp.lux
index 370697323..cda068a78 100644
--- a/stdlib/test/test/lux/world/net/tcp.lux
+++ b/stdlib/test/test/lux/world/net/tcp.lux
@@ -7,7 +7,7 @@
    [concurrency
     ["P" promise]
     ["T" task]
-    [frp ("frp/" Functor<Channel>)]]
+    [frp ("frp/." Functor<Channel>)]]
    [data
     ["E" error]
     ["." text
author	Eduardo Julian	2018-07-20 23:43:59 -0400
committer	Eduardo Julian	2018-07-20 23:43:59 -0400
commit	b0914546f8e8ea5ef970c1f92dbb0072aa22be63 (patch)
tree	f8ca4bf6bc4b3e8703ff1cb752a4e18b8973d3d5 /stdlib
parent	518a7467c4e0ef904afa8c59cff3594d6f63c552 (diff)