Re-named "Name" to "Symbol".

1 files changed, 57 insertions, 57 deletions

diff --git a/stdlib/source/library/lux.lux b/stdlib/source/library/lux.lux
index 9aed7e4de..f3f3601d3 100644
--- a/stdlib/source/library/lux.lux
+++ b/stdlib/source/library/lux.lux
@@ -108,10 +108,10 @@
      {0 #0 "#Text" {#End}}})
  #1)
 
-("lux def" Name
+("lux def" Symbol
  ("lux type check type"
   {9 #1
-     [..prelude_module "Name"]
+     [..prelude_module "Symbol"]
      {2 #0 Text Text}})
  #1)
 
@@ -144,7 +144,7 @@
 ...      {#UnivQ (List Type) Type}
 ...      {#ExQ (List Type) Type}
 ...      {#Apply Type Type}
-...      {#Named Name Type})))
+...      {#Named Symbol Type})))
 ("lux def type tagged" Type
  {9 #1 [..prelude_module "Type"]
     ({Type
@@ -185,7 +185,7 @@
                                               ... Apply
                                               Type_Pair
                                               ... Named
-                                              {2 #0 Name Type}}}}}}}}}}}}}}
+                                              {2 #0 Symbol Type}}}}}}}}}}}}}}
          ("lux type check type" {2 #0 Type Type}))}
        ("lux type check type" {9 #0 Type List}))}
      ("lux type check type" {9 #0 {0 #0 ["" {#End}]} {4 #0 0}}))}
@@ -224,7 +224,7 @@
 ...   {#Rev Rev}
 ...   {#Frac Frac}
 ...   {#Text Text}
-...   {#Identifier Name}
+...   {#Identifier Symbol}
 ...   {#Form (List (w (Code' w)))}
 ...   {#Variant (List (w (Code' w)))}
 ...   {#Tuple (List (w (Code' w)))})
@@ -253,7 +253,7 @@
                            Text
                            {#Sum
                             ... Identifier
-                            Name
+                            Symbol
                             {#Sum
                              ... Form
                              Code_List
@@ -336,7 +336,7 @@
  #0)
 
 ("lux def" identifier$
- ("lux type check" {#Function Name Code}
+ ("lux type check" {#Function Symbol Code}
   ([_ name] (_ann {#Identifier name})))
  #0)
 
@@ -369,11 +369,11 @@
  .public)
 
 ... (type: .public Alias
-...   Name)
+...   Symbol)
 ("lux def" Alias
  ("lux type check type"
   {#Named [..prelude_module "Alias"]
-          Name})
+          Symbol})
  .public)
 
 ... (type: .public Label
@@ -1489,15 +1489,15 @@
          (-> Text Text Text)
          ("lux text concat" x y))
 
-(def:''' .private (name#encoded full_name)
-         (-> Name Text)
+(def:''' .private (symbol#encoded full_name)
+         (-> Symbol Text)
          (let' [[module name] full_name]
                ({"" name
                  _  ($_ text#composite module "." name)}
                 module)))
 
 (def:''' .private (global_identifier full_name state)
-         (-> Name ($' Meta Name))
+         (-> Symbol ($' Meta Symbol))
          (let' [[module name] full_name
                 [#info info #source    source  #current_module _ #modules modules
                  #scopes scopes #type_context types    #host    host
@@ -1515,11 +1515,11 @@
                     constant)
 
                    {#None}
-                   {#Left ($_ text#composite "Unknown definition: " (name#encoded full_name))}}
+                   {#Left ($_ text#composite "Unknown definition: " (symbol#encoded full_name))}}
                   (plist#value name definitions))
                  
                  {#None}
-                 {#Left ($_ text#composite "Unknown module: " module " @ " (name#encoded full_name))}}
+                 {#Left ($_ text#composite "Unknown module: " module " @ " (symbol#encoded full_name))}}
                 (plist#value module modules))))
 
 (def:''' .private (:List<Code> expression)
@@ -1752,7 +1752,7 @@
          (function' [x] (f (g x))))
 
 (def:''' .private (identifier_name x)
-         (-> Code ($' Maybe Name))
+         (-> Code ($' Maybe Symbol))
          ({[_ {#Identifier sname}]
            {#Some sname}
 
@@ -1993,7 +1993,7 @@
             ("lux type check" Global gdef))))
 
 (def:''' .private (normal name)
-         (-> Name ($' Meta Name))
+         (-> Symbol ($' Meta Symbol))
          ({["" name]
            (do meta_monad
              [module_name current_module_name]
@@ -2004,7 +2004,7 @@
           name))
 
 (def:''' .private (macro' full_name)
-         (-> Name ($' Meta ($' Maybe Macro)))
+         (-> Symbol ($' Meta ($' Maybe Macro)))
          (do meta_monad
            [current_module current_module_name]
            (let' [[module name] full_name]
@@ -2018,7 +2018,7 @@
                              state)))))
 
 (def:''' .private (macro? name)
-         (-> Name ($' Meta Bit))
+         (-> Symbol ($' Meta Bit))
          (do meta_monad
            [name (normal name)
             output (macro' name)]
@@ -2843,7 +2843,7 @@
         {#Left ($_ text#composite "Unknown module: " name)}))))
 
 (def: (type_slot [module name])
-  (-> Name (Meta [Nat (List Name) Bit Type]))
+  (-> Symbol (Meta [Nat (List Symbol) Bit Type]))
   (do meta_monad
     [=module (..module module)
      .let [[#module_hash _ #module_aliases _ #definitions definitions #imports _ #module_state _] =module]]
@@ -2857,10 +2857,10 @@
                 type])
 
       _
-      (failure (text#composite "Unknown slot: " (name#encoded [module name]))))))
+      (failure (text#composite "Unknown slot: " (symbol#encoded [module name]))))))
 
 (def: (record_slots type)
-  (-> Type (Meta (Maybe [(List Name) (List Type)])))
+  (-> Type (Meta (Maybe [(List Symbol) (List Type)])))
   (case type
     {#Apply arg func}
     (record_slots func)
@@ -2949,7 +2949,7 @@
           ")"))
     
     {#Named name _}
-    (name#encoded name)
+    (symbol#encoded name)
     ))
 
 (macro: .public (implementation tokens)
@@ -2957,7 +2957,7 @@
     [tokens' (monad#each meta_monad expansion tokens)
      struct_type ..expected_type
      tags+type (record_slots struct_type)
-     tags (: (Meta (List Name))
+     tags (: (Meta (List Symbol))
              (case tags+type
                {#Some [tags _]}
                (in_meta tags)
@@ -3595,7 +3595,7 @@
               scopes)))
 
 (def: (definition_type name state)
-  (-> Name Lux (Maybe Type))
+  (-> Symbol Lux (Maybe Type))
   (let [[v_module v_name] name
         [#info info #source    source  #current_module _ #modules modules
          #scopes scopes #type_context types    #host    host
@@ -3628,7 +3628,7 @@
           {#None})))))
 
 (def: (definition_value name state)
-  (-> Name (Meta [Type Any]))
+  (-> Symbol (Meta [Type Any]))
   (let [[v_module v_name] name
         [#info info #source    source #current_module _  #modules modules
          #scopes scopes #type_context types    #host    host
@@ -3636,12 +3636,12 @@
          #scope_type_vars scope_type_vars #eval _eval] state]
     (case (plist#value v_module modules)
       {#None}
-      {#Left (text#composite "Unknown definition: " (name#encoded name))}
+      {#Left (text#composite "Unknown definition: " (symbol#encoded name))}
 
       {#Some [#definitions definitions #module_hash _ #module_aliases _ #imports _ #module_state _]}
       (case (plist#value v_name definitions)
         {#None}
-        {#Left (text#composite "Unknown definition: " (name#encoded name))}
+        {#Left (text#composite "Unknown definition: " (symbol#encoded name))}
 
         {#Some definition}
         (case definition
@@ -3655,10 +3655,10 @@
           {#Right [state [..Type type]]}
 
           {#Tag _}
-          {#Left (text#composite "Unknown definition: " (name#encoded name))}
+          {#Left (text#composite "Unknown definition: " (symbol#encoded name))}
 
           {#Slot _}
-          {#Left (text#composite "Unknown definition: " (name#encoded name))})))))
+          {#Left (text#composite "Unknown definition: " (symbol#encoded name))})))))
 
 (def: (type_variable idx bindings)
   (-> Nat (List [Nat (Maybe Type)]) (Maybe Type))
@@ -3672,7 +3672,7 @@
       (type_variable idx bindings'))))
 
 (def: (type_definition full_name)
-  (-> Name (Meta Type))
+  (-> Symbol (Meta Type))
   (do meta_monad
     [.let [[module name] full_name]
      current_module current_module_name]
@@ -3688,13 +3688,13 @@
                        {#Right [compiler struct_type]}
 
                        _
-                       {#Left ($_ text#composite "Unknown var: " (name#encoded full_name))}))
+                       {#Left ($_ text#composite "Unknown var: " (symbol#encoded full_name))}))
                    (case (definition_type full_name compiler)
                      {#Some struct_type}
                      {#Right [compiler struct_type]}
 
                      _
-                     {#Left ($_ text#composite "Unknown var: " (name#encoded full_name))}))]
+                     {#Left ($_ text#composite "Unknown var: " (symbol#encoded full_name))}))]
         (case temp
           {#Right [compiler {#Var type_id}]}
           (let [[#info _ #source _ #current_module _ #modules _
@@ -3745,7 +3745,7 @@
 
         {#Some tags&members}
         (do meta_monad
-          [full_body ((: (-> Name [(List Name) (List Type)] Code (Meta Code))
+          [full_body ((: (-> Symbol [(List Symbol) (List Type)] Code (Meta Code))
                          (function (recur source [tags members] target)
                            (let [locals (list#each (function (_ [t_module t_name])
                                                      [[t_module t_name]
@@ -3821,7 +3821,7 @@
       (case (interface_methods type)
         {#Some members}
         (let [pattern (|> (zipped/2 tags (enumeration members))
-                          (list#each (: (-> [Name [Nat Type]] (List Code))
+                          (list#each (: (-> [Symbol [Nat Type]] (List Code))
                                         (function (_ [[r_module r_name] [r_idx r_type]])
                                           (list (identifier$ [r_module r_name])
                                                 (if ("lux i64 =" idx r_idx)
@@ -3851,7 +3851,7 @@
     (failure "Wrong syntax for value@")))
 
 (def: (open_declaration alias tags my_tag_index [module short] source type)
-  (-> Text (List Name) Nat Name Code Type (Meta (List Code)))
+  (-> Text (List Symbol) Nat Symbol Code Type (Meta (List Code)))
   (do meta_monad
     [output (record_slots type)
      g!_ (..identifier "g!_")
@@ -3868,7 +3868,7 @@
       {#Some [tags' members']}
       (do meta_monad
         [decls' (monad#each meta_monad
-                            (: (-> [Nat Name Type] (Meta (List Code)))
+                            (: (-> [Nat Symbol Type] (Meta (List Code)))
                                (function (_ [sub_tag_index sname stype])
                                  (open_declaration alias tags' sub_tag_index sname source+ stype)))
                             (enumeration (zipped/2 tags' members')))]
@@ -3891,7 +3891,7 @@
         (case output
           {#Some [tags members]}
           (do meta_monad
-            [decls' (monad#each meta_monad (: (-> [Nat Name Type] (Meta (List Code)))
+            [decls' (monad#each meta_monad (: (-> [Nat Symbol Type] (Meta (List Code)))
                                               (function (_ [tag_index sname stype])
                                                 (open_declaration alias tags tag_index sname source stype)))
                                 (enumeration (zipped/2 tags members)))]
@@ -3944,9 +3944,9 @@
       _
       (failure ($_ text#composite "Wrong syntax for refer @ " current_module
                    \n (|> options
-                            (list#each code#encoded)
-                            (list#interposed " ")
-                            (list#mix text#composite "")))))))
+                          (list#each code#encoded)
+                          (list#interposed " ")
+                          (list#mix text#composite "")))))))
 
 (def: (referral_definitions module_name [r_defs r_opens])
   (-> Text Refer (Meta (List Code)))
@@ -4071,21 +4071,21 @@
         {#Some members}
         (do meta_monad
           [pattern' (monad#each meta_monad
-                                (: (-> [Name [Nat Type]] (Meta [Name Nat Code]))
+                                (: (-> [Symbol [Nat Type]] (Meta [Symbol Nat Code]))
                                    (function (_ [r_slot_name [r_idx r_type]])
                                      (do meta_monad
                                        [g!slot (..identifier "")]
                                        (in_meta [r_slot_name r_idx g!slot]))))
                                 (zipped/2 tags (enumeration members)))]
           (let [pattern (|> pattern'
-                            (list#each (: (-> [Name Nat Code] (List Code))
+                            (list#each (: (-> [Symbol Nat Code] (List Code))
                                           (function (_ [r_slot_name r_idx r_var])
                                             (list (identifier$ r_slot_name)
                                                   r_var))))
                             list#conjoint
                             tuple$)
                 output (|> pattern'
-                           (list#each (: (-> [Name Nat Code] (List Code))
+                           (list#each (: (-> [Symbol Nat Code] (List Code))
                                          (function (_ [r_slot_name r_idx r_var])
                                            (list (identifier$ r_slot_name)
                                                  (if ("lux i64 =" idx r_idx)
@@ -4154,21 +4154,21 @@
         {#Some members}
         (do meta_monad
           [pattern' (monad#each meta_monad
-                                (: (-> [Name [Nat Type]] (Meta [Name Nat Code]))
+                                (: (-> [Symbol [Nat Type]] (Meta [Symbol Nat Code]))
                                    (function (_ [r_slot_name [r_idx r_type]])
                                      (do meta_monad
                                        [g!slot (..identifier "")]
                                        (in_meta [r_slot_name r_idx g!slot]))))
                                 (zipped/2 tags (enumeration members)))]
           (let [pattern (|> pattern'
-                            (list#each (: (-> [Name Nat Code] (List Code))
+                            (list#each (: (-> [Symbol Nat Code] (List Code))
                                           (function (_ [r_slot_name r_idx r_var])
                                             (list (identifier$ r_slot_name)
                                                   r_var))))
                             list#conjoint
                             tuple$)
                 output (|> pattern'
-                           (list#each (: (-> [Name Nat Code] (List Code))
+                           (list#each (: (-> [Symbol Nat Code] (List Code))
                                          (function (_ [r_slot_name r_idx r_var])
                                            (list (identifier$ r_slot_name)
                                                  (if ("lux i64 =" idx r_idx)
@@ -4314,7 +4314,7 @@
             inits (list#each product#right pairs)]
         (if (every? identifier? inits)
           (do meta_monad
-            [inits' (: (Meta (List Name))
+            [inits' (: (Meta (List Symbol))
                        (case (monad#each maybe_monad identifier_name inits)
                          {#Some inits'} (in_meta inits')
                          {#None}        (failure "Wrong syntax for loop")))
@@ -4343,8 +4343,8 @@
   (case tokens
     (^ (list& [_ {#Form (list [_ {#Tuple (list& hslot' tslots')}])}] body branches))
     (do meta_monad
-      [slots (: (Meta [Name (List Name)])
-                (case (: (Maybe [Name (List Name)])
+      [slots (: (Meta [Symbol (List Symbol)])
+                (case (: (Maybe [Symbol (List Symbol)])
                          (do maybe_monad
                            [hslot (..identifier_name hslot')
                             tslots (monad#each maybe_monad ..identifier_name tslots')]
@@ -4360,12 +4360,12 @@
        output (..type_slot hslot)
        g!_ (..identifier "_")
        .let [[idx tags exported? type] output
-             slot_pairings (list#each (: (-> Name [Text Code])
+             slot_pairings (list#each (: (-> Symbol [Text Code])
                                          (function (_ [module name])
                                            [name (local_identifier$ name)]))
                                       (list& hslot tslots))
              pattern (|> tags
-                         (list#each (: (-> Name (List Code))
+                         (list#each (: (-> Symbol (List Code))
                                        (function (_ [module name])
                                          (let [tag (identifier$ [module name])]
                                            (case (plist#value name slot_pairings)
@@ -4438,7 +4438,7 @@
     type))
 
 (def: (static_simple_literal name)
-  (-> Name (Meta Code))
+  (-> Symbol (Meta Code))
   (do meta_monad
     [type+value (definition_value name)
      .let [[type value] type+value]]
@@ -4454,7 +4454,7 @@
        ["Text" Text text$])
       
       _
-      (failure (text#composite "Cannot anti-quote type: " (name#encoded name))))))
+      (failure (text#composite "Cannot anti-quote type: " (symbol#encoded name))))))
 
 (def: (static_literal token)
   (-> Code (Meta Code))
@@ -4571,8 +4571,8 @@
 ... currently being defined. That name can then be fed into
 ... 'wrong_syntax_error' for easier maintenance of the error_messages.
 (def: wrong_syntax_error
-  (-> Name Text)
-  (|>> name#encoded
+  (-> Symbol Text)
+  (|>> symbol#encoded
        (text#composite "Wrong syntax for ")))
 
 (macro: .public (name_of tokens)
@@ -4762,7 +4762,7 @@
 
         _
         (failure ($_ text#composite
-                     "Invalid target platform (must be a value of type Text): " (name#encoded identifier)
+                     "Invalid target platform (must be a value of type Text): " (symbol#encoded identifier)
                      " : " (..code#encoded (..type_code type))))))
 
     _
@@ -4856,7 +4856,7 @@
     (failure (..wrong_syntax_error (name_of ..``)))))
 
 (def: (name$ [module name])
-  (-> Name Code)
+  (-> Symbol Code)
   (` [(~ (text$ module)) (~ (text$ name))]))
 
 (def: (untemplated_list& last inits)