Moved interpreter (REPL) code to stdlib.

7 files changed, 304 insertions, 90 deletions

diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux
index 7faad6c0a..9bf515bdb 100644
--- a/stdlib/source/lux.lux
+++ b/stdlib/source/lux.lux
@@ -652,19 +652,19 @@
 ## (type: Mode
 ##   #Build
 ##   #Eval
-##   #REPL)
+##   #Interpreter)
 ("lux def" Mode
  (#Named ["lux" "Mode"]
          (#Sum ## Build
           Any
           (#Sum ## Eval
            Any
-           ## REPL
+           ## Interpreter
            Any)))
  (record$ (#Cons [(tag$ ["lux" "tags"])
                   (tuple$ (#Cons (text$ "Build")
                                  (#Cons (text$ "Eval")
-                                        (#Cons (text$ "REPL")
+                                        (#Cons (text$ "Interpreter")
                                                #Nil))))]
                  (#Cons [(tag$ ["lux" "doc"])
                          (text$ "A sign that shows the conditions under which the compiler is running.")]
diff --git a/stdlib/source/lux/compiler/cli.lux b/stdlib/source/lux/compiler/cli.lux
index a73eb5a15..55ce35145 100644
--- a/stdlib/source/lux/compiler/cli.lux
+++ b/stdlib/source/lux/compiler/cli.lux
@@ -8,46 +8,32 @@
 
 (type: #export Configuration
   {#sources (List File)
-   #target File})
-
-(type: #export Build
-  [Configuration Text])
-
-(type: #export REPL
-  Configuration)
+   #target File
+   #module Text})
 
 (type: #export Service
-  (#Build Build)
-  (#REPL REPL))
+  (#Compilation Configuration)
+  (#Interpretation Configuration))
 
 (do-template [<name> <short> <long>]
   [(def: #export <name>
      (CLI Text)
      (cli.parameter [<short> <long>]))]
 
-  [source  "-s" "--source"]
-  [target  "-t" "--target"]
-  [program "-p" "--program"]
+  [source "-s" "--source"]
+  [target "-t" "--target"]
+  [module "-m" "--module"]
   )
 
 (def: #export configuration
   (CLI Configuration)
   ($_ p.and
       (p.some ..source)
-      ..target))
-
-(def: #export build
-  (CLI Build)
-  ($_ p.and
-      configuration
-      ..program))
-
-(def: #export repl
-  (CLI REPL)
-  ..configuration)
+      ..target
+      ..module))
 
 (def: #export service
   (CLI Service)
   ($_ p.or
-      (p.after (cli.this "build") ..build)
-      (p.after (cli.this "repl") ..repl)))
+      (p.after (cli.this "build") ..configuration)
+      (p.after (cli.this "repl") ..configuration)))
diff --git a/stdlib/source/lux/compiler/default.lux b/stdlib/source/lux/compiler/default.lux
index cb93fdba4..ac3fb7aa8 100644
--- a/stdlib/source/lux/compiler/default.lux
+++ b/stdlib/source/lux/compiler/default.lux
@@ -118,15 +118,15 @@
        _ (loop-module-compilation module-name)]
       (end-module-compilation module-name)))
 
-  (def: #export (compile-module platform configuration module-name compiler)
+  (def: #export (compile-module platform configuration compiler)
     (All [fs anchor expression statement]
-      (-> <Platform> Configuration Text <Compiler> (fs <Compiler>)))
+      (-> <Platform> Configuration <Compiler> (fs <Compiler>)))
     (do (:: (get@ #file-system platform) &monad)
       [source (context.read (get@ #file-system platform)
                             (get@ #cli.sources configuration)
-                            module-name)
-       ## _ (&io.prepare-module target-dir module-name)
-       ## _ (write-module target-dir file-name module-name module artifacts)
+                            (get@ #cli.module configuration))
+       ## _ (&io.prepare-module target-dir (get@ #cli.module configuration))
+       ## _ (write-module target-dir file-name (get@ #cli.module configuration) module artifacts)
        ]
       (<| (:: @ map product.left)
           (:: (get@ #file-system platform) lift)
@@ -135,9 +135,9 @@
                   {<Platform>
                    platform}
                   {<Operation>
-                   (perform-module-compilation module-name source)}))))
+                   (perform-module-compilation (get@ #cli.module configuration) source)}))))
 
-  (def: (initialize-runtime platform configuration)
+  (def: #export (initialize platform configuration)
     (All [fs anchor expression statement]
       (-> <Platform> Configuration (fs <Compiler>)))
     (|> platform
@@ -174,13 +174,13 @@
     ##   (io.fail error))
     )
 
-  (def: #export (compile platform configuration program)
+  (def: #export (compile platform configuration)
     (All [fs anchor expression statement]
-      (-> <Platform> Configuration Text (fs Any)))
+      (-> <Platform> Configuration (fs Any)))
     (do (:: (get@ #file-system platform) &monad)
-      [compiler (initialize-runtime platform configuration)
-       _ (compile-module platform configuration ..prelude compiler)
-       _ (compile-module platform configuration program compiler)
+      [compiler (initialize platform configuration)
+       _ (compile-module platform (set@ #cli.module ..prelude configuration) compiler)
+       _ (compile-module platform configuration compiler)
        ## _ (cache/io.clean target ...)
        ]
       (wrap (log! "Compilation complete!"))))
diff --git a/stdlib/source/lux/compiler/default/phase/extension.lux b/stdlib/source/lux/compiler/default/phase/extension.lux
index 3783b741a..808c6b4fd 100644
--- a/stdlib/source/lux/compiler/default/phase/extension.lux
+++ b/stdlib/source/lux/compiler/default/phase/extension.lux
@@ -24,7 +24,8 @@
     <Bundle>))
 
 (type: #export (State s i o)
-  [(Bundle s i o) s])
+  {#bundle (Bundle s i o)
+   #state s})
 
 (type: #export (Operation s i o v)
   (//.Operation (State s i o) v))
diff --git a/stdlib/source/lux/interpreter.lux b/stdlib/source/lux/interpreter.lux
new file mode 100644
index 000000000..2feb4b81c
--- /dev/null
+++ b/stdlib/source/lux/interpreter.lux
@@ -0,0 +1,217 @@
+(.module:
+  [lux #*
+   [control
+    [monad (#+ Monad do)]
+    ["ex" exception (#+ exception:)]]
+   [data
+    ["." error (#+ Error)]
+    [text ("text/." Equivalence<Text>)
+     format]]
+   [type (#+ :share)
+    ["." check]]
+   [compiler
+    ["." cli (#+ Configuration)]
+    ["." default (#+ Platform)
+     ["." syntax]
+     ["." init]
+     ["." phase
+      ["." analysis
+       ["." module]
+       ["." type]]
+      ["." translation]
+      ["." statement (#+ State+ Operation)
+       ["." total]]
+      ["." extension]]]]
+   [world
+    ["." file (#+ File)]
+    ["." console (#+ Console)]]]
+  ["." /type])
+
+(exception: #export (error {message Text})
+  message)
+
+(def: #export module "<INTERPRETER>")
+
+(def: fresh-source Source [[..module 1 0] 0 ""])
+
+(def: (add-line line [where offset input])
+  (-> Text Source Source)
+  [where offset (format input "\n" line)])
+
+(def: exit-command Text "exit")
+
+(def: welcome-message
+  Text
+  (format "\n"
+          "Welcome to the interpreter!" "\n"
+          "Type \"exit\" to leave." "\n"
+          "\n"))
+
+(def: farewell-message
+  Text
+  "Till next time...")
+
+(def: enter-module
+  (All [anchor expression statement]
+    (Operation anchor expression statement Any))
+  (statement.lift-analysis
+   (do phase.Monad<Operation>
+     [_ (module.create 0 ..module)]
+     (analysis.set-current-module ..module))))
+
+(def: (initialize Monad<!> Console<!> platform configuration)
+  (All [! anchor expression statement]
+    (-> (Monad !)
+        (Console !) (Platform ! anchor expression statement)
+        Configuration
+        (! (State+ anchor expression statement))))
+  (do Monad<!>
+    [state (default.initialize platform configuration)
+     state (default.compile-module platform
+                                   (set@ #cli.module default.prelude configuration)
+                                   (set@ [#extension.state
+                                          #statement.analysis #statement.state
+                                          #extension.state
+                                          #.info #.mode]
+                                         #.Interpreter
+                                         state))
+     [state _] (:: (get@ #default.file-system platform)
+                   lift (phase.run' state enter-module))
+     _ (:: Console<!> write ..welcome-message)]
+    (wrap state)))
+
+(with-expansions [<Interpretation> (as-is (Operation anchor expression statement [Type Any]))]
+  
+  (def: (interpret-statement code)
+    (All [anchor expression statement]
+      (-> Code <Interpretation>))
+    (do phase.Monad<Operation>
+      [_ (total.phase code)
+       _ init.refresh]
+      (wrap [Any []])))
+
+  (def: (interpret-expression code)
+    (All [anchor expression statement]
+      (-> Code <Interpretation>))
+    (do phase.Monad<Operation>
+      [state (extension.lift phase.get-state)
+       #let [analyse (get@ [#statement.analysis #statement.phase] state)
+             synthesize (get@ [#statement.synthesis #statement.phase] state)
+             translate (get@ [#statement.translation #statement.phase] state)]
+       [_ codeT codeA] (statement.lift-analysis
+                        (analysis.with-scope
+                          (type.with-fresh-env
+                            (do @
+                              [[codeT codeA] (type.with-inference
+                                               (analyse code))
+                               codeT (type.with-env
+                                       (check.clean codeT))]
+                              (wrap [codeT codeA])))))
+       codeS (statement.lift-synthesis
+              (synthesize codeA))]
+      (statement.lift-translation
+       (translation.with-buffer
+         (do @
+           [codeH (translate codeS)
+            count translation.next
+            codeV (translation.evaluate! (format "interpretation_" (%n count)) codeH)]
+           (wrap [codeT codeV]))))))
+
+  (def: (interpret configuration code)
+    (All [anchor expression statement]
+      (-> Configuration Code <Interpretation>))
+    (function (_ state)
+      (case (<| (phase.run' state)
+                (:share [anchor expression statement]
+                        {(State+ anchor expression statement)
+                         state}
+                        {<Interpretation>
+                         (interpret-statement code)}))
+        (#error.Success [state' output])
+        (#error.Success [state' output])
+
+        (#error.Error error)
+        (if (ex.match? total.unrecognized-statement error)
+          (<| (phase.run' state)
+              (:share [anchor expression statement]
+                      {(State+ anchor expression statement)
+                       state}
+                      {<Interpretation>
+                       (interpret-expression code)}))
+          (#error.Error error)))))
+  )
+
+(def: (execute configuration code)
+  (All [anchor expression statement]
+    (-> Configuration Code (Operation anchor expression statement Text)))
+  (do phase.Monad<Operation>
+    [[codeT codeV] (interpret configuration code)
+     state phase.get-state]
+    (wrap (/type.represent (get@ [#extension.state
+                                  #statement.analysis #statement.state
+                                  #extension.state]
+                                 state)
+                           codeT
+                           codeV))))
+
+(type: (Context anchor expression statement)
+  {#configuration Configuration
+   #state (State+ anchor expression statement)
+   #source Source})
+
+(with-expansions [<Context> (as-is (Context anchor expression statement))]
+  (def: (read-eval-print context)
+    (All [anchor expression statement]
+      (-> <Context> (Error [<Context> Text])))
+    (do error.Monad<Error>
+      [[source' input] (syntax.read ..module syntax.no-aliases (get@ #source context))
+       [state' representation] (let [## TODO: Simplify ASAP
+                                     state (:share [anchor expression statement]
+                                                   {<Context>
+                                                    context}
+                                                   {(State+ anchor expression statement)
+                                                    (get@ #state context)})]
+                                 (<| (phase.run' state)
+                                     ## TODO: Simplify ASAP
+                                     (:share [anchor expression statement]
+                                             {<Context>
+                                              context}
+                                             {(Operation anchor expression statement Text)
+                                              (execute (get@ #configuration context) input)})))]
+      (wrap [(|> context
+                 (set@ #state state')
+                 (set@ #source source'))
+             representation]))))
+
+(def: #export (run Monad<!> Console<!> platform configuration)
+  (All [! anchor expression statement]
+    (-> (Monad !)
+        (Console !) (Platform ! anchor expression statement)
+        Configuration
+        (! Any)))
+  (do Monad<!>
+    [state (initialize Monad<!> Console<!> platform configuration)]
+    (loop [context {#configuration configuration
+                    #state state
+                    #source ..fresh-source}
+           multi-line? #0]
+      (do @
+        [_ (if multi-line?
+             (:: Console<!> write "  ")
+             (:: Console<!> write "> "))
+         line (:: Console<!> read-line)]
+        (if (and (not multi-line?)
+                 (text/= ..exit-command line))
+          (:: Console<!> write ..farewell-message)
+          (case (read-eval-print (update@ #source (add-line line) context))
+            (#error.Success [context' representation])
+            (do @
+              [_ (:: Console<!> write representation)]
+              (recur context' #0))
+
+            (#error.Error error)
+            (if (ex.match? syntax.end-of-file error)
+              (recur context #1)
+              (exec (log! (ex.construct ..error error))
+                (recur (set@ #source ..fresh-source context) #0))))))
+      )))
diff --git a/stdlib/source/lux/compiler/default/repl/type.lux b/stdlib/source/lux/interpreter/type.lux
index 7d3ac0d9c..7d3ac0d9c 100644
--- a/stdlib/source/lux/compiler/default/repl/type.lux
+++ b/stdlib/source/lux/interpreter/type.lux
diff --git a/stdlib/source/lux/world/console.lux b/stdlib/source/lux/world/console.lux
index 93365f61e..85db061c8 100644
--- a/stdlib/source/lux/world/console.lux
+++ b/stdlib/source/lux/world/console.lux
@@ -7,66 +7,76 @@
     ["." error]
     ["." text
      format]]
-   [concurrency
-    ["." promise]
-    ["." task (#+ Task)]]
    ["." io (#+ IO Process io)]
-   [host (#+ import:)]])
+   [host (#+ import:)]
+   [compiler
+    ["." host]]])
 
-(exception: #export (cannot-close)
-  "")
+(do-template [<name>]
+  [(exception: #export (<name>)
+     "")]
 
-(signature: #export (Console m)
-  (: (-> [] (m Nat))
+  [cannot-open]
+  [cannot-close]
+  )
+
+(signature: #export (Console !)
+  (: (-> [] (! Nat))
      read)
-  (: (-> [] (m Text))
+  (: (-> [] (! Text))
      read-line)
-  (: (-> [Text] (m Any))
+  (: (-> Text (! Any))
      write)
-  (: (-> [] (m Any))
+  (: (-> [] (! Any))
      close))
 
-(for {"JVM"
-      (as-is (import: java/lang/String)
+(`` (for {(~~ (static host.jvm))
+          (as-is (import: java/lang/String)
+
+                 (import: #long java/io/Console
+                   (readLine [] #io #try String))
 
-             (import: #long java/io/Console
-               (readLine [] #io #try String))
+                 (import: java/io/InputStream
+                   (read [] #io #try int))
 
-             (import: java/io/InputStream
-               (read [] #io #try int))
+                 (import: java/io/PrintStream
+                   (print [String] #io #try void))
 
-             (import: java/io/PrintStream
-               (print [String] #io #try void))
+                 (import: java/lang/System
+                   (#static console [] #io #? java/io/Console)
+                   (#static in java/io/InputStream)
+                   (#static out java/io/PrintStream))
 
-             (import: java/lang/System
-               (#static console [] #io #try java/io/Console)
-               (#static in java/io/InputStream)
-               (#static out java/io/PrintStream))
+                 (def: #export open
+                   (Process (Console Process))
+                   (do io.Monad<IO>
+                     [?jvm-console (System::console [])]
+                     (case ?jvm-console
+                       #.None
+                       (io.fail (ex.construct cannot-open []))
 
-             (def: #export open
-               (Process (Console Task))
-               (do io.Monad<Process>
-                 [jvm-console (System::console [])
-                  #let [jvm-input System::in
-                        jvm-output System::out]]
-                 (wrap (: (Console Task)
-                          (structure
-                           (def: (read _)
-                             (|> jvm-input
-                                 (InputStream::read [])
-                                 (:: io.Functor<Process> map .nat)
-                                 promise.future))
-                           
-                           (def: (read-line _)
-                             (|> jvm-console (java/io/Console::readLine []) promise.future))
-                           
-                           (def: (write message)
-                             (|> jvm-output (PrintStream::print [message]) promise.future))
-                           
-                           (def: close
-                             (|>> (ex.construct cannot-close) task.fail))))))))
-      })
+                       (#.Some jvm-console)
+                       (let [jvm-input System::in
+                             jvm-output System::out]
+                         (<| io.from-io
+                             wrap
+                             (: (Console Process)) ## TODO: Remove ASAP
+                             (structure
+                              (def: (read _)
+                                (|> jvm-input
+                                    (InputStream::read [])
+                                    (:: io.Functor<Process> map .nat)))
+                              
+                              (def: (read-line _)
+                                (|> jvm-console (java/io/Console::readLine [])))
+                              
+                              (def: (write message)
+                                (|> jvm-output (PrintStream::print [message])))
+                              
+                              (def: close
+                                (|>> (ex.construct cannot-close) io.fail)))))))))
+          }))
 
-(def: #export (write-line message console)
-  (All [m] (-> Text (Console m) (m Any)))
-  (:: console write (format message "")))
+(def: #export (write-line message Console<!>)
+  (All [!] (-> Text (Console !) (! Any)))
+  (:: Console<!> write (format message "")))