- Added a new (albeit small) I/O library with host-dependent functions.

5 files changed, 76 insertions, 46 deletions

diff --git a/source/lux/data/io.lux b/source/lux/data/io.lux
index 5c54c0369..4919d2edd 100644
--- a/source/lux/data/io.lux
+++ b/source/lux/data/io.lux
@@ -38,14 +38,3 @@
 
   (def (join mma)
     (mma [])))
-
-## [Functions]
-(def #export (print x)
-  (-> Text (IO (,)))
-  (@io (_jvm_invokevirtual "java.io.PrintStream" "print" ["java.lang.String"]
-                           (_jvm_getstatic "java.lang.System" "out") [x])))
-
-(def #export (println x)
-  (-> Text (IO (,)))
-  (@io (_jvm_invokevirtual "java.io.PrintStream" "println" ["java.lang.String"]
-                           (_jvm_getstatic "java.lang.System" "out") [x])))
diff --git a/source/lux/host/io.lux b/source/lux/host/io.lux
new file mode 100644
index 000000000..7611e41b7
--- /dev/null
+++ b/source/lux/host/io.lux
@@ -0,0 +1,35 @@
+##  Copyright (c) Eduardo Julian. All rights reserved.
+##  This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+##  If a copy of the MPL was not distributed with this file,
+##  You can obtain one at http://mozilla.org/MPL/2.0/.
+
+(;import lux
+         lux/data/io
+         (.. jvm))
+
+## [Functions]
+(do-template [<name> <method> <type> <class>]
+  [(def #export (<name> x)
+     (-> <type> (IO (,)))
+     (@io (.! (<method> [<class>] [x])
+              (..? out java.lang.System))))]
+
+  [write-char print   Char char]
+  [write      print   Text java.lang.String]
+  [write-line println Text java.lang.String])
+
+(do-template [<name> <type> <op>]
+  [(def #export <name>
+     (IO (Maybe <type>))
+     (let [in (..? in java.lang.System)
+           reader (new java.io.InputStreamReader [java.io.InputStream] [in])
+           buff-reader (new java.io.BufferedReader [java.io.Reader] [reader])]
+       (@io (let [output (: (Either Text <type>) (try$ <op>))]
+              (exec (.! (close [] []) buff-reader)
+                (case output
+                  (#;Left _)      #;None
+                  (#;Right input) (#;Some input)))))))]
+
+  [read-char Char (_jvm_i2c (.! (read [] []) buff-reader))]
+  [read-line Text (.! (readLine [] []) buff-reader)]
+  )
diff --git a/source/lux/host/jvm.lux b/source/lux/host/jvm.lux
index 7a564826c..eddedfdc5 100644
--- a/source/lux/host/jvm.lux
+++ b/source/lux/host/jvm.lux
@@ -247,4 +247,4 @@
 (defsyntax #export (try$ expr)
   (emit (@list (` (try (#;Right (~ expr))
                     (~ (' (catch java.lang.Exception e
-                            (#;Left (.! (getMessage [] []) e))))))))))
+                            (#;Left (_jvm_invokevirtual "java.lang.Throwable" "getMessage" [] e []))))))))))
diff --git a/source/lux/meta/lux.lux b/source/lux/meta/lux.lux
index df3ebae48..dd14e708d 100644
--- a/source/lux/meta/lux.lux
+++ b/source/lux/meta/lux.lux
@@ -247,26 +247,25 @@
     (#;Some y) (#;Some y)))
 
 (def (find-in-env name state)
-  (-> Ident Compiler (Maybe Type))
-  (let [vname' (ident->text name)]
-    (case state
-      {#;source source #;modules modules
-       #;envs   envs   #;type-vars   types             #;host  host
-       #;seed   seed   #;eval? eval? #;expected expected
-       #;cursor cursor}
-      (some (: (-> (Env Text (, LuxVar Type)) (Maybe Type))
-               (lambda [env]
-                 (case env
-                   {#;name _ #;inner-closures _ #;locals {#;counter _ #;mappings locals} #;closure {#;counter _ #;mappings closure}}
-                   (try-both (some (: (-> (, Text (, LuxVar Type)) (Maybe Type))
-                                      (lambda [binding]
-                                        (let [[bname [_ type]] binding]
-                                          (if (text:= vname' bname)
-                                            (#;Some type)
-                                            #;None)))))
-                             locals
-                             closure))))
-            envs))))
+  (-> Text Compiler (Maybe Type))
+  (case state
+    {#;source source #;modules modules
+     #;envs   envs   #;type-vars   types             #;host  host
+     #;seed   seed   #;eval? eval? #;expected expected
+     #;cursor cursor}
+    (some (: (-> (Env Text (, LuxVar Type)) (Maybe Type))
+             (lambda [env]
+               (case env
+                 {#;name _ #;inner-closures _ #;locals {#;counter _ #;mappings locals} #;closure {#;counter _ #;mappings closure}}
+                 (try-both (some (: (-> (, Text (, LuxVar Type)) (Maybe Type))
+                                    (lambda [binding]
+                                      (let [[bname [_ type]] binding]
+                                        (if (text:= name bname)
+                                          (#;Some type)
+                                          #;None)))))
+                           locals
+                           closure))))
+          envs)))
 
 (def (find-in-defs name state)
   (-> Ident Compiler (Maybe Type))
@@ -294,10 +293,11 @@
 (def #export (find-var-type name)
   (-> Ident (Lux Type))
   (do Lux/Monad
-    [name' (normalize name)]
+    [#let [[_ _name] name]
+     name' (normalize name)]
     (: (Lux Type)
        (lambda [state]
-         (case (find-in-env name state)
+         (case (find-in-env _name state)
            (#;Some struct-type)
            (#;Right [state struct-type])
 
diff --git a/source/program.lux b/source/program.lux
index 1b6c6f398..69b9e811d 100644
--- a/source/program.lux
+++ b/source/program.lux
@@ -19,32 +19,38 @@
                     (either #as e)
                     id
                     io
-                    (list #refer #all #open ("list:" List/Functor))
+                    list
                     maybe
-                    (number (int #refer #all #open ("" Int/Show))
-                            real)
+                    (number (int #refer (#only))
+                            (real #refer (#only)))
                     (text #refer (#only <>) #open ("text:" Text/Monoid))
-                    writer
-                    tuple
+                    (writer #refer (#only))
+                    (tuple #refer (#only))
                     )
               (codata (stream #as s)
-                      lazy
-                      function
+                      (lazy #refer (#only))
+                      (function #refer (#only))
                       (reader #as r)
-                      state)
-              (host jvm)
+                      (state #refer (#only)))
+              (host jvm
+                    io)
               (meta ast
                     lux
                     macro
-                    syntax)
+                    syntax
+                    type)
               math
               ))
 
 (program args
   (case args
     (\ (@list name))
-    (println (<> "Hello, #{name}!"))
+    (write-line (<> "Hello, #{name}!"))
 
     _
-    (println "Hello, world!")
+    (do IO/Monad
+      [_ (write "Please, tell me your name: ")
+       name' read-line
+       #let [name (? "???" name')]]
+      (write-line (<> "Hello, #{name}!")))
     ))