Re-named "Ident" to "Name".

41 files changed, 468 insertions, 498 deletions

diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux
index f96062238..e53709ce2 100644
--- a/stdlib/source/lux.lux
+++ b/stdlib/source/lux.lux
@@ -153,8 +153,8 @@
                              [dummy-cursor (+5 "Your standard, run-of-the-mill string values.")]]
                             #Nil))))])
 
-("lux def" Ident
- (+10 ["lux" "Ident"]
+("lux def" Name
+ (+10 ["lux" "Name"]
       (+2 Text Text))
  [dummy-cursor
   (+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])]
@@ -201,7 +201,7 @@
 ##   (#UnivQ (List Type) Type)
 ##   (#ExQ (List Type) Type)
 ##   (#Apply Type Type)
-##   (#Named Ident Type)
+##   (#Named Name Type)
 ##   )
 ("lux def" Type
  (+10 ["lux" "Type"]
@@ -231,7 +231,7 @@
                              (+1 ## "lux.Apply"
                               Type-Pair
                               ## "lux.Named"
-                              (+2 Ident Type)))))))))))))}
+                              (+2 Name Type)))))))))))))}
            ("lux check type" (+2 Type Type)))}
          ("lux check type" (+9 Type List)))}
        ("lux check type" (+9 (+4 +1) (+4 +0)))))
@@ -311,8 +311,8 @@
 ##   (#Rev Rev)
 ##   (#Frac Frac)
 ##   (#Text Text)
-##   (#Symbol Ident)
-##   (#Tag Ident)
+##   (#Symbol Name)
+##   (#Tag Name)
 ##   (#Form (List (w (Code' w))))
 ##   (#Tuple (List (w (Code' w))))
 ##   (#Record (List [(w (Code' w)) (w (Code' w))])))
@@ -334,9 +334,9 @@
                           (#Sum ## "lux.Text"
                            Text
                            (#Sum ## "lux.Symbol"
-                            Ident
+                            Name
                             (#Sum ## "lux.Tag"
-                             Ident
+                             Name
                              (#Sum ## "lux.Form"
                               Code-List
                               (#Sum ## "lux.Tuple"
@@ -426,18 +426,18 @@
  [dummy-cursor (#Record #Nil)])
 
 ("lux def" symbol$
- ("lux check" (#Function Ident Code)
-  ([_ ident] (_ann (#Symbol ident))))
+ ("lux check" (#Function Name Code)
+  ([_ name] (_ann (#Symbol name))))
  [dummy-cursor (#Record #Nil)])
 
 ("lux def" local-symbol$
  ("lux check" (#Function Text Code)
-  ([_ ident] (_ann (#Symbol ["" ident]))))
+  ([_ name] (_ann (#Symbol ["" name]))))
  [dummy-cursor (#Record #Nil)])
 
 ("lux def" tag$
- ("lux check" (#Function Ident Code)
-  ([_ ident] (_ann (#Tag ident))))
+ ("lux check" (#Function Name Code)
+  ([_ name] (_ann (#Tag name))))
  [dummy-cursor (#Record #Nil)])
 
 ("lux def" form$
@@ -584,8 +584,8 @@
 ##    #module-aliases     (List [Text Text])
 ##    #definitions        (List [Text Definition])
 ##    #imports            (List Text)
-##    #tags               (List [Text [Nat (List Ident) Bit Type]])
-##    #types              (List [Text [(List Ident) Bit Type]])
+##    #tags               (List [Text [Nat (List Name) Bit Type]])
+##    #types              (List [Text [(List Name) Bit Type]])
 ##    #module-annotations (Maybe Code)
 ##    #module-state       Module-State})
 ("lux def" Module
@@ -601,13 +601,13 @@
              (#Product ## "lux.tags"
               (#Apply (#Product Text
                                 (#Product Nat
-                                          (#Product (#Apply Ident List)
+                                          (#Product (#Apply Name List)
                                                     (#Product Bit
                                                               Type))))
                       List)
               (#Product ## "lux.types"
                (#Apply (#Product Text
-                                 (#Product (#Apply Ident List)
+                                 (#Product (#Apply Name List)
                                            (#Product Bit
                                                      Type)))
                        List)
@@ -865,7 +865,7 @@
  (record$ #Nil))
 
 ("lux def" meta-code
- ("lux check" (#Function Ident (#Function Code Code))
+ ("lux check" (#Function Name (#Function Code Code))
   ([_ tag]
    ([_ value]
     (tuple$ (#Cons cursor-code
@@ -1770,17 +1770,17 @@
          (-> Text Text Text)
          ("lux text concat" x y))
 
-(def:''' (ident/encode ident)
+(def:''' (name/encode full-name)
          #Nil
-         (-> Ident Text)
-         (let' [[module name] ident]
+         (-> Name Text)
+         (let' [[module name] full-name]
                ({"" name
                  _  ($_ text/compose module "." name)}
                 module)))
 
 (def:''' (get-meta tag def-meta)
          #Nil
-         (-> Ident Code ($' Maybe Code))
+         (-> Name Code ($' Maybe Code))
          (let' [[prefix name] tag]
                ({[_ (#Record def-meta)]
                  ({(#Cons [key value] def-meta')
@@ -1805,10 +1805,10 @@
                  #None}
                 def-meta)))
 
-(def:''' (resolve-global-symbol ident state)
+(def:''' (resolve-global-symbol full-name state)
          #Nil
-         (-> Ident ($' Meta Ident))
-         (let' [[module name] ident
+         (-> Name ($' Meta Name))
+         (let' [[module name] full-name
                 {#info info #source    source  #current-module _ #modules modules
                  #scopes scopes #type-context types    #host    host
                  #seed seed #expected  expected #cursor  cursor #extensions extensions
@@ -1819,15 +1819,15 @@
                      (#Right [state real-name])
 
                      _
-                     (#Right [state ident])}
+                     (#Right [state full-name])}
                     (get-meta ["lux" "alias"] def-meta))
 
                    #None
-                   (#Left ($_ text/compose "Unknown definition: " (ident/encode ident)))}
+                   (#Left ($_ text/compose "Unknown definition: " (name/encode full-name)))}
                   (get name definitions))
                  
                  #None
-                 (#Left ($_ text/compose "Unknown module: " module " @ " (ident/encode ident)))}
+                 (#Left ($_ text/compose "Unknown module: " module " @ " (name/encode full-name)))}
                 (get module modules))))
 
 (def:''' (splice replace? untemplate elems)
@@ -2105,9 +2105,9 @@
            (-> (-> b c) (-> a b) (-> a c)))
          (function' [x] (f (g x))))
 
-(def:''' (get-ident x)
+(def:''' (get-name x)
          #Nil
-         (-> Code ($' Maybe Ident))
+         (-> Code ($' Maybe Name))
          ({[_ (#Symbol sname)]
            (#Some sname)
 
@@ -2117,7 +2117,7 @@
 
 (def:''' (get-tag x)
          #Nil
-         (-> Code ($' Maybe Ident))
+         (-> Code ($' Maybe Name))
          ({[_ (#Tag sname)]
            (#Some sname)
 
@@ -2125,7 +2125,7 @@
            #None}
           x))
 
-(def:''' (get-name x)
+(def:''' (get-short x)
          #Nil
          (-> Code ($' Maybe Text))
          ({[_ (#Symbol "" sname)]
@@ -2273,7 +2273,7 @@
 
              _
              (fail "Wrong syntax for do-template")}
-            [(monad/map Monad<Maybe> get-name bindings)
+            [(monad/map Monad<Maybe> get-short bindings)
              (monad/map Monad<Maybe> tuple->list data)])
 
            _
@@ -2642,24 +2642,24 @@
                   (get-meta ["lux" "macro?"] def-meta)))
            ))
 
-(def:''' (normalize ident)
+(def:''' (normalize name)
          #Nil
-         (-> Ident ($' Meta Ident))
+         (-> Name ($' Meta Name))
          ({["" name]
            (do Monad<Meta>
              [module-name current-module-name]
              (wrap [module-name name]))
 
            _
-           (return ident)}
-          ident))
+           (return name)}
+          name))
 
-(def:''' (find-macro ident)
+(def:''' (find-macro full-name)
          #Nil
-         (-> Ident ($' Meta ($' Maybe Macro)))
+         (-> Name ($' Meta ($' Maybe Macro)))
          (do Monad<Meta>
            [current-module current-module-name]
-           (let' [[module name] ident]
+           (let' [[module name] full-name]
                  (function' [state]
                             ({{#info info #source source #current-module _ #modules modules
                                #scopes   scopes   #type-context   types   #host host
@@ -2669,12 +2669,12 @@
                               (#Right state (find-macro' modules current-module module name))}
                              state)))))
 
-(def:''' (macro? ident)
+(def:''' (macro? name)
          #Nil
-         (-> Ident ($' Meta Bit))
+         (-> Name ($' Meta Bit))
          (do Monad<Meta>
-           [ident (normalize ident)
-            output (find-macro ident)]
+           [name (normalize name)
+            output (find-macro name)]
            (wrap ({(#Some _) #1
                    #None     #0}
                   output))))
@@ -3431,7 +3431,7 @@
          (list [(tag$ ["lux" "doc"])
                 (text$ "Macro-definition macro.
 
-                        (macro: #export (ident-for tokens)
+                        (macro: #export (name-for tokens)
                           (case tokens
                             (^template [<tag>]
                               (^ (list [_ (<tag> [prefix name])]))
@@ -3439,9 +3439,9 @@
                                             ([#Symbol] [#Tag])
 
                             _
-                            (fail \"Wrong syntax for ident-for\")))")])
+                            (fail \"Wrong syntax for name-for\")))")])
          (let [[exported? tokens] (export^ tokens)
-               name+args+meta+body?? (: (Maybe [Ident (List Code) Code Code])
+               name+args+meta+body?? (: (Maybe [Name (List Code) Code Code])
                                         (case tokens
                                           (^ (list [_ (#Form (list& [_ (#Symbol name)] args))] body))
                                           (#Some [name args (` {}) body])
@@ -3489,7 +3489,7 @@
             (: (-> a a Bit)
                >=))"}
   (let [[exported? tokens'] (export^ tokens)
-        ?parts (: (Maybe [Ident (List Code) Code (List Code)])
+        ?parts (: (Maybe [Name (List Code) Code (List Code)])
                   (case tokens'
                     (^ (list& [_ (#Form (list& [_ (#Symbol name)] args))] [meta-rec-cursor (#Record meta-rec-parts)] sigs))
                     (#Some name args [meta-rec-cursor (#Record meta-rec-parts)] sigs)
@@ -3791,7 +3791,7 @@
     (find-module module-name)))
 
 (def: (resolve-tag [module name])
-  (-> Ident (Meta [Nat (List Ident) Bit Type]))
+  (-> Name (Meta [Nat (List Name) Bit Type]))
   (do Monad<Meta>
     [=module (find-module module)
      #let [{#module-hash _ #module-aliases _ #definitions bindings #imports _ #tags tags-table #types types #module-annotations _ #module-state _} =module]]
@@ -3800,10 +3800,10 @@
       (return output)
 
       _
-      (fail (text/compose "Unknown tag: " (ident/encode [module name]))))))
+      (fail (text/compose "Unknown tag: " (name/encode [module name]))))))
 
 (def: (resolve-type-tags type)
-  (-> Type (Meta (Maybe [(List Ident) (List Type)])))
+  (-> Type (Meta (Maybe [(List Name) (List Type)])))
   (case type
     (#Apply arg func)
     (resolve-type-tags func)
@@ -3853,7 +3853,7 @@
     [tokens' (monad/map Monad<Meta> macro-expand tokens)
      struct-type get-expected-type
      tags+type (resolve-type-tags struct-type)
-     tags (: (Meta (List Ident))
+     tags (: (Meta (List Name))
              (case tags+type
                (#Some [tags _])
                (return tags)
@@ -4339,7 +4339,7 @@
           scopes)))
 
 (def: (find-def-type name state)
-  (-> Ident Lux (Maybe Type))
+  (-> Name Lux (Maybe Type))
   (let [[v-prefix v-name] name
         {#info info #source    source  #current-module _ #modules modules
          #scopes scopes #type-context types    #host    host
@@ -4358,7 +4358,7 @@
         (#Some def-type)))))
 
 (def: (find-def-value name state)
-  (-> Ident (Meta [Type Any]))
+  (-> Name (Meta [Type Any]))
   (let [[v-prefix v-name] name
         {#info info #source    source #current-module _  #modules modules
          #scopes scopes #type-context types    #host    host
@@ -4366,12 +4366,12 @@
          #scope-type-vars scope-type-vars} state]
     (case (get v-prefix modules)
       #None
-      (#Left (text/compose "Unknown definition: " (ident/encode name)))
+      (#Left (text/compose "Unknown definition: " (name/encode name)))
 
       (#Some {#definitions definitions #module-hash _ #module-aliases _ #imports _ #tags tags #types types #module-annotations _ #module-state _})
       (case (get v-name definitions)
         #None
-        (#Left (text/compose "Unknown definition: " (ident/encode name)))
+        (#Left (text/compose "Unknown definition: " (name/encode name)))
 
         (#Some [def-type def-meta def-value])
         (#Right [state [def-type def-value]])))))
@@ -4387,10 +4387,10 @@
       bound
       (find-type-var idx bindings'))))
 
-(def: (find-type ident)
-  (-> Ident (Meta Type))
+(def: (find-type full-name)
+  (-> Name (Meta Type))
   (do Monad<Meta>
-    [#let [[module name] ident]
+    [#let [[module name] full-name]
      current-module current-module-name]
     (function (_ compiler)
       (let [temp (if (text/= "" module)
@@ -4404,13 +4404,13 @@
                        (#Right [compiler struct-type])
 
                        _
-                       (#Left ($_ text/compose "Unknown var: " (ident/encode ident)))))
-                   (case (find-def-type ident compiler)
+                       (#Left ($_ text/compose "Unknown var: " (name/encode full-name)))))
+                   (case (find-def-type full-name compiler)
                      (#Some struct-type)
                      (#Right [compiler struct-type])
 
                      _
-                     (#Left ($_ text/compose "Unknown var: " (ident/encode ident)))))]
+                     (#Left ($_ text/compose "Unknown var: " (name/encode full-name)))))]
         (case temp
           (#Right [compiler (#Var type-id)])
           (let [{#info _ #source _ #current-module _ #modules _
@@ -4511,7 +4511,7 @@
 
         (#Some tags&members)
         (do Monad<Meta>
-          [full-body ((: (-> Ident [(List Ident) (List Type)] Code (Meta Code))
+          [full-body ((: (-> Name [(List Name) (List Type)] Code (Meta Code))
                          (function (recur source [tags members] target)
                            (let [pattern (record$ (list/map (function (_ [t-module t-name])
                                                               [(tag$ [t-module t-name])
@@ -4593,7 +4593,7 @@
        g!output (gensym "")]
       (case (resolve-struct-type type)
         (#Some members)
-        (let [pattern (record$ (list/map (: (-> [Ident [Nat Type]] [Code Code])
+        (let [pattern (record$ (list/map (: (-> [Name [Nat Type]] [Code Code])
                                             (function (_ [[r-prefix r-name] [r-idx r-type]])
                                               [(tag$ [r-prefix r-name])
                                                (if (n/= idx r-idx)
@@ -4622,7 +4622,7 @@
     (fail "Wrong syntax for get@")))
 
 (def: (open-field alias [module name] source type)
-  (-> Text Ident Code Type (Meta (List Code)))
+  (-> Text Name Code Type (Meta (List Code)))
   (do Monad<Meta>
     [output (resolve-type-tags type)
      #let [source+ (` (get@ (~ (tag$ [module name])) (~ source)))]]
@@ -4630,7 +4630,7 @@
       (#Some [tags members])
       (do Monad<Meta>
         [decls' (monad/map Monad<Meta>
-                           (: (-> [Ident Type] (Meta (List Code)))
+                           (: (-> [Name Type] (Meta (List Code)))
                               (function (_ [sname stype]) (open-field alias sname source+ stype)))
                            (zip2 tags members))]
         (return (list/join decls')))
@@ -4660,7 +4660,7 @@
         (case output
           (#Some [tags members])
           (do Monad<Meta>
-            [decls' (monad/map Monad<Meta> (: (-> [Ident Type] (Meta (List Code)))
+            [decls' (monad/map Monad<Meta> (: (-> [Name Type] (Meta (List Code)))
                                               (function (_ [sname stype])
                                                 (open-field alias sname source stype)))
                                (zip2 tags members))]
@@ -4829,26 +4829,20 @@
 
           ## Examples
           (.module: {#.doc \"Some documentation...\"}
-            lux
-            (lux (control (monad #as M #refer #all))
-                 (data (text #open (\"text/\" Monoid<Text>))
-                       (collection (list #open (\"list/\" Monad<List>)))
-                       maybe
-                       (ident #open (\"ident/\" Codec<Text,Ident>)))
-                 meta
-                 (macro code))
-            (// (type #open (\"\" Equivalence<Type>))))
-
-          (.module: {#.doc \"Some documentation...\"}
-            lux
-            (lux (control [\"M\" monad #*])
-                 (data [text \"text/\" Monoid<Text>]
-                       (collection [list \"list/\" Monad<List>])
-                       maybe
-                       [ident \"ident/\" Codec<Text,Ident>])
-                 meta
-                 (macro code))
-            (// [type \"\" Equivalence<Type>]))"}
+            [lux #*
+             [control
+              [\"M\" monad #*]]
+             [data
+              maybe
+              [\".\" name (\"name/.\" Codec<Text,Name>)]
+              [\".\" text (\"text/.\" Monoid<Text>)]
+              [collection
+               [list (\"list/.\" Monad<List>)]]]
+             meta
+             [macro
+              code]]
+            [//
+             [type (\".\" Equivalence<Type>)]])"}
   (do Monad<Meta>
     [#let [[_meta _imports] (: [(List [Code Code]) (List Code)]
                                (case tokens
@@ -4913,18 +4907,18 @@
         (#Some members)
         (do Monad<Meta>
           [pattern' (monad/map Monad<Meta>
-                               (: (-> [Ident [Nat Type]] (Meta [Ident Nat Code]))
+                               (: (-> [Name [Nat Type]] (Meta [Name Nat Code]))
                                   (function (_ [r-slot-name [r-idx r-type]])
                                     (do Monad<Meta>
                                       [g!slot (gensym "")]
                                       (return [r-slot-name r-idx g!slot]))))
                                (zip2 tags (enumerate members)))]
-          (let [pattern (record$ (list/map (: (-> [Ident Nat Code] [Code Code])
+          (let [pattern (record$ (list/map (: (-> [Name Nat Code] [Code Code])
                                               (function (_ [r-slot-name r-idx r-var])
                                                 [(tag$ r-slot-name)
                                                  r-var]))
                                            pattern'))
-                output (record$ (list/map (: (-> [Ident Nat Code] [Code Code])
+                output (record$ (list/map (: (-> [Name Nat Code] [Code Code])
                                              (function (_ [r-slot-name r-idx r-var])
                                                [(tag$ r-slot-name)
                                                 (if (n/= idx r-idx)
@@ -5003,18 +4997,18 @@
         (#Some members)
         (do Monad<Meta>
           [pattern' (monad/map Monad<Meta>
-                               (: (-> [Ident [Nat Type]] (Meta [Ident Nat Code]))
+                               (: (-> [Name [Nat Type]] (Meta [Name Nat Code]))
                                   (function (_ [r-slot-name [r-idx r-type]])
                                     (do Monad<Meta>
                                       [g!slot (gensym "")]
                                       (return [r-slot-name r-idx g!slot]))))
                                (zip2 tags (enumerate members)))]
-          (let [pattern (record$ (list/map (: (-> [Ident Nat Code] [Code Code])
+          (let [pattern (record$ (list/map (: (-> [Name Nat Code] [Code Code])
                                               (function (_ [r-slot-name r-idx r-var])
                                                 [(tag$ r-slot-name)
                                                  r-var]))
                                            pattern'))
-                output (record$ (list/map (: (-> [Ident Nat Code] [Code Code])
+                output (record$ (list/map (: (-> [Name Nat Code] [Code Code])
                                              (function (_ [r-slot-name r-idx r-var])
                                                [(tag$ r-slot-name)
                                                 (if (n/= idx r-idx)
@@ -5097,7 +5091,7 @@
               branches))
     (case (: (Maybe (List Code))
              (do Monad<Maybe>
-               [bindings' (monad/map Monad<Maybe> get-name bindings)
+               [bindings' (monad/map Monad<Maybe> get-short bindings)
                 data' (monad/map Monad<Maybe> tuple->list data)]
                (if (every? (n/= (list/size bindings')) (list/map list/size data'))
                  (let [apply (: (-> RepEnv (List Code))
@@ -5189,8 +5183,8 @@
   )
 
 (def: tag/encode
-  (-> Ident Text)
-  (|>> ident/encode (text/compose "#")))
+  (-> Name Text)
+  (|>> name/encode (text/compose "#")))
 
 (do-template [<name> <to>]
   [(def: #export <name>
@@ -5247,7 +5241,7 @@
      [#Int    int/encode]
      [#Frac   frac/encode]
      [#Text   text/encode]
-     [#Symbol ident/encode]
+     [#Symbol name/encode]
      [#Tag    tag/encode])
 
     (^template [<tag> <open> <close> <prep>]
@@ -5389,8 +5383,8 @@
             inits (list/map second pairs)]
         (if (every? symbol? inits)
           (do Monad<Meta>
-            [inits' (: (Meta (List Ident))
-                       (case (monad/map Monad<Maybe> get-ident inits)
+            [inits' (: (Meta (List Name))
+                       (case (monad/map Monad<Maybe> get-name inits)
                          (#Some inits') (return inits')
                          #None          (fail "Wrong syntax for loop")))
              init-types (monad/map Monad<Meta> find-type inits')
@@ -5420,8 +5414,8 @@
   (case tokens
     (^ (list& [_ (#Form (list [_ (#Tuple (list& hslot' tslots'))]))] body branches))
     (do Monad<Meta>
-      [slots (: (Meta [Ident (List Ident)])
-                (case (: (Maybe [Ident (List Ident)])
+      [slots (: (Meta [Name (List Name)])
+                (case (: (Maybe [Name (List Name)])
                          (do Monad<Maybe>
                            [hslot (get-tag hslot')
                             tslots (monad/map Monad<Maybe> get-tag tslots')]
@@ -5437,10 +5431,10 @@
        output (resolve-tag hslot)
        g!_ (gensym "_")
        #let [[idx tags exported? type] output
-             slot-pairings (list/map (: (-> Ident [Text Code])
+             slot-pairings (list/map (: (-> Name [Text Code])
                                         (function (_ [module name]) [name (symbol$ ["" name])]))
                                      (list& hslot tslots))
-             pattern (record$ (list/map (: (-> Ident [Code Code])
+             pattern (record$ (list/map (: (-> Name [Code Code])
                                            (function (_ [module name])
                                              (let [tag (tag$ [module name])]
                                                (case (get name slot-pairings)
@@ -5559,7 +5553,7 @@
     type))
 
 (def: (anti-quote-def name)
-  (-> Ident (Meta Code))
+  (-> Name (Meta Code))
   (do Monad<Meta>
     [type+value (find-def-value name)
      #let [[type value] type+value]]
@@ -5575,7 +5569,7 @@
        ["Text" Text text$])
       
       _
-      (fail (text/compose "Cannot anti-quote type: " (ident/encode name))))))
+      (fail (text/compose "Cannot anti-quote type: " (name/encode name))))))
 
 (def: (anti-quote token)
   (-> Code (Meta Code))
@@ -5698,9 +5692,9 @@
     _
     (fail "Wrong syntax for ^multi")))
 
-(macro: #export (ident-for tokens)
+(macro: #export (name-for tokens)
   {#.doc (doc "Given a symbol or a tag, gives back a 2 tuple with the prefix and name parts, both as Text."
-              (ident-for #.doc)
+              (name-for #.doc)
               "=>"
               ["lux" "doc"])}
   (case tokens
@@ -5710,7 +5704,7 @@
     ([#Symbol] [#Tag])
     
     _
-    (fail "Wrong syntax for ident-for")))
+    (fail "Wrong syntax for name-for")))
 
 (do-template [<type> <even> <odd> <%> <=> <0> <2>]
   [(def: #export (<even> n)
@@ -6069,8 +6063,8 @@
     (fail "Wrong syntax for ``")
     ))
 
-(def: (ident$ [module name])
-  (-> Ident Code)
+(def: (name$ [module name])
+  (-> Name Code)
   (` [(~ (text$ module)) (~ (text$ name))]))
 
 (def: (untemplate-list& last inits)
@@ -6090,14 +6084,14 @@
       (do Monad<Meta>
         [g!meta (gensym "g!meta")]
         (wrap (` [(~ g!meta) (<tag> (~ (<gen> value)))]))))
-    ([#Bit "Bit" bit$]
-     [#Nat "Nat" nat$]
-     [#Int "Int" int$]
-     [#Rev "Rev" rev$]
-     [#Frac "Frac" frac$]
-     [#Text "Text" text$]
-     [#Tag "Tag" ident$]
-     [#Symbol "Symbol" ident$])
+    ([#Bit    "Bit"    bit$]
+     [#Nat    "Nat"    nat$]
+     [#Int    "Int"    int$]
+     [#Rev    "Rev"    rev$]
+     [#Frac   "Frac"   frac$]
+     [#Text   "Text"   text$]
+     [#Tag    "Tag"    name$]
+     [#Symbol "Symbol" name$])
 
     [_ (#Record fields)]
     (do Monad<Meta>
diff --git a/stdlib/source/lux/compiler/default/name.lux b/stdlib/source/lux/compiler/default/name.lux
index f6489b89c..50240a801 100644
--- a/stdlib/source/lux/compiler/default/name.lux
+++ b/stdlib/source/lux/compiler/default/name.lux
@@ -43,6 +43,6 @@
                (|> (text.nth idx name) maybe.assume sanitize (format output)))
         output))))
 
-(def: #export (definition [module name])
-  (-> Ident Text)
-  (format (normalize module) "___" (normalize name)))
+(def: #export (definition [module short])
+  (-> Name Text)
+  (format (normalize module) "___" (normalize short)))
diff --git a/stdlib/source/lux/compiler/default/phase/analysis/module.lux b/stdlib/source/lux/compiler/default/phase/analysis/module.lux
index adc442c1f..61d3a2ec6 100644
--- a/stdlib/source/lux/compiler/default/phase/analysis/module.lux
+++ b/stdlib/source/lux/compiler/default/phase/analysis/module.lux
@@ -35,8 +35,8 @@
   [cannot-declare-tags-for-foreign-type]
   )
 
-(exception: #export (cannot-define-more-than-once {name Ident})
-  (%ident name))
+(exception: #export (cannot-define-more-than-once {name Name})
+  (%name name))
 
 (exception: #export (can-only-change-state-of-active-module {module Text} {state Module-State})
   (ex.report ["Module" module]
@@ -203,8 +203,8 @@
           #.None
           ((///.throw unknown-module module-name) state)))))]
 
-  [tags  #.tags        (List [Text [Nat (List Ident) Bit Type]])]
-  [types #.types       (List [Text [(List Ident) Bit Type]])]
+  [tags  #.tags        (List [Text [Nat (List Name) Bit Type]])]
+  [types #.types       (List [Text [(List Name) Bit Type]])]
   [hash  #.module-hash Nat]
   )
 
@@ -228,8 +228,8 @@
   (do ///.Monad<Operation>
     [self-name (extension.lift macro.current-module-name)
      [type-module type-name] (case type
-                               (#.Named type-ident _)
-                               (wrap type-ident)
+                               (#.Named type-name _)
+                               (wrap type-name)
 
                                _
                                (///.throw cannot-declare-tags-for-unnamed-type [tags type]))
diff --git a/stdlib/source/lux/compiler/default/phase/analysis/reference.lux b/stdlib/source/lux/compiler/default/phase/analysis/reference.lux
index bb78a32fb..0647dd391 100644
--- a/stdlib/source/lux/compiler/default/phase/analysis/reference.lux
+++ b/stdlib/source/lux/compiler/default/phase/analysis/reference.lux
@@ -19,16 +19,16 @@
   (ex.report ["Current" current]
              ["Foreign" foreign]))
 
-(exception: #export (definition-has-not-been-expored {definition Ident})
-  (ex.report ["Definition" (%ident definition)]))
+(exception: #export (definition-has-not-been-expored {definition Name})
+  (ex.report ["Definition" (%name definition)]))
 
 ## [Analysers]
 (def: (definition def-name)
-  (-> Ident (Operation Analysis))
+  (-> Name (Operation Analysis))
   (with-expansions [<return> (wrap (|> def-name reference.constant #//.Reference))]
     (do ///.Monad<Operation>
       [[actualT def-anns _] (extension.lift (macro.find-def def-name))]
-      (case (macro.get-symbol-ann (ident-for #.alias) def-anns)
+      (case (macro.get-symbol-ann (name-for #.alias) def-anns)
         (#.Some real-def-name)
         (definition real-def-name)
 
@@ -61,7 +61,7 @@
       (wrap #.None))))
 
 (def: #export (reference reference)
-  (-> Ident (Operation Analysis))
+  (-> Name (Operation Analysis))
   (case reference
     ["" simple-name]
     (do ///.Monad<Operation>
diff --git a/stdlib/source/lux/compiler/default/phase/analysis/structure.lux b/stdlib/source/lux/compiler/default/phase/analysis/structure.lux
index c50383eb8..e4d6159fc 100644
--- a/stdlib/source/lux/compiler/default/phase/analysis/structure.lux
+++ b/stdlib/source/lux/compiler/default/phase/analysis/structure.lux
@@ -4,7 +4,7 @@
     ["." monad (#+ do)]
     ["ex" exception (#+ exception:)]]
    [data
-    ["." ident]
+    ["." name]
     ["." number]
     ["." product]
     ["." maybe]
@@ -57,7 +57,7 @@
              ["Record" (%code (code.record record))]))
 
 (do-template [<name>]
-  [(exception: #export (<name> {key Ident} {record (List [Ident Code])})
+  [(exception: #export (<name> {key Name} {record (List [Name Code])})
      (ex.report ["Tag" (%code (code.tag key))]
                 ["Record" (%code (code.record (list/map (function (_ [keyI valC])
                                                           [(code.tag keyI) valC])
@@ -66,11 +66,11 @@
   [cannot-repeat-tag]
   )
 
-(exception: #export (tag-does-not-belong-to-record {key Ident} {type Type})
+(exception: #export (tag-does-not-belong-to-record {key Name} {type Type})
   (ex.report ["Tag" (%code (code.tag key))]
              ["Type" (%type type)]))
 
-(exception: #export (record-size-mismatch {expected Nat} {actual Nat} {type Type} {record (List [Ident Code])})
+(exception: #export (record-size-mismatch {expected Nat} {actual Nat} {type Type} {record (List [Name Code])})
   (ex.report ["Expected" (|> expected .int %i)]
              ["Actual" (|> actual .int %i)]
              ["Type" (%type type)]
@@ -259,7 +259,7 @@
         ))))
 
 (def: #export (tagged-sum analyse tag valueC)
-  (-> Phase Ident Code (Operation Analysis))
+  (-> Phase Name Code (Operation Analysis))
   (do ///.Monad<Operation>
     [tag (extension.lift (macro.normalize tag))
      [idx group variantT] (extension.lift (macro.resolve-tag tag))
@@ -280,7 +280,7 @@
 ## Normalization just means that all the tags get resolved to their
 ## canonical form (with their corresponding module identified).
 (def: #export (normalize record)
-  (-> (List [Code Code]) (Operation (List [Ident Code])))
+  (-> (List [Code Code]) (Operation (List [Name Code])))
   (monad.map ///.Monad<Operation>
              (function (_ [key val])
                (case key
@@ -297,7 +297,7 @@
 ## re-implementing the same functionality for records makes no sense.
 ## Records, thus, get transformed into tuples by ordering the elements.
 (def: #export (order record)
-  (-> (List [Ident Code]) (Operation [(List Code) Type]))
+  (-> (List [Name Code]) (Operation [(List Code) Type]))
   (case record
     ## empty-record = empty-tuple = unit = []
     #.Nil
@@ -313,7 +313,7 @@
            (wrap [])
            (///.throw record-size-mismatch [size-ts size-record recordT record]))
        #let [tuple-range (list.n/range +0 (dec size-ts))
-             tag->idx (dict.from-list ident.Hash<Ident> (list.zip2 tag-set tuple-range))]
+             tag->idx (dict.from-list name.Hash<Name> (list.zip2 tag-set tuple-range))]
        idx->val (monad.fold @
                             (function (_ [key val] idx->val)
                               (do @
diff --git a/stdlib/source/lux/compiler/default/phase/translation.lux b/stdlib/source/lux/compiler/default/phase/translation.lux
index 82e31320a..f9b5dfbb4 100644
--- a/stdlib/source/lux/compiler/default/phase/translation.lux
+++ b/stdlib/source/lux/compiler/default/phase/translation.lux
@@ -6,7 +6,7 @@
    [data
     ["." product]
     ["." error (#+ Error)]
-    [ident ("ident/." Equivalence<Ident> Codec<Text,Ident>)]
+    [name ("name/." Equivalence<Name> Codec<Text,Name>)]
     ["." text
      format]
     [collection
@@ -30,8 +30,8 @@
   message)
 
 (do-template [<name>]
-  [(exception: #export (<name> {name Ident})
-     (ex.report ["Artifact" (ident/encode name)]))]
+  [(exception: #export (<name> {name Name})
+     (ex.report ["Artifact" (name/encode name)]))]
 
   [cannot-overwrite-artifact]
   [no-buffer-for-saving-code]
@@ -47,7 +47,7 @@
   (: (-> statement (Error Any))
      execute!))
 
-(type: #export (Buffer statement) (Row [Ident statement]))
+(type: #export (Buffer statement) (Row [Name statement]))
 
 (type: #export (Artifacts statement) (Dictionary File (Buffer statement)))
 
@@ -175,13 +175,13 @@
 
 (def: #export (save! name code)
   (All [anchor expression statement]
-    (-> Ident statement (Operation anchor expression statement Any)))
+    (-> Name statement (Operation anchor expression statement Any)))
   (do //.Monad<Operation>
     [_ (execute! code)
      ?buffer (extension.read (get@ #buffer))]
     (case ?buffer
       (#.Some buffer)
-      (if (row.any? (|>> product.left (ident/= name)) buffer)
+      (if (row.any? (|>> product.left (name/= name)) buffer)
         (//.throw cannot-overwrite-artifact name)
         (extension.update (set@ #buffer (#.Some (row.add [name code] buffer)))))
       
diff --git a/stdlib/source/lux/compiler/default/phase/translation/scheme/reference.jvm.lux b/stdlib/source/lux/compiler/default/phase/translation/scheme/reference.jvm.lux
index 3fca5842f..240513fbc 100644
--- a/stdlib/source/lux/compiler/default/phase/translation/scheme/reference.jvm.lux
+++ b/stdlib/source/lux/compiler/default/phase/translation/scheme/reference.jvm.lux
@@ -40,11 +40,11 @@
        operation/wrap))
 
 (def: #export constant'
-  (-> Ident Var)
+  (-> Name Var)
   (|>> name.definition _.var))
 
 (def: #export constant
-  (-> Ident (Operation Var))
+  (-> Name (Operation Var))
   (|>> constant' operation/wrap))
 
 (def: #export reference'
diff --git a/stdlib/source/lux/compiler/default/reference.lux b/stdlib/source/lux/compiler/default/reference.lux
index 84b838b3d..086c72810 100644
--- a/stdlib/source/lux/compiler/default/reference.lux
+++ b/stdlib/source/lux/compiler/default/reference.lux
@@ -13,7 +13,7 @@
 
 (type: #export Reference
   (#Variable Variable)
-  (#Constant Ident))
+  (#Constant Name))
 
 (structure: #export _ (Equivalence Variable)
   (def: (= reference sample)
diff --git a/stdlib/source/lux/compiler/default/repl/type.lux b/stdlib/source/lux/compiler/default/repl/type.lux
index 2af590c4b..4a1cdbe57 100644
--- a/stdlib/source/lux/compiler/default/repl/type.lux
+++ b/stdlib/source/lux/compiler/default/repl/type.lux
@@ -80,7 +80,7 @@
                               (format "(#.Some " (elemR elemV) ")"))))))))
 
 (def: (record-representation tags representation)
-  (-> (List Ident) (Poly Representation) (Poly Representation))
+  (-> (List Name) (Poly Representation) (Poly Representation))
   (do p.Monad<Parser>
     [membersR+ (poly.tuple (p.many representation))
      _ (p.assert "Number of tags does not match record type size."
@@ -102,7 +102,7 @@
               (format "{" record-body "}"))))))
 
 (def: (variant-representation tags representation)
-  (-> (List Ident) (Poly Representation) (Poly Representation))
+  (-> (List Name) (Poly Representation) (Poly Representation))
   (do p.Monad<Parser>
     [casesR+ (poly.variant (p.many representation))
      #let [num-tags (list.size tags)]
diff --git a/stdlib/source/lux/compiler/default/syntax.lux b/stdlib/source/lux/compiler/default/syntax.lux
index 41c11ee2d..1378e37c0 100644
--- a/stdlib/source/lux/compiler/default/syntax.lux
+++ b/stdlib/source/lux/compiler/default/syntax.lux
@@ -482,18 +482,18 @@
     (wrap [where'
            [where (#.Record elems)]])))
 
-## The parts of an identifier are separated by a single mark.
-## E.g. module.name.
-## Only one such mark may be used in an identifier, since there
-## can only be 2 parts to an identifier (the module [before the
-## mark], and the name [after the mark]).
-## There are also some extra rules regarding identifier syntax,
+## The parts of an name are separated by a single mark.
+## E.g. module.short.
+## Only one such mark may be used in an name, since there
+## can only be 2 parts to an name (the module [before the
+## mark], and the short [after the mark]).
+## There are also some extra rules regarding name syntax,
 ## encoded on the parser.
-(def: identifier-separator Text ".")
+(def: name-separator Text ".")
 
-## A Lux identifier is a pair of chunks of text, where the first-part
-## refers to the module that gives context to the identifier, and the
-## second part corresponds to the name of the identifier itself.
+## A Lux name is a pair of chunks of text, where the first-part
+## refers to the module that gives context to the name, and the
+## second part corresponds to the short of the name itself.
 ## The module part may be absent (by being the empty text ""), but the
 ## name part must always be present.
 ## The rules for which characters you may use are specified in terms
@@ -502,13 +502,13 @@
 ## In particular, no white-space can be used, and neither can other
 ## characters which are already used by Lux as delimiters for other
 ## Code nodes (thereby reducing ambiguity while parsing).
-## Additionally, the first character in an identifier's part cannot be
+## Additionally, the first character in an name's part cannot be
 ## a digit, to avoid confusion with regards to numbers.
-(def: ident-part^
+(def: name-part^
   (l.Lexer Text)
   (do p.Monad<Parser>
     [#let [digits "0123456789"
-           delimiters (format "()[]{}#\"" identifier-separator)
+           delimiters (format "()[]{}#\"" name-separator)
            space (format white-space new-line)
            head-lexer (l.none-of (format digits delimiters space))
            tail-lexer (l.some (l.none-of (format delimiters space)))]
@@ -516,45 +516,45 @@
      tail tail-lexer]
     (wrap (format head tail))))
 
-(def: current-module-mark Text (format identifier-separator identifier-separator))
+(def: current-module-mark Text (format name-separator name-separator))
 
-(def: (ident^ current-module aliases)
-  (-> Text Aliases (l.Lexer [Ident Nat]))
+(def: (name^ current-module aliases)
+  (-> Text Aliases (l.Lexer [Name Nat]))
   ($_ p.either
-      ## When an identifier starts with 2 marks, its module is
+      ## When an name starts with 2 marks, its module is
       ## taken to be the current-module being compiled at the moment.
-      ## This can be useful when mentioning identifiers and tags
+      ## This can be useful when mentioning names and tags
       ## inside quoted/templated code in macros.
       (do p.Monad<Parser>
         [_ (l.this current-module-mark)
-         def-name ident-part^]
+         def-name name-part^]
         (wrap [[current-module def-name]
                (n/+ +2 (text.size def-name))]))
-      ## If the identifier is prefixed by the mark, but no module
+      ## If the name is prefixed by the mark, but no module
       ## part, the module is assumed to be "lux" (otherwise known as
       ## the 'prelude').
       ## This makes it easy to refer to definitions in that module,
       ## since it is the most fundamental module in the entire
       ## standard library.
       (do p.Monad<Parser>
-        [_ (l.this identifier-separator)
-         def-name ident-part^]
+        [_ (l.this name-separator)
+         def-name name-part^]
         (wrap [["lux" def-name]
                (inc (text.size def-name))]))
-      ## Not all identifiers must be specified with a module part.
-      ## If that part is not provided, the identifier will be created
+      ## Not all names must be specified with a module part.
+      ## If that part is not provided, the name will be created
       ## with the empty "" text as the module.
-      ## During program analysis, such identifiers tend to be treated
+      ## During program analysis, such names tend to be treated
       ## as if their context is the current-module, but this only
-      ## applies to identifiers for tags and module definitions.
+      ## applies to names for tags and module definitions.
       ## Function arguments and local-variables may not be referred-to
-      ## using identifiers with module parts, so being able to specify
-      ## identifiers with empty modules helps with those use-cases.
+      ## using names with module parts, so being able to specify
+      ## names with empty modules helps with those use-cases.
       (do p.Monad<Parser>
-        [first-part ident-part^]
+        [first-part name-part^]
         (p.either (do @
-                    [_ (l.this identifier-separator)
-                     second-part ident-part^]
+                    [_ (l.this name-separator)
+                     second-part name-part^]
                     (wrap [[(|> aliases (dict.get first-part) (maybe.default first-part))
                             second-part]
                            ($_ n/+
@@ -568,14 +568,14 @@
   (-> Text Aliases Cursor (l.Lexer [Cursor Code]))
   (do p.Monad<Parser>
     [[value length] (p.after (l.this "#")
-                             (ident^ current-module aliases))]
+                             (name^ current-module aliases))]
     (wrap [(update@ #.column (|>> ($_ n/+ +1 length)) where)
            [where (#.Tag value)]])))
 
 (def: #export (symbol current-module aliases where)
   (-> Text Aliases Cursor (l.Lexer [Cursor Code]))
   (do p.Monad<Parser>
-    [[value length] (ident^ current-module aliases)]
+    [[value length] (name^ current-module aliases)]
     (wrap [(update@ #.column (|>> (n/+ length)) where)
            [where (case value
                     (^template [<name> <value>]
diff --git a/stdlib/source/lux/compiler/meta/archive.lux b/stdlib/source/lux/compiler/meta/archive.lux
index ee31e65d9..47572fe04 100644
--- a/stdlib/source/lux/compiler/meta/archive.lux
+++ b/stdlib/source/lux/compiler/meta/archive.lux
@@ -6,7 +6,7 @@
     ["." monad (#+ do)]]
    [data
     ["." error (#+ Error)]
-    ["." ident]
+    ["." name]
     ["." text
      format]
     [collection
@@ -20,16 +20,16 @@
 
 ## Key
 (type: #export Signature
-  {#name Ident
+  {#name Name
    #version Version})
 
 (def: Equivalence<Signature>
   (Equivalence Signature)
-  (equivalence.product ident.Equivalence<Ident> text.Equivalence<Text>))
+  (equivalence.product name.Equivalence<Name> text.Equivalence<Text>))
 
 (def: (describe signature)
   (-> Signature Text)
-  (format (%ident (get@ #name signature)) " " (get@ #version signature)))
+  (format (%name (get@ #name signature)) " " (get@ #version signature)))
 
 (abstract: #export (Key k)
   {}
diff --git a/stdlib/source/lux/compiler/meta/cache.lux b/stdlib/source/lux/compiler/meta/cache.lux
index eb702c0da..fe9a32266 100644
--- a/stdlib/source/lux/compiler/meta/cache.lux
+++ b/stdlib/source/lux/compiler/meta/cache.lux
@@ -99,7 +99,7 @@
 ## Load
 (def: signature
   (Format Signature)
-  ($_ binary.seq binary.ident binary.text))
+  ($_ binary.seq binary.name binary.text))
 
 (def: descriptor
   (Format Descriptor)
diff --git a/stdlib/source/lux/concurrency/actor.lux b/stdlib/source/lux/concurrency/actor.lux
index 52bf7621d..b9b1a22c2 100644
--- a/stdlib/source/lux/concurrency/actor.lux
+++ b/stdlib/source/lux/concurrency/actor.lux
@@ -150,15 +150,15 @@
 ## [Syntax]
 (do-template [<with> <resolve> <tag> <desc>]
   [(def: #export (<with> name)
-     (-> Ident cs.Annotations cs.Annotations)
-     (|>> (#.Cons [(ident-for <tag>)
+     (-> Name cs.Annotations cs.Annotations)
+     (|>> (#.Cons [(name-for <tag>)
                    (code.tag name)])))
    
    (def: #export (<resolve> name)
-     (-> Ident (Meta Ident))
+     (-> Name (Meta Name))
      (do Monad<Meta>
        [[_ annotations _] (macro.find-def name)]
-       (case (macro.get-tag-ann (ident-for <tag>) annotations)
+       (case (macro.get-tag-ann (name-for <tag>) annotations)
          (#.Some actor-name)
          (wrap actor-name)
 
@@ -293,7 +293,7 @@
               s.any)))
 
 (def: reference^
-  (s.Syntax [Ident (List Text)])
+  (s.Syntax [Name (List Text)])
   (p.either (s.form (p.seq s.symbol (p.some s.local-symbol)))
             (p.seq s.symbol (:: p.Monad<Parser> wrap (list)))))
 
@@ -373,7 +373,7 @@
                                                         (~ g!self))]
                                    (if (~ g!sent?)
                                      ((~' wrap) (~ g!task))
-                                     ((~' wrap) (task.throw ..dead [(~ (code.text (%ident actor-name)))
-                                                                    (~ (code.text (%ident message-name)))]))))))))
+                                     ((~' wrap) (task.throw ..dead [(~ (code.text (%name actor-name)))
+                                                                    (~ (code.text (%name message-name)))]))))))))
                   ))
       )))
diff --git a/stdlib/source/lux/data/format/binary.lux b/stdlib/source/lux/data/format/binary.lux
index 27a510b44..add376a44 100644
--- a/stdlib/source/lux/data/format/binary.lux
+++ b/stdlib/source/lux/data/format/binary.lux
@@ -219,8 +219,8 @@
      (..alt ..any
             (..seq value recur)))))
 
-(def: #export ident
-  (Format Ident)
+(def: #export name
+  (Format Name)
   (..seq ..text ..text))
 
 (def: #export type
@@ -252,7 +252,7 @@
            ## #Apply
            pair
            ## #Named
-           (..seq ..ident type)
+           (..seq ..name type)
            )))))
 
 (def: #export cursor
@@ -278,9 +278,9 @@
                      ## #Text
                      ..text
                      ## #Symbol
-                     ..ident
+                     ..name
                      ## #Tag
-                     ..ident
+                     ..name
                      ## #Form
                      sequence
                      ## #Tuple
diff --git a/stdlib/source/lux/data/format/xml.lux b/stdlib/source/lux/data/format/xml.lux
index 5e92de080..a990e6901 100644
--- a/stdlib/source/lux/data/format/xml.lux
+++ b/stdlib/source/lux/data/format/xml.lux
@@ -10,17 +10,17 @@
     ["." number]
     ["E" error]
     ["." product]
-    ["." ident ("ident/." Equivalence<Ident> Codec<Text,Ident>)]
+    ["." name ("name/." Equivalence<Name> Codec<Text,Name>)]
     ["." text ("text/." Equivalence<Text> Monoid<Text>)
      ["l" lexer]]
     [collection
      ["." list ("list/." Monad<List>)]
      ["d" dictionary]]]])
 
-(type: #export Tag Ident)
-(type: #export Attrs (d.Dictionary Ident Text))
+(type: #export Tag Name)
+(type: #export Attrs (d.Dictionary Name Text))
 
-(def: #export attrs Attrs (d.new ident.Hash<Ident>))
+(def: #export attrs Attrs (d.new name.Hash<Name>))
 
 (type: #export #rec XML
   (#Text Text)
@@ -69,7 +69,7 @@
     (wrap ($_ text/compose head tail))))
 
 (def: namespaced-symbol^
-  (l.Lexer Ident)
+  (l.Lexer Name)
   (do p.Monad<Parser>
     [first-part xml-identifier
      ?second-part (<| p.maybe (p.after (l.this ":")) xml-identifier)]
@@ -97,7 +97,7 @@
 
 (def: attrs^
   (l.Lexer Attrs)
-  (<| (:: p.Monad<Parser> map (d.from-list ident.Hash<Ident>))
+  (<| (:: p.Monad<Parser> map (d.from-list name.Hash<Name>))
       p.some
       (p.seq (spaced^ attr-name^))
       (p.after (l.this "="))
@@ -111,9 +111,9 @@
                 (p.after (l.this "/"))
                 (l.enclosed ["<" ">"]))]
     (p.assert ($_ text/compose "Close tag does not match open tag.\n"
-                  "Expected: " (ident/encode expected) "\n"
-                  "  Actual: " (ident/encode actual) "\n")
-              (ident/= expected actual))))
+                  "Expected: " (name/encode expected) "\n"
+                  "  Actual: " (name/encode actual) "\n")
+              (name/= expected actual))))
 
 (def: comment^
   (l.Lexer Text)
@@ -234,7 +234,7 @@
 
       [(#Node reference/tag reference/attrs reference/children)
        (#Node sample/tag sample/attrs sample/children)]
-      (and (ident/= reference/tag sample/tag)
+      (and (name/= reference/tag sample/tag)
            (:: (d.Equivalence<Dictionary> text.Equivalence<Text>) = reference/attrs sample/attrs)
            (n/= (list.size reference/children)
                 (list.size sample/children))
@@ -251,8 +251,8 @@
 (exception: #export unexpected-input)
 (exception: #export unknown-attribute)
 
-(exception: #export (wrong-tag {tag Ident})
-  (ident/encode tag))
+(exception: #export (wrong-tag {tag Name})
+  (name/encode tag))
 
 (exception: #export (unconsumed-inputs {inputs (List XML)})
   (|> inputs
@@ -275,7 +275,7 @@
         (ex.throw unexpected-input [])))))
 
 (def: #export (attr name)
-  (-> Ident (Reader Text))
+  (-> Name (Reader Text))
   (function (_ docs)
     (case docs
       #.Nil
@@ -306,7 +306,7 @@
     (#E.Error error)))
 
 (def: #export (node tag)
-  (-> Ident (Reader Any))
+  (-> Name (Reader Any))
   (function (_ docs)
     (case docs
       #.Nil
@@ -318,7 +318,7 @@
         (ex.throw unexpected-input [])
         
         (#Node _tag _attrs _children)
-        (if (ident/= tag _tag)
+        (if (name/= tag _tag)
           (#E.Success [docs []])
           (ex.throw wrong-tag tag))))))
 
diff --git a/stdlib/source/lux/data/ident.lux b/stdlib/source/lux/data/name.lux
index 27d45227f..0129bc5cc 100644
--- a/stdlib/source/lux/data/ident.lux
+++ b/stdlib/source/lux/data/name.lux
@@ -8,46 +8,46 @@
     ["." text ("text/." Monoid<Text> Hash<Text>)]]])
 
 ## [Types]
-## (type: Ident
+## (type: Name
 ##   [Text Text])
 
 ## [Functions]
 (do-template [<name> <side>]
-  [(def: #export (<name> [module name])
-     (-> Ident Text)
+  [(def: #export (<name> [module short])
+     (-> Name Text)
      <side>)]
 
   [module module]
-  [name   name]
+  [short  short]
   )
 
 ## [Structures]
-(structure: #export _ (Equivalence Ident)
+(structure: #export _ (Equivalence Name)
   (def: (= [xmodule xname] [ymodule yname])
     (and (text/= xmodule ymodule)
          (text/= xname yname))))
 
-(structure: #export _ (Codec Text Ident)
-  (def: (encode [module name])
+(structure: #export _ (Codec Text Name)
+  (def: (encode [module short])
     (case module
-      "" name
-      _ ($_ text/compose module "." name)))
+      "" short
+      _ ($_ text/compose module "." short)))
   
   (def: (decode input)
     (if (text/= "" input)
-      (#.Left (text/compose "Invalid format for Ident: " input))
+      (#.Left (text/compose "Invalid format for Name: " input))
       (case (text.split-all-with "." input)
-        (^ (list name))
-        (#.Right ["" name])
+        (^ (list short))
+        (#.Right ["" short])
 
-        (^ (list module name))
-        (#.Right [module name])
+        (^ (list module short))
+        (#.Right [module short])
 
         _
-        (#.Left (text/compose "Invalid format for Ident: " input))))))
+        (#.Left (text/compose "Invalid format for Name: " input))))))
 
-(structure: #export _ (Hash Ident)
-  (def: eq Equivalence<Ident>)
+(structure: #export _ (Hash Name)
+  (def: eq Equivalence<Name>)
   
   (def: (hash [module name])
     (n/+ (text/hash module) (text/hash name))))
diff --git a/stdlib/source/lux/data/text/format.lux b/stdlib/source/lux/data/text/format.lux
index 7592b7b28..7f4188154 100644
--- a/stdlib/source/lux/data/text/format.lux
+++ b/stdlib/source/lux/data/text/format.lux
@@ -5,7 +5,7 @@
     ["p" parser]]
    [data
     ["." bit]
-    ["." ident]
+    ["." name]
     ["." number]
     ["." text]
     [format
@@ -46,7 +46,7 @@
   [%r        Rev               (:: number.Codec<Text,Rev> encode)]
   [%f        Frac              (:: number.Codec<Text,Frac> encode)]
   [%t        Text              text.encode]
-  [%ident    Ident             (:: ident.Codec<Text,Ident> encode)]
+  [%name     Name              (:: name.Codec<Text,Name> encode)]
   [%code     Code              code.to-text]
   [%type     Type              type.to-text]
   [%bin      Nat               (:: number.Binary@Codec<Text,Nat> encode)]
diff --git a/stdlib/source/lux/data/text/regex.lux b/stdlib/source/lux/data/text/regex.lux
index 34505d157..158eea153 100644
--- a/stdlib/source/lux/data/text/regex.lux
+++ b/stdlib/source/lux/data/text/regex.lux
@@ -52,31 +52,31 @@
     [parts part^]
     (wrap (text.join-with "" parts))))
 
-(def: identifier-char^
+(def: name-char^
   (l.Lexer Text)
   (l.none-of "[]{}()s\"#.<>"))
 
-(def: identifier-part^
+(def: name-part^
   (l.Lexer Text)
   (do p.Monad<Parser>
     [head (refine^ (l.not l.decimal)
-                   identifier-char^)
-     tail (l.some identifier-char^)]
+                   name-char^)
+     tail (l.some name-char^)]
     (wrap (format head tail))))
 
-(def: (identifier^ current-module)
-  (-> Text (l.Lexer Ident))
+(def: (name^ current-module)
+  (-> Text (l.Lexer Name))
   ($_ p.either
-      (p.seq (parser/wrap current-module) (p.after (l.this "..") identifier-part^))
-      (p.seq identifier-part^ (p.after (l.this ".") identifier-part^))
-      (p.seq (parser/wrap "lux") (p.after (l.this ".") identifier-part^))
-      (p.seq (parser/wrap "") identifier-part^)))
+      (p.seq (parser/wrap current-module) (p.after (l.this "..") name-part^))
+      (p.seq name-part^ (p.after (l.this ".") name-part^))
+      (p.seq (parser/wrap "lux") (p.after (l.this ".") name-part^))
+      (p.seq (parser/wrap "") name-part^)))
 
 (def: (re-var^ current-module)
   (-> Text (l.Lexer Code))
   (do p.Monad<Parser>
-    [ident (l.enclosed ["\\@<" ">"] (identifier^ current-module))]
-    (wrap (` (: (l.Lexer Text) (~ (code.symbol ident)))))))
+    [name (l.enclosed ["\\@<" ">"] (name^ current-module))]
+    (wrap (` (: (l.Lexer Text) (~ (code.symbol name)))))))
 
 (def: re-range^
   (l.Lexer Code)
@@ -194,7 +194,7 @@
               (wrap (` ((~! ..copy) (~ (code.symbol ["" (int/encode (.int id))]))))))
             (do p.Monad<Parser>
               [_ (l.this "\\k<")
-               captured-name identifier-part^
+               captured-name name-part^
                _ (l.this ">")]
               (wrap (` ((~! ..copy) (~ (code.symbol ["" captured-name]))))))))
 
@@ -384,7 +384,7 @@
         (wrap [#Non-Capturing complex]))
       (do p.Monad<Parser>
         [_ (l.this "(?<")
-         captured-name identifier-part^
+         captured-name name-part^
          _ (l.this ">")
          [num-captures pattern] (re-alternative^ #1 re-scoped^ current-module)
          _ (l.this ")")]
diff --git a/stdlib/source/lux/host.jvm.lux b/stdlib/source/lux/host.jvm.lux
index a3f8a82c4..7b02f3df6 100644
--- a/stdlib/source/lux/host.jvm.lux
+++ b/stdlib/source/lux/host.jvm.lux
@@ -369,7 +369,7 @@
                          definitions (macro.definitions current-module)]
                         (wrap (list/fold (: (-> [Text Definition] Class-Imports Class-Imports)
                                             (function (_ [short-name [_ meta _]] imports)
-                                              (case (macro.get-text-ann (ident-for #..jvm-class) meta)
+                                              (case (macro.get-text-ann (name-for #..jvm-class) meta)
                                                 (#.Some full-class-name)
                                                 (add-import [short-name full-class-name] imports)
 
diff --git a/stdlib/source/lux/macro.lux b/stdlib/source/lux/macro.lux
index 64dfcff24..f6dc72204 100644
--- a/stdlib/source/lux/macro.lux
+++ b/stdlib/source/lux/macro.lux
@@ -6,7 +6,7 @@
     ["." monad (#+ do Monad)]]
    [data
     ["." product]
-    [ident ("ident/." Codec<Text,Ident> Equivalence<Ident>)]
+    [name ("name/." Codec<Text,Name> Equivalence<Name>)]
     ["." maybe]
     ["e" error]
     ["." number ("nat/." Codec<Text,Nat>)]
@@ -142,7 +142,7 @@
 
 (def: #export (get-ann tag anns)
   {#.doc "Looks-up a particular annotation's value within the set of annotations."}
-  (-> Ident Code (Maybe Code))
+  (-> Name Code (Maybe Code))
   (case anns
     [_ (#.Record anns)]
     (loop [anns anns]
@@ -150,7 +150,7 @@
         (#.Cons [key value] anns')
         (case key
           [_ (#.Tag tag')]
-          (if (ident/= tag tag')
+          (if (name/= tag tag')
             (#.Some value)
             (recur anns'))
 
@@ -165,7 +165,7 @@
 
 (do-template [<name> <tag> <type>]
   [(def: #export (<name> tag anns)
-     (-> Ident Code (Maybe <type>))
+     (-> Name Code (Maybe <type>))
      (case (get-ann tag anns)
        (#.Some [_ (<tag> value)])
        (#.Some value)
@@ -177,8 +177,8 @@
   [get-int-ann    #.Int    Int]
   [get-frac-ann   #.Frac   Frac]
   [get-text-ann   #.Text   Text]
-  [get-symbol-ann #.Symbol Ident]
-  [get-tag-ann    #.Tag    Ident]
+  [get-symbol-ann #.Symbol Name]
+  [get-tag-ann    #.Tag    Name]
   [get-form-ann   #.Form   (List Code)]
   [get-tuple-ann  #.Tuple  (List Code)]
   [get-record-ann #.Record (List [Code Code])]
@@ -187,18 +187,18 @@
 (def: #export (get-doc anns)
   {#.doc "Looks-up a definition's documentation."}
   (-> Code (Maybe Text))
-  (get-text-ann (ident-for #.doc) anns))
+  (get-text-ann (name-for #.doc) anns))
 
 (def: #export (flag-set? flag-name anns)
   {#.doc "Finds out whether an annotation-as-a-flag is set (has value '#1')."}
-  (-> Ident Code Bit)
+  (-> Name Code Bit)
   (maybe.default #0 (get-bit-ann flag-name anns)))
 
 (do-template [<name> <tag> <desc>]
   [(def: #export <name>
      {#.doc (code.text ($_ text/compose "Checks whether a definition is " <desc> "."))}
      (-> Code Bit)
-     (flag-set? (ident-for <tag>)))]
+     (flag-set? (name-for <tag>)))]
 
   [export?   #.export?   "exported"]
   [macro?    #.macro?    "a macro"]
@@ -210,7 +210,7 @@
 
 (def: #export (aliased? annotations)
   (-> Code Bit)
-  (case (get-symbol-ann (ident-for #.alias) annotations)
+  (case (get-symbol-ann (name-for #.alias) annotations)
     (#.Some _)
     #1
 
@@ -237,7 +237,7 @@
      (-> Code (List Text))
      (maybe.default (list)
                     (do maybe.Monad<Maybe>
-                      [_args (get-ann (ident-for <tag>) anns)
+                      [_args (get-ann (name-for <tag>) anns)
                        args (parse-tuple _args)]
                       (monad.map @ parse-text args))))]
 
@@ -255,36 +255,35 @@
     (if (and (macro? def-anns)
              (or (export? def-anns) (text/= module this-module)))
       (#.Some (:coerce Macro def-value))
-      (case (get-symbol-ann (ident-for #.alias) def-anns)
+      (case (get-symbol-ann (name-for #.alias) def-anns)
         (#.Some [r-module r-name])
         (find-macro' modules this-module r-module r-name)
 
         _
         #.None))))
 
-(def: #export (normalize ident)
-  {#.doc "If given an identifier without a module prefix, gives it the current module's name as prefix.
+(def: #export (normalize name)
+  {#.doc "If given a name without a module prefix, gives it the current module's name as prefix.
 
-          Otherwise, returns the identifier as-is."}
-  (-> Ident (Meta Ident))
-  (case ident
+          Otherwise, returns the name as-is."}
+  (-> Name (Meta Name))
+  (case name
     ["" name]
     (do Monad<Meta>
       [module-name current-module-name]
       (wrap [module-name name]))
 
     _
-    (:: Monad<Meta> wrap ident)))
+    (:: Monad<Meta> wrap name)))
 
-(def: #export (find-macro ident)
-  (-> Ident (Meta (Maybe Macro)))
+(def: #export (find-macro full-name)
+  (-> Name (Meta (Maybe Macro)))
   (do Monad<Meta>
-    [ident (normalize ident)
+    [[module name] (normalize full-name)
      this-module current-module-name]
-    (let [[module name] ident]
-      (: (Meta (Maybe Macro))
-         (function (_ compiler)
-           (#e.Success [compiler (find-macro' (get@ #.modules compiler) this-module module name)]))))))
+    (: (Meta (Maybe Macro))
+       (function (_ compiler)
+         (#e.Success [compiler (find-macro' (get@ #.modules compiler) this-module module name)])))))
 
 (def: #export (expand-once syntax)
   {#.doc "Given code that requires applying a macro, does it once and returns the result.
@@ -361,7 +360,7 @@
     (:: Monad<Meta> wrap (list syntax))))
 
 (def: #export (gensym prefix)
-  {#.doc "Generates a unique identifier as an Code node (ready to be used in code templates).
+  {#.doc "Generates a unique name as an Code node (ready to be used in code templates).
 
           A prefix can be given (or just be empty text \"\") to better identify the code for debugging purposes."}
   (-> Text (Meta Code))
@@ -490,7 +489,7 @@
 
 (def: #export (find-def name)
   {#.doc "Looks-up a definition's whole data in the available modules (including the current one)."}
-  (-> Ident (Meta Definition))
+  (-> Name (Meta Definition))
   (do Monad<Meta>
     [name (normalize name)]
     (function (_ compiler)
@@ -505,7 +504,7 @@
         _
         (let [current-module (|> compiler (get@ #.current-module) (maybe.default "???"))]
           (#e.Error ($_ text/compose
-                        "Unknown definition: " (ident/encode name) "\n"
+                        "Unknown definition: " (name/encode name) "\n"
                         "    Current module: " current-module "\n"
                         (case (get current-module (get@ #.modules compiler))
                           (#.Some this-module)
@@ -519,14 +518,14 @@
 
 (def: #export (find-def-type name)
   {#.doc "Looks-up a definition's type in the available modules (including the current one)."}
-  (-> Ident (Meta Type))
+  (-> Name (Meta Type))
   (do Monad<Meta>
     [[def-type def-data def-value] (find-def name)]
     (clean-type def-type)))
 
 (def: #export (find-type name)
   {#.doc "Looks-up the type of either a local variable or a definition."}
-  (-> Ident (Meta Type))
+  (-> Name (Meta Type))
   (do Monad<Meta>
     [#let [[_ _name] name]]
     (case name
@@ -539,7 +538,7 @@
 
 (def: #export (find-type-def name)
   {#.doc "Finds the value of a type definition (such as Int, Any or Lux)."}
-  (-> Ident (Meta Type))
+  (-> Name (Meta Type))
   (do Monad<Meta>
     [[def-type def-data def-value] (find-def name)]
     (wrap (:coerce Type def-value))))
@@ -573,7 +572,7 @@
 
 (def: #export (tags-of type-name)
   {#.doc "All the tags associated with a type definition."}
-  (-> Ident (Meta (Maybe (List Ident))))
+  (-> Name (Meta (Maybe (List Name))))
   (do Monad<Meta>
     [#let [[module name] type-name]
      module (find-module module)]
@@ -623,7 +622,7 @@
 
 (def: #export (resolve-tag tag)
   {#.doc "Given a tag, finds out what is its index, its related tag-list and it's associated type."}
-  (-> Ident (Meta [Nat (List Ident) Type]))
+  (-> Name (Meta [Nat (List Name) Type]))
   (do Monad<Meta>
     [#let [[module name] tag]
      =module (find-module module)
@@ -634,14 +633,14 @@
       (if (or (text/= this-module-name module)
               (and imported! exported?))
         (wrap [idx tag-list type])
-        (fail ($_ text/compose "Cannot access tag: " (ident/encode tag) " from module " this-module-name)))
+        (fail ($_ text/compose "Cannot access tag: " (name/encode tag) " from module " this-module-name)))
 
       _
-      (fail ($_ text/compose "Unknown tag: " (ident/encode tag))))))
+      (fail ($_ text/compose "Unknown tag: " (name/encode tag))))))
 
 (def: #export (tag-lists module)
   {#.doc "All the tag-lists defined in a module, with their associated types."}
-  (-> Text (Meta (List [(List Ident) Type])))
+  (-> Text (Meta (List [(List Name) Type])))
   (do Monad<Meta>
     [=module (find-module module)
      this-module-name current-module-name]
@@ -669,10 +668,10 @@
 
 (def: #export (un-alias def-name)
   {#.doc "Given an aliased definition's name, returns the original definition being referenced."}
-  (-> Ident (Meta Ident))
+  (-> Name (Meta Name))
   (do Monad<Meta>
     [[_ def-anns _] (find-def def-name)]
-    (case (get-symbol-ann (ident-for #.alias) def-anns)
+    (case (get-symbol-ann (name-for #.alias) def-anns)
       (#.Some real-def-name)
       (wrap real-def-name)
 
diff --git a/stdlib/source/lux/macro/code.lux b/stdlib/source/lux/macro/code.lux
index de6f1fd50..b48406f13 100644
--- a/stdlib/source/lux/macro/code.lux
+++ b/stdlib/source/lux/macro/code.lux
@@ -5,7 +5,7 @@
    [data
     bit
     number
-    ident
+    name
     ["." text (#+ Equivalence<Text>) ("text/." Monoid<Text>)]
     [collection
      ["." list ("list/." Functor<List> Fold<List>)]]]])
@@ -41,8 +41,8 @@
   [rev    Rev               #.Rev]
   [frac   Frac              #.Frac]
   [text   Text              #.Text]
-  [symbol Ident             #.Symbol]
-  [tag    Ident             #.Tag]
+  [symbol Name              #.Symbol]
+  [tag    Name              #.Tag]
   [form   (List Code)       #.Form]
   [tuple  (List Code)       #.Tuple]
   [record (List [Code Code]) #.Record]
@@ -70,8 +70,8 @@
        [#.Rev    Equivalence<Rev>]
        [#.Frac   Equivalence<Frac>]
        [#.Text   Equivalence<Text>]
-       [#.Symbol Equivalence<Ident>]
-       [#.Tag    Equivalence<Ident>])
+       [#.Symbol Equivalence<Name>]
+       [#.Tag    Equivalence<Name>])
 
       (^template [<tag>]
         [[_ (<tag> xs')] [_ (<tag> ys')]]
@@ -98,13 +98,13 @@
      [#.Int    Codec<Text,Int>]
      [#.Rev    Codec<Text,Rev>]
      [#.Frac   Codec<Text,Frac>]
-     [#.Symbol Codec<Text,Ident>])
+     [#.Symbol Codec<Text,Name>])
 
     [_ (#.Text value)]
     (text.encode value)
 
-    [_ (#.Tag ident)]
-    (text/compose  "#" (:: Codec<Text,Ident> encode ident))
+    [_ (#.Tag name)]
+    (text/compose  "#" (:: Codec<Text,Name> encode name))
 
     (^template [<tag> <open> <close>]
       [_ (<tag> members)]
diff --git a/stdlib/source/lux/macro/poly.lux b/stdlib/source/lux/macro/poly.lux
index f234980c6..1dffc77ea 100644
--- a/stdlib/source/lux/macro/poly.lux
+++ b/stdlib/source/lux/macro/poly.lux
@@ -10,7 +10,7 @@
     ["." product]
     ["." bit]
     ["." maybe]
-    [ident ("ident/." Codec<Text,Ident>)]
+    [name ("name/." Codec<Text,Name>)]
     ["e" error]
     ["." number ("nat/." Codec<Text,Nat>)]
     ["." text ("text/." Monoid<Text>)
@@ -290,7 +290,7 @@
       (p.fail (ex.construct not-existential headT)))))
 
 (def: #export named
-  (Poly [Ident Type])
+  (Poly [Name Type])
   (do p.Monad<Parser>
     [inputT any]
     (case inputT
@@ -347,7 +347,7 @@
   (do p.Monad<Parser>
     [current any
      #let [_ (log! ($_ text/compose
-                       "{" (ident/encode (ident-for ..log)) "} "
+                       "{" (name/encode (name-for ..log)) "} "
                        (%type current)))]]
     (p.fail "LOGGING")))
 
diff --git a/stdlib/source/lux/macro/syntax.lux b/stdlib/source/lux/macro/syntax.lux
index 5bf0f21b0..1334296da 100644
--- a/stdlib/source/lux/macro/syntax.lux
+++ b/stdlib/source/lux/macro/syntax.lux
@@ -6,7 +6,7 @@
     ["p" parser]]
    [data
     ["." bit]
-    ["." ident]
+    ["." name]
     ["." maybe]
     ["." error (#+ Error)]
     ["." number]
@@ -61,8 +61,8 @@
   [   rev   Rev    #.Rev  number.Equivalence<Rev> "rev"]
   [  frac  Frac   #.Frac number.Equivalence<Frac> "frac"]
   [  text  Text   #.Text   text.Equivalence<Text> "text"]
-  [symbol Ident #.Symbol ident.Equivalence<Ident> "symbol"]
-  [   tag Ident    #.Tag ident.Equivalence<Ident> "tag"]
+  [symbol  Name #.Symbol   name.Equivalence<Name> "symbol"]
+  [   tag  Name    #.Tag   name.Equivalence<Name> "tag"]
   )
 
 (def: #export (this? ast)
diff --git a/stdlib/source/lux/macro/syntax/common.lux b/stdlib/source/lux/macro/syntax/common.lux
index 1ea1624da..dc38d1409 100644
--- a/stdlib/source/lux/macro/syntax/common.lux
+++ b/stdlib/source/lux/macro/syntax/common.lux
@@ -8,7 +8,7 @@
    #declaration-args (List Text)})
 
 (type: #export Annotations
-  (List [Ident Code]))
+  (List [Name Code]))
 
 (def: #export empty-annotations
   Annotations
diff --git a/stdlib/source/lux/macro/syntax/common/reader.lux b/stdlib/source/lux/macro/syntax/common/reader.lux
index 818320a1a..2ec2ee95d 100644
--- a/stdlib/source/lux/macro/syntax/common/reader.lux
+++ b/stdlib/source/lux/macro/syntax/common/reader.lux
@@ -4,7 +4,7 @@
     monad
     ["p" parser ("parser/." Monad<Parser>)]]
    [data
-    [ident ("ident/." Equivalence<Ident>)]
+    [name ("name/." Equivalence<Name>)]
     ["." product]
     ["." maybe]
     [collection
@@ -49,7 +49,7 @@
                    s.any)))
 
 (def: _definition-anns-tag^
-  (Syntax Ident)
+  (Syntax Name)
   (s.tuple (p.seq s.text s.text)))
 
 (def: (_definition-anns^ _)
@@ -88,9 +88,9 @@
   )
 
 (def: (find-definition-args meta-data)
-  (-> (List [Ident Code]) (List Text))
+  (-> (List [Name Code]) (List Text))
   (<| (maybe.default (list))
-      (case (list.find (|>> product.left (ident/= ["lux" "func-args"])) meta-data)
+      (case (list.find (|>> product.left (name/= ["lux" "func-args"])) meta-data)
         (^multi (#.Some [_ value])
                 [(p.run (list value) tuple-meta^)
                  (#.Right [_ args])]
diff --git a/stdlib/source/lux/test.lux b/stdlib/source/lux/test.lux
index 3c213e29b..75879343c 100644
--- a/stdlib/source/lux/test.lux
+++ b/stdlib/source/lux/test.lux
@@ -205,7 +205,7 @@
     [defs (macro.exports module-name)]
     (wrap (|> defs
               (list/map (function (_ [def-name [_ def-anns _]])
-                          (case (macro.get-text-ann (ident-for #..test) def-anns)
+                          (case (macro.get-text-ann (name-for #..test) def-anns)
                             (#.Some description)
                             [#1 module-name def-name description]
 
diff --git a/stdlib/source/lux/type.lux b/stdlib/source/lux/type.lux
index 9d774198d..929967e84 100644
--- a/stdlib/source/lux/type.lux
+++ b/stdlib/source/lux/type.lux
@@ -6,7 +6,7 @@
     ["p" parser]]
    [data
     ["." text ("text/." Monoid<Text> Equivalence<Text>)]
-    [ident ("ident/." Equivalence<Ident> Codec<Text,Ident>)]
+    [name ("name/." Equivalence<Name> Codec<Text,Name>)]
     [number ("nat/." Codec<Text,Nat>)]
     ["." maybe]
     [collection
@@ -69,7 +69,7 @@
            (= xright yright))
 
       [(#.Named xname xtype) (#.Named yname ytype)]
-      (and (ident/= xname yname)
+      (and (name/= xname yname)
            (= xtype ytype))
 
       (^template [<tag>]
@@ -251,8 +251,8 @@
 (def: #export (un-alias type)
   (-> Type Type)
   (case type
-    (#.Named _ (#.Named ident type'))
-    (un-alias (#.Named ident type'))
+    (#.Named _ (#.Named name type'))
+    (un-alias (#.Named name type'))
 
     _
     type))
@@ -260,7 +260,7 @@
 (def: #export (un-name type)
   (-> Type Type)
   (case type
-    (#.Named ident type')
+    (#.Named name type')
     (un-name type')
 
     _
@@ -345,7 +345,7 @@
        valueT (macro.find-type valueN)
        #let [_ (log! ($_ text/compose
                          ":log!" " @ " (.cursor-description cursor) "\n"
-                         (ident/encode valueN) " : " (..to-text valueT) "\n"))]]
+                         (name/encode valueN) " : " (..to-text valueT) "\n"))]]
       (wrap (list (' []))))
 
     (#.Right valueC)
diff --git a/stdlib/source/lux/type/abstract.lux b/stdlib/source/lux/type/abstract.lux
index 7dd65b106..648435721 100644
--- a/stdlib/source/lux/type/abstract.lux
+++ b/stdlib/source/lux/type/abstract.lux
@@ -61,7 +61,7 @@
 (def: representation-name
   (-> Text Text)
   (|>> ($_ text/compose "{" kind "@" module "}")
-       (let [[module kind] (ident-for #..Representation)])))
+       (let [[module kind] (name-for #..Representation)])))
 
 (def: (cast type-vars input-declaration output-declaration)
   (-> (List Code) Code Code Macro)
diff --git a/stdlib/source/lux/type/implicit.lux b/stdlib/source/lux/type/implicit.lux
index f8be1a83f..1deb21c60 100644
--- a/stdlib/source/lux/type/implicit.lux
+++ b/stdlib/source/lux/type/implicit.lux
@@ -39,7 +39,7 @@
     ))
 
 (def: (resolve-type var-name)
-  (-> Ident (Meta Type))
+  (-> Name (Meta Type))
   (do Monad<Meta>
     [raw-type (macro.find-type var-name)
      compiler macro.get-compiler]
@@ -75,7 +75,7 @@
       (check.fail (format "Cannot find member type " (%n idx) " for " (%type sig-type))))))
 
 (def: (find-member-name member)
-  (-> Ident (Meta Ident))
+  (-> Name (Meta Name))
   (case member
     ["" simple-name]
     (macro.either (do Monad<Meta>
@@ -91,26 +91,26 @@
                                                    tag-lists)]]
                     (case candidates
                       #.Nil
-                      (macro.fail (format "Unknown tag: " (%ident member)))
+                      (macro.fail (format "Unknown tag: " (%name member)))
                       
                       (#.Cons winner #.Nil)
                       (wrap winner)
                       
                       _
-                      (macro.fail (format "Too many candidate tags: " (%list %ident candidates))))))
+                      (macro.fail (format "Too many candidate tags: " (%list %name candidates))))))
 
     _
     (:: Monad<Meta> wrap member)))
 
 (def: (resolve-member member)
-  (-> Ident (Meta [Nat Type]))
+  (-> Name (Meta [Nat Type]))
   (do Monad<Meta>
     [member (find-member-name member)
      [idx tag-list sig-type] (macro.resolve-tag member)]
     (wrap [idx sig-type])))
 
 (def: (prepare-definitions this-module-name definitions)
-  (-> Text (List [Text Definition]) (List [Ident Type]))
+  (-> Text (List [Text Definition]) (List [Name Type]))
   (|> definitions
       (list.filter (function (_ [name [def-type def-anns def-value]])
                      (macro.struct? def-anns)))
@@ -118,7 +118,7 @@
                   [[this-module-name name] def-type]))))
 
 (def: local-env
-  (Meta (List [Ident Type]))
+  (Meta (List [Name Type]))
   (do Monad<Meta>
     [local-batches macro.locals
      #let [total-locals (list/fold (function (_ [name type] table)
@@ -131,14 +131,14 @@
               (list/map (function (_ [name type]) [["" name] type]))))))
 
 (def: local-structs
-  (Meta (List [Ident Type]))
+  (Meta (List [Name Type]))
   (do Monad<Meta>
     [this-module-name macro.current-module-name
      definitions (macro.definitions this-module-name)]
     (wrap (prepare-definitions this-module-name definitions))))
 
 (def: import-structs
-  (Meta (List [Ident Type]))
+  (Meta (List [Name Type]))
   (do Monad<Meta>
     [this-module-name macro.current-module-name
      imp-mods (macro.imported-modules this-module-name)
@@ -193,12 +193,12 @@
     (check.check output-type member-type')))
 
 (type: #rec Instance
-  {#constructor Ident
+  {#constructor Name
    #dependencies (List Instance)})
 
 (def: (test-provision provision context dep alts)
   (-> (-> Lux Type-Context Type (Check Instance))
-      Type-Context Type (List [Ident Type])
+      Type-Context Type (List [Name Type])
       (Meta (List Instance)))
   (do Monad<Meta>
     [compiler macro.get-compiler]
@@ -243,11 +243,11 @@
       (:: check.Monad<Check> wrap winner)
 
       _
-      (check.fail (format "Too many candidates for provisioning: " (%type dep) " --- " (%list (|>> product.left %ident) candidates))))
+      (check.fail (format "Too many candidates for provisioning: " (%type dep) " --- " (%list (|>> product.left %name) candidates))))
     ))
 
 (def: (test-alternatives sig-type member-idx input-types output-type alts)
-  (-> Type Nat (List Type) Type (List [Ident Type]) (Meta (List Instance)))
+  (-> Type Nat (List Type) Type (List [Name Type]) (Meta (List Instance)))
   (do Monad<Meta>
     [compiler macro.get-compiler
      context macro.type-context]
@@ -341,7 +341,7 @@
        chosen-ones (find-alternatives sig-type member-idx input-types output-type)]
       (case chosen-ones
         #.Nil
-        (macro.fail (format "No structure option could be found for member: " (%ident member)))
+        (macro.fail (format "No structure option could be found for member: " (%name member)))
 
         (#.Cons chosen #.Nil)
         (wrap (list (` (:: (~ (instance$ chosen))
@@ -351,7 +351,7 @@
         _
         (macro.fail (format "Too many options available: "
                             (|> chosen-ones
-                                (list/map (|>> product.left %ident))
+                                (list/map (|>> product.left %name))
                                 (text.join-with ", "))
                             " --- for type: " (%type sig-type)))))
 
diff --git a/stdlib/source/lux/type/object/interface.lux b/stdlib/source/lux/type/object/interface.lux
index cb92c7253..fb2579d55 100644
--- a/stdlib/source/lux/type/object/interface.lux
+++ b/stdlib/source/lux/type/object/interface.lux
@@ -6,7 +6,7 @@
    [data
     ["." product]
     ["." maybe]
-    [ident ("ident/." Equivalence<Ident>)]
+    [name ("name/." Equivalence<Name>)]
     ["." text
      format]
     [collection
@@ -65,7 +65,7 @@
       (p.default default-alias)))
 
 (def: (ancestor-inputs ancestors)
-  (-> (List Ident) (List Code))
+  (-> (List Name) (List Code))
   (if (list.empty? ancestors)
     (list)
     (|> (list.size ancestors)
@@ -120,39 +120,39 @@
 
 ## [Inheritance]
 (type: Reference
-  [Ident (List Code)])
+  [Name (List Code)])
 
-(def: no-parent Ident ["" ""])
+(def: no-parent Name ["" ""])
 
 (def: (no-parent? parent)
-  (-> Ident Bit)
-  (ident/= no-parent parent))
+  (-> Name Bit)
+  (name/= no-parent parent))
 
 (def: (with-interface parent interface)
-  (-> Ident Ident cs.Annotations cs.Annotations)
-  (|>> (#.Cons [(ident-for #..interface-name)
+  (-> Name Name cs.Annotations cs.Annotations)
+  (|>> (#.Cons [(name-for #..interface-name)
                 (code.tag interface)])
-       (#.Cons [(ident-for #..interface-parent)
+       (#.Cons [(name-for #..interface-parent)
                 (code.tag parent)])))
 
 (def: (with-class interface parent class)
-  (-> Ident Ident Ident cs.Annotations cs.Annotations)
-  (|>> (#.Cons [(ident-for #..class-interface)
+  (-> Name Name Name cs.Annotations cs.Annotations)
+  (|>> (#.Cons [(name-for #..class-interface)
                 (code.tag interface)])
-       (#.Cons [(ident-for #..class-parent)
+       (#.Cons [(name-for #..class-parent)
                 (code.tag parent)])
-       (#.Cons [(ident-for #..class-name)
+       (#.Cons [(name-for #..class-name)
                 (code.tag class)])))
 
 (do-template [<name> <name-tag> <parent-tag> <desc>]
   [(def: (<name> name)
-     (-> Ident (Meta [Ident (List Ident)]))
+     (-> Name (Meta [Name (List Name)]))
      (do Monad<Meta>
        [[_ annotations _] (macro.find-def name)]
-       (case [(macro.get-tag-ann (ident-for <name-tag>) annotations)
-              (macro.get-tag-ann (ident-for <parent-tag>) annotations)]
+       (case [(macro.get-tag-ann (name-for <name-tag>) annotations)
+              (macro.get-tag-ann (name-for <parent-tag>) annotations)]
          [(#.Some real-name) (#.Some parent)]
-         (if (ident/= no-parent parent)
+         (if (name/= no-parent parent)
            (wrap [real-name (list)])
            (do @
              [[_ ancestors] (<name> parent)]
@@ -238,7 +238,7 @@
 (do-template [<name> <category>]
   [(def: (<name> raw)
      (-> Text Text)
-     (let [[module kind] (ident-for <category>)]
+     (let [[module kind] (name-for <category>)]
        (format "{" kind "@" module "}" raw)))]
 
   [signatureN #..Signature]
@@ -247,7 +247,7 @@
   )
 
 (def: (getterN export interface g!parameters g!ext g!child ancestors)
-  (-> Bit Text (List Code) Code Code (List Ident)
+  (-> Bit Text (List Code) Code Code (List Name)
       Code)
   (let [g!get (code.local-symbol (getN interface))
         g!interface (code.local-symbol interface)
@@ -266,7 +266,7 @@
            (~ g!_state))))))
 
 (def: (setterN export interface g!parameters g!ext g!child ancestors)
-  (-> Bit Text (List Code) Code Code (List Ident)
+  (-> Bit Text (List Code) Code Code (List Name)
       Code)
   (let [g!set (code.local-symbol (setN interface))
         g!interface (code.local-symbol interface)
@@ -289,7 +289,7 @@
            (~ g!build-up))))))
 
 (def: (updaterN export interface g!parameters g!ext g!child ancestors)
-  (-> Bit Text (List Code) Code Code (List Ident)
+  (-> Bit Text (List Code) Code Code (List Name)
       Code)
   (let [g!update (code.local-symbol (updateN interface))
         g!interface (code.local-symbol interface)
@@ -367,7 +367,7 @@
   (macro.with-gensyms [g!self-class g!child g!ext]
     (do @
       [module macro.current-module-name
-       [parent ancestors mappings] (: (Meta [Ident (List Ident) (List Code)])
+       [parent ancestors mappings] (: (Meta [Name (List Name) (List Code)])
                                       (case ?extends
                                         #.None
                                         (wrap [no-parent (list) (list)])
@@ -437,7 +437,7 @@
     (do @
       [module macro.current-module-name
        [interface _] (interfaceN interface)
-       [parent ancestors parent-mappings] (: (Meta [Ident (List Ident) (List Code)])
+       [parent ancestors parent-mappings] (: (Meta [Name (List Name) (List Code)])
                                              (case super
                                                (#.Some [super-class super-mappings])
                                                (do @
diff --git a/stdlib/source/lux/type/resource.lux b/stdlib/source/lux/type/resource.lux
index c683a93cb..68d0410dd 100644
--- a/stdlib/source/lux/type/resource.lux
+++ b/stdlib/source/lux/type/resource.lux
@@ -19,7 +19,8 @@
      ["." list ("list/." Functor<List> Fold<List>)]]]
    [concurrency
     ["." promise (#+ Promise)]]
-   ["." macro ["s" syntax (#+ Syntax syntax:)]]
+   ["." macro
+    ["s" syntax (#+ Syntax syntax:)]]
    [type
     abstract]
    ["." io (#+ IO)]])
diff --git a/stdlib/source/lux/type/unit.lux b/stdlib/source/lux/type/unit.lux
index e7be06eed..230818e30 100644
--- a/stdlib/source/lux/type/unit.lux
+++ b/stdlib/source/lux/type/unit.lux
@@ -62,7 +62,7 @@
   [(def: <name>
      (-> Text Text)
      (|>> (format "{" kind "@" module "}")
-          (let [[module kind] (ident-for <tag>)])))]
+          (let [[module kind] (name-for <tag>)])))]
   
   [unit-name  #..Unit]
   [scale-name #..Scale]
diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/reference.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/reference.lux
index 6a103d155..de813de4e 100644
--- a/stdlib/test/test/lux/compiler/default/phase/analysis/reference.lux
+++ b/stdlib/test/test/lux/compiler/default/phase/analysis/reference.lux
@@ -5,7 +5,7 @@
     pipe]
    [data
     ["e" error]
-    [ident ("ident/." Equivalence<Ident>)]
+    [name ("name/." Equivalence<Name>)]
     [text ("text/." Equivalence<Text>)]]
    [math
     ["r" random]]
@@ -96,7 +96,7 @@
                         (phase.run [analysisE.bundle (init.compiler [])])
                         (case> (^ (#e.Success [_ inferredT (#analysis.Reference (reference.constant constant-name))]))
                                (and (type/= expectedT inferredT)
-                                    (ident/= def-name constant-name))
+                                    (name/= def-name constant-name))
 
                                _
                                #0))))
diff --git a/stdlib/test/test/lux/compiler/default/syntax.lux b/stdlib/test/test/lux/compiler/default/syntax.lux
index 42ae7f379..a0d5ce367 100644
--- a/stdlib/test/test/lux/compiler/default/syntax.lux
+++ b/stdlib/test/test/lux/compiler/default/syntax.lux
@@ -26,7 +26,7 @@
    #.line   +0
    #.column +0})
 
-(def: ident-part^
+(def: name-part^
   (r.Random Text)
   (do r.Monad<Random>
     [#let [digits "0123456789"
@@ -41,9 +41,9 @@
      size (|> r.nat (:: @ map (|>> (n/% +20) (n/max +1))))]
     (r.text char-gen size)))
 
-(def: ident^
-  (r.Random Ident)
-  (r.seq ident-part^ ident-part^))
+(def: name^
+  (r.Random Name)
+  (r.seq name-part^ name-part^))
 
 (def: code^
   (r.Random Code)
@@ -59,8 +59,8 @@
                         (do r.Monad<Random>
                           [size (|> r.nat (r/map (n/% +20)))]
                           (|> (r.unicode size) (r/map code.text)))
-                        (|> ident^ (r/map code.symbol))
-                        (|> ident^ (r/map code.tag))))
+                        (|> name^ (r/map code.symbol))
+                        (|> name^ (r/map code.tag))))
         simple^ (: (r.Random Code)
                    ($_ r.either
                        numeric^
diff --git a/stdlib/test/test/lux/data/format/xml.lux b/stdlib/test/test/lux/data/format/xml.lux
index d09dc1b45..37eec4169 100644
--- a/stdlib/test/test/lux/data/format/xml.lux
+++ b/stdlib/test/test/lux/data/format/xml.lux
@@ -5,7 +5,7 @@
     ["p" parser]
     pipe]
    [data
-    ["." ident]
+    ["." name]
     ["E" error]
     ["." maybe]
     ["." text ("text/." Equivalence<Text>)
@@ -43,7 +43,7 @@
     (r.text xml-char^ size)))
 
 (def: xml-identifier^
-  (r.Random Ident)
+  (r.Random Name)
   (r.seq (xml-text^ +0 +10)
          (xml-text^ +1 +10)))
 
@@ -55,7 +55,7 @@
                     [size (size^ +0 +2)]
                     ($_ r.seq
                         xml-identifier^
-                        (r.dictionary ident.Hash<Ident> size xml-identifier^ (xml-text^ +0 +10))
+                        (r.dictionary name.Hash<Name> size xml-identifier^ (xml-text^ +0 +10))
                         (r.list size gen-xml)))))))
 
 (context: "XML."
diff --git a/stdlib/test/test/lux/data/ident.lux b/stdlib/test/test/lux/data/ident.lux
deleted file mode 100644
index ed9339f01..000000000
--- a/stdlib/test/test/lux/data/ident.lux
+++ /dev/null
@@ -1,73 +0,0 @@
-(.module:
-  [lux #*
-   [control
-    [monad (#+ do Monad)]
-    pipe]
-   [data
-    ["&" ident]
-    ["." text ("text/." Equivalence<Text>)
-     format]]
-   [math
-    ["r" random]]]
-  lux/test)
-
-(def: (gen-part size)
-  (-> Nat (r.Random Text))
-  (|> (r.unicode size) (r.filter (|>> (text.contains? ".") not))))
-
-(context: "Idents"
-  (<| (times +100)
-      (do @
-        [## First Ident
-         sizeM1 (|> r.nat (:: @ map (n/% +100)))
-         sizeN1 (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1))))
-         module1 (gen-part sizeM1)
-         name1 (gen-part sizeN1)
-         #let [ident1 [module1 name1]]
-         ## Second Ident
-         sizeM2 (|> r.nat (:: @ map (n/% +100)))
-         sizeN2 (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1))))
-         module2 (gen-part sizeM2)
-         name2 (gen-part sizeN2)
-         #let [ident2 [module2 name2]]
-         #let [(^open "&/.") &.Equivalence<Ident>
-               (^open "&/.") &.Codec<Text,Ident>]]
-        ($_ seq
-            (test "Can get the module & name parts of an ident."
-                  (and (is? module1 (&.module ident1))
-                       (is? name1 (&.name ident1))))
-
-            (test "Can compare idents for equivalence."
-                  (and (&/= ident1 ident1)
-                       (if (&/= ident1 ident2)
-                         (and (text/= module1 module2)
-                              (text/= name1 name2))
-                         (or (not (text/= module1 module2))
-                             (not (text/= name1 name2))))))
-
-            (test "Can encode idents as text."
-                  (|> ident1
-                      &/encode &/decode
-                      (case> (#.Right dec-ident) (&/= ident1 dec-ident)
-                             _ #0)))
-
-            (test "Encoding an ident without a module component results in text equal to the name of the ident."
-                  (if (text.empty? module1)
-                    (text/= name1 (&/encode ident1))
-                    #1))
-            ))))
-
-(context: "Ident-related macros."
-  (let [(^open "&/.") &.Equivalence<Ident>]
-    ($_ seq
-        (test "Can obtain Ident from symbol."
-              (and (&/= ["lux" "yolo"] (ident-for .yolo))
-                   (&/= ["test/lux/data/ident" "yolo"] (ident-for ..yolo))
-                   (&/= ["" "yolo"] (ident-for yolo))
-                   (&/= ["lux/test" "yolo"] (ident-for lux/test.yolo))))
-        
-        (test "Can obtain Ident from tag."
-              (and (&/= ["lux" "yolo"] (ident-for #.yolo))
-                   (&/= ["test/lux/data/ident" "yolo"] (ident-for #..yolo))
-                   (&/= ["" "yolo"] (ident-for #yolo))
-                   (&/= ["lux/test" "yolo"] (ident-for #lux/test.yolo)))))))
diff --git a/stdlib/test/test/lux/data/name.lux b/stdlib/test/test/lux/data/name.lux
new file mode 100644
index 000000000..699b76bb2
--- /dev/null
+++ b/stdlib/test/test/lux/data/name.lux
@@ -0,0 +1,73 @@
+(.module:
+  [lux #*
+   [control
+    [monad (#+ do Monad)]
+    pipe]
+   [data
+    ["&" name]
+    ["." text ("text/." Equivalence<Text>)
+     format]]
+   [math
+    ["r" random]]]
+  lux/test)
+
+(def: (gen-part size)
+  (-> Nat (r.Random Text))
+  (|> (r.unicode size) (r.filter (|>> (text.contains? ".") not))))
+
+(context: "Names"
+  (<| (times +100)
+      (do @
+        [## First Name
+         sizeM1 (|> r.nat (:: @ map (n/% +100)))
+         sizeN1 (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1))))
+         module1 (gen-part sizeM1)
+         short1 (gen-part sizeN1)
+         #let [name1 [module1 short1]]
+         ## Second Name
+         sizeM2 (|> r.nat (:: @ map (n/% +100)))
+         sizeN2 (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1))))
+         module2 (gen-part sizeM2)
+         short2 (gen-part sizeN2)
+         #let [name2 [module2 short2]]
+         #let [(^open "&/.") &.Equivalence<Name>
+               (^open "&/.") &.Codec<Text,Name>]]
+        ($_ seq
+            (test "Can get the module & short parts of an name."
+                  (and (is? module1 (&.module name1))
+                       (is? short1 (&.short name1))))
+
+            (test "Can compare names for equivalence."
+                  (and (&/= name1 name1)
+                       (if (&/= name1 name2)
+                         (and (text/= module1 module2)
+                              (text/= short1 short2))
+                         (or (not (text/= module1 module2))
+                             (not (text/= short1 short2))))))
+
+            (test "Can encode names as text."
+                  (|> name1
+                      &/encode &/decode
+                      (case> (#.Right dec-name) (&/= name1 dec-name)
+                             _ #0)))
+
+            (test "Encoding an name without a module component results in text equal to the short of the name."
+                  (if (text.empty? module1)
+                    (text/= short1 (&/encode name1))
+                    #1))
+            ))))
+
+(context: "Name-related macros."
+  (let [(^open "&/.") &.Equivalence<Name>]
+    ($_ seq
+        (test "Can obtain Name from symbol."
+              (and (&/= ["lux" "yolo"] (name-for .yolo))
+                   (&/= ["test/lux/data/name" "yolo"] (name-for ..yolo))
+                   (&/= ["" "yolo"] (name-for yolo))
+                   (&/= ["lux/test" "yolo"] (name-for lux/test.yolo))))
+        
+        (test "Can obtain Name from tag."
+              (and (&/= ["lux" "yolo"] (name-for #.yolo))
+                   (&/= ["test/lux/data/name" "yolo"] (name-for #..yolo))
+                   (&/= ["" "yolo"] (name-for #yolo))
+                   (&/= ["lux/test" "yolo"] (name-for #lux/test.yolo)))))))
diff --git a/stdlib/test/test/lux/macro/syntax.lux b/stdlib/test/test/lux/macro/syntax.lux
index a9913f754..d378153bc 100644
--- a/stdlib/test/test/lux/macro/syntax.lux
+++ b/stdlib/test/test/lux/macro/syntax.lux
@@ -6,7 +6,7 @@
     ["p" parser]]
    [data
     ["." bit]
-    ["." ident]
+    ["." name]
     ["e" error]
     ["." number]
     ["." text
@@ -78,8 +78,8 @@
                       ["Can parse Rev syntax."   .123            code.rev    number.Equivalence<Rev>  s.rev]
                       ["Can parse Frac syntax."   123.0          code.frac   number.Equivalence<Frac> s.frac]
                       ["Can parse Text syntax."   "\n"           code.text   text.Equivalence<Text>   s.text]
-                      ["Can parse Symbol syntax." ["yolo" "lol"] code.symbol ident.Equivalence<Ident> s.symbol]
-                      ["Can parse Tag syntax."    ["yolo" "lol"] code.tag    ident.Equivalence<Ident> s.tag]
+                      ["Can parse Symbol syntax." ["yolo" "lol"] code.symbol name.Equivalence<Name>   s.symbol]
+                      ["Can parse Tag syntax."    ["yolo" "lol"] code.tag    name.Equivalence<Name>   s.tag]
                       )]
     ($_ seq
         <simple-tests>
diff --git a/stdlib/test/test/lux/type.lux b/stdlib/test/test/lux/type.lux
index 9592170ff..611f7bd60 100644
--- a/stdlib/test/test/lux/type.lux
+++ b/stdlib/test/test/lux/type.lux
@@ -15,33 +15,36 @@
   lux/test)
 
 ## [Utils]
-(def: gen-name
+(def: #export gen-short
   (r.Random Text)
   (do r.Monad<Random>
     [size (|> r.nat (:: @ map (n/% +10)))]
     (r.unicode size)))
 
-(def: gen-ident
-  (r.Random Ident)
-  (r.seq gen-name gen-name))
+(def: #export gen-name
+  (r.Random Name)
+  (r.seq gen-short gen-short))
 
-(def: gen-type
+(def: #export gen-type
   (r.Random Type)
   (let [(^open "R/.") r.Monad<Random>]
     (r.rec (function (_ gen-type)
-             ($_ r.alt
-                 (r.seq gen-name (R/wrap (list)))
-                 (r.seq gen-type gen-type)
-                 (r.seq gen-type gen-type)
-                 (r.seq gen-type gen-type)
-                 r.nat
-                 r.nat
-                 r.nat
-                 (r.seq (R/wrap (list)) gen-type)
-                 (r.seq (R/wrap (list)) gen-type)
-                 (r.seq gen-type gen-type)
-                 (r.seq gen-ident gen-type)
-                 )))))
+             (let [pairG (r.seq gen-type gen-type)
+                   idG r.nat
+                   quantifiedG (r.seq (R/wrap (list)) gen-type)]
+               ($_ r.alt
+                   (r.seq gen-short (R/wrap (list)))
+                   pairG
+                   pairG
+                   pairG
+                   idG
+                   idG
+                   idG
+                   quantifiedG
+                   quantifiedG
+                   pairG
+                   (r.seq gen-name gen-type)
+                   ))))))
 
 ## [Tests]
 (context: "Types"
diff --git a/stdlib/test/test/lux/type/check.lux b/stdlib/test/test/lux/type/check.lux
index c817ec61e..b1d0365e1 100644
--- a/stdlib/test/test/lux/type/check.lux
+++ b/stdlib/test/test/lux/type/check.lux
@@ -15,37 +15,10 @@
     ["r" random]]
    ["." type ("type/." Equivalence<Type>)
     ["@" check]]]
-  lux/test)
+  lux/test
+  ["." //])
 
 ## [Utils]
-(def: gen-name
-  (r.Random Text)
-  (do r.Monad<Random>
-    [size (|> r.nat (:: @ map (n/% +10)))]
-    (r.unicode size)))
-
-(def: gen-ident
-  (r.Random Ident)
-  (r.seq gen-name gen-name))
-
-(def: gen-type
-  (r.Random Type)
-  (let [(^open "r/.") r.Monad<Random>]
-    (r.rec (function (_ gen-type)
-             ($_ r.alt
-                 (r.seq gen-name (r/wrap (list)))
-                 (r.seq gen-type gen-type)
-                 (r.seq gen-type gen-type)
-                 (r.seq gen-type gen-type)
-                 r.nat
-                 r.nat
-                 r.nat
-                 (r.seq (r/wrap (list)) gen-type)
-                 (r.seq (r/wrap (list)) gen-type)
-                 (r.seq gen-type gen-type)
-                 (r.seq gen-ident gen-type)
-                 )))))
-
 (def: (valid-type? type)
   (-> Type Bit)
   (case type
@@ -79,7 +52,7 @@
 (context: "Any and Nothing."
   (<| (times +100)
       (do @
-        [sample (|> gen-type (r.filter valid-type?))]
+        [sample (|> //.gen-type (r.filter valid-type?))]
         ($_ seq
             (test "Any is the super-type of everything."
                   (@.checks? Any sample))
@@ -127,8 +100,8 @@
 (context: "Type application."
   (<| (times +100)
       (do @
-        [meta gen-type
-         data gen-type]
+        [meta //.gen-type
+         data //.gen-type]
         (test "Can type-check type application."
               (and (@.checks? (|> Ann (#.Apply meta) (#.Apply data))
                               (type.tuple (list meta data)))
@@ -138,10 +111,10 @@
 (context: "Primitive types."
   (<| (times +100)
       (do @
-        [nameL gen-name
-         nameR (|> gen-name (r.filter (|>> (text/= nameL) not)))
-         paramL gen-type
-         paramR (|> gen-type (r.filter (|>> (@.checks? paramL) not)))]
+        [nameL //.gen-short
+         nameR (|> //.gen-short (r.filter (|>> (text/= nameL) not)))
+         paramL //.gen-type
+         paramR (|> //.gen-type (r.filter (|>> (@.checks? paramL) not)))]
         ($_ seq
             (test "Primitive types match when they have the same name and the same parameters."
                   (@.checks? (#.Primitive nameL (list paramL))
@@ -207,7 +180,7 @@
   (<| (times +100)
       (do @
         [num-connections (|> r.nat (:: @ map (n/% +100)))
-         boundT (|> gen-type (r.filter (|>> (case> (#.Var _) #0 _ #1))))
+         boundT (|> //.gen-type (r.filter (|>> (case> (#.Var _) #0 _ #1))))
          pick-pcg (r.seq r.nat r.nat)]
         ($_ seq
             (test "Can create rings of variables."
diff --git a/stdlib/test/tests.lux b/stdlib/test/tests.lux
index e855220dd..db2687876 100644
--- a/stdlib/test/tests.lux
+++ b/stdlib/test/tests.lux
@@ -96,7 +96,7 @@
      ["_." bit]
      ["_." color]
      ["_." error]
-     ["_." ident]
+     ["_." name]
      ["_." identity]
      ["_." lazy]
      ["_." maybe]