Normalized the hierarchy of the standard library modules.

1 files changed, 72 insertions, 0 deletions

diff --git a/stdlib/source/library/lux/control/io.lux b/stdlib/source/library/lux/control/io.lux
new file mode 100644
index 000000000..a4773cd0d
--- /dev/null
+++ b/stdlib/source/library/lux/control/io.lux
@@ -0,0 +1,72 @@
+(.module: {#.doc "A method for abstracting I/O and effectful computations to make it safe while writing pure functional code."}
+  [library
+   [lux #*
+    [abstract
+     [functor (#+ Functor)]
+     [apply (#+ Apply)]
+     [monad (#+ Monad do)]]
+    [control
+     [parser
+      ["s" code]]]
+    [type
+     abstract]
+    [macro (#+ with_gensyms)
+     [syntax (#+ syntax:)]
+     ["." template]]]])
+
+(abstract: #export (IO a)
+  (-> Any a)
+
+  {#.doc "A type that represents synchronous, effectful computations that may interact with the outside world."}
+
+  (def: label
+    (All [a] (-> (-> Any a) (IO a)))
+    (|>> :abstraction))
+
+  (template: (!io computation)
+    (:abstraction (template.with_locals [g!func g!arg]
+                    (function (g!func g!arg)
+                      computation))))
+
+  (template: (!run io)
+    ## creatio ex nihilo
+    ((:representation io) []))
+
+  (syntax: #export (io computation)
+    {#.doc (doc "Delays the evaluation of an expression, by wrapping it in an IO 'thunk'."
+                "Great for wrapping effectful computations (which will not be performed until the IO is 'run')."
+                (io (exec
+                      (log! msg)
+                      "Some value...")))}
+    (with_gensyms [g!func g!arg]
+      (wrap (list (` ((~! ..label) (function ((~ g!func) (~ g!arg))
+                                     (~ computation))))))))
+
+  (def: #export run
+    {#.doc "A way to execute IO computations and perform their side-effects."}
+    (All [a] (-> (IO a) a))
+    (|>> !run))
+
+  (implementation: #export functor
+    (Functor IO)
+    
+    (def: (map f)
+      (|>> !run f !io)))
+
+  (implementation: #export apply
+    (Apply IO)
+    
+    (def: &functor ..functor)
+
+    (def: (apply ff fa)
+      (!io ((!run ff) (!run fa)))))
+
+  (implementation: #export monad
+    (Monad IO)
+    
+    (def: &functor ..functor)
+
+    (def: wrap (|>> !io))
+    
+    (def: join (|>> !run !run !io)))
+  )