Moved "lux/data/number" to "lux/math/number".

1 files changed, 27 insertions, 27 deletions

diff --git a/stdlib/source/program/compositor.lux b/stdlib/source/program/compositor.lux
index fdd985f2a..6c1a9202c 100644
--- a/stdlib/source/program/compositor.lux
+++ b/stdlib/source/program/compositor.lux
@@ -57,54 +57,54 @@
    ["#." export]
    ["#." import]])
 
-(def: (or-crash! failure-description action)
+(def: (or_crash! failure_description action)
   (All [a]
     (-> Text (Promise (Try a)) (Promise a)))
   (do promise.monad
     [?output action]
     (case ?output
       (#try.Failure error)
-      (exec (log! (format text.new-line
-                          failure-description text.new-line
-                          error text.new-line))
+      (exec (log! (format text.new_line
+                          failure_description text.new_line
+                          error text.new_line))
         (io.run (\ world/program.default exit +1)))
 
       (#try.Success output)
       (wrap output))))
 
-(def: (package! monad file-system [packager package] static archive context)
+(def: (package! monad file_system [packager package] static archive context)
   (All [!] (-> (Monad !) (file.System !) [Packager Path] Static Archive Context (! (Try Any))))
   (for {@.old
         (do (try.with monad)
           [#let [packager (:share [!] {(Monad !) monad} {(Packager !) packager})]
-           content (packager monad file-system static archive context)
+           content (packager monad file_system static archive context)
            package (:share [!]
                            {(Monad !)
                             monad}
                            {(! (Try (File !)))
-                            (:assume (file.get-file monad file-system package))})]
+                            (:assume (file.get_file monad file_system package))})]
           (!.use (\ (:share [!]
                             {(Monad !)
                              monad}
                             {(File !)
                              (:assume package)})
-                    over-write)
+                    over_write)
                  [content]))}
-       ## TODO: Fix whatever type-checker bug is forcing me into this compromise...
+       ## TODO: Fix whatever type_checker bug is forcing me into this compromise...
        (:assume
         (: (Promise (Try Any))
            (let [monad (:coerce (Monad Promise) monad)
-                 file-system (:coerce (file.System Promise) file-system)
+                 file_system (:coerce (file.System Promise) file_system)
                  packager (:coerce (Packager Promise) packager)]
              (do (try.with monad)
-               [content (packager monad file-system static archive context)
+               [content (packager monad file_system static archive context)
                 package (: (Promise (Try (File Promise)))
-                           (file.get-file monad file-system package))]
-               (!.use (\ (: (File Promise) package) over-write) [content])))))))
+                           (file.get_file monad file_system package))]
+               (!.use (\ (: (File Promise) package) over_write) [content])))))))
 
-(with-expansions [<parameters> (as-is anchor expression artifact)]
+(with_expansions [<parameters> (as_is anchor expression artifact)]
   (def: #export (compiler static
-                          expander host-analysis platform generation-bundle host-directive-bundle program anchorT,expressionT,directiveT extender
+                          expander host_analysis platform generation_bundle host_directive_bundle program anchorT,expressionT,directiveT extender
                           service
                           packager,package)
     (All [<parameters>]
@@ -124,41 +124,41 @@
       [platform (promise.future platform)]
       (case service
         (#/cli.Compilation compilation)
-        (<| (or-crash! "Compilation failed:")
+        (<| (or_crash! "Compilation failed:")
             (do (try.with promise.monad)
-              [#let [[compilation-sources compilation-libraries compilation-target compilation-module] compilation]
-               import (/import.import (get@ #platform.&file-system platform) compilation-libraries)
+              [#let [[compilation_sources compilation_libraries compilation_target compilation_module] compilation]
+               import (/import.import (get@ #platform.&file_system platform) compilation_libraries)
                [state archive] (:share [<parameters>]
                                        {(Platform <parameters>)
                                         platform}
                                        {(Promise (Try [(directive.State+ <parameters>)
                                                        Archive]))
-                                        (:assume (platform.initialize static compilation-module expander host-analysis platform generation-bundle host-directive-bundle program anchorT,expressionT,directiveT extender
-                                                                      import compilation-sources))})
+                                        (:assume (platform.initialize static compilation_module expander host_analysis platform generation_bundle host_directive_bundle program anchorT,expressionT,directiveT extender
+                                                                      import compilation_sources))})
                [archive state] (:share [<parameters>]
                                        {(Platform <parameters>)
                                         platform}
                                        {(Promise (Try [Archive (directive.State+ <parameters>)]))
                                         (:assume (platform.compile import static expander platform compilation [archive state]))})
-               _ (ioW.freeze (get@ #platform.&file-system platform) static archive)
-               program-context (promise\wrap ($/program.context archive))
-               _ (promise.future (..package! io.monad file.default packager,package static archive program-context))]
+               _ (ioW.freeze (get@ #platform.&file_system platform) static archive)
+               program_context (promise\wrap ($/program.context archive))
+               _ (promise.future (..package! io.monad file.default packager,package static archive program_context))]
               (wrap (log! "Compilation complete!"))))
 
         (#/cli.Export export)
-        (<| (or-crash! "Export failed:")
+        (<| (or_crash! "Export failed:")
             (do (try.with promise.monad)
-              [_ (/export.export (get@ #platform.&file-system platform)
+              [_ (/export.export (get@ #platform.&file_system platform)
                                  export)]
               (wrap (log! "Export complete!"))))
         
         (#/cli.Interpretation interpretation)
         ## TODO: Fix the interpreter...
         (undefined)
-        ## (<| (or-crash! "Interpretation failed:")
+        ## (<| (or_crash! "Interpretation failed:")
         ##     (do {! promise.monad}
         ##       [console (|> console.default
         ##                    promise.future
         ##                    (\ ! map (|>> try.assume console.async)))]
-        ##       (interpreter.run (try.with promise.monad) console platform interpretation generation-bundle)))
+        ##       (interpreter.run (try.with promise.monad) console platform interpretation generation_bundle)))
         ))))