From 8e6c5fc029178674275758f7c68425b13a473208 Mon Sep 17 00:00:00 2001
From: Eduardo Julian
Date: Mon, 4 Sep 2017 20:01:01 -0400
Subject: - Renamed "Log" to "Writer".

---
 stdlib/source/lux/control/writer.lux | 59 ++++++++++++++++++++++++++++++++++++
 stdlib/source/lux/data/log.lux       | 59 ------------------------------------
 2 files changed, 59 insertions(+), 59 deletions(-)
 create mode 100644 stdlib/source/lux/control/writer.lux
 delete mode 100644 stdlib/source/lux/data/log.lux

(limited to 'stdlib/source')

diff --git a/stdlib/source/lux/control/writer.lux b/stdlib/source/lux/control/writer.lux
new file mode 100644
index 000000000..6a82df77c
--- /dev/null
+++ b/stdlib/source/lux/control/writer.lux
@@ -0,0 +1,59 @@
+(;module:
+  lux
+  (lux/control monoid
+               ["A" applicative #*]
+               functor
+               [monad #+ do Monad]))
+
+(type: #export (Writer l a)
+  {#;doc "Represents a value with an associated 'log' value to record arbitrary information."}
+  {#log l
+   #value a})
+
+(struct: #export Functor<Writer> (All [l]
+                                   (Functor (Writer l)))
+  (def: (map f fa)
+    (let [[log datum] fa]
+      [log (f datum)])))
+
+(struct: #export (Applicative<Writer> mon) (All [l]
+                                             (-> (Monoid l) (Applicative (Writer l))))
+  (def: functor Functor<Writer>)
+
+  (def: (wrap x)
+    [(:: mon unit) x])
+
+  (def: (apply ff fa)
+    (let [[log1 f] ff
+          [log2 a] fa]
+      [(:: mon append log1 log2) (f a)])))
+
+(struct: #export (Monad<Writer> mon) (All [l]
+                                       (-> (Monoid l) (Monad (Writer l))))
+  (def: applicative (Applicative<Writer> mon))
+
+  (def: (join mma)
+    (let [[log1 [log2 a]] mma]
+      [(:: mon append log1 log2) a])))
+
+(def: #export (log l)
+  {#;doc "Set the log to a particular value."}
+  (All [l] (-> l (Writer l Unit)))
+  [l []])
+
+(struct: #export (WriterT Monoid<l> Monad<M>)
+  (All [l M] (-> (Monoid l) (Monad M) (Monad (All [a] (M (Writer l a))))))
+  (def: applicative (A;compA (get@ #monad;applicative Monad<M>) (Applicative<Writer> Monoid<l>)))
+  (def: (join MlMla)
+    (do Monad<M>
+      [[l1 Mla] (: (($ +1) (Writer ($ +0) (($ +1) (Writer ($ +0) ($ +2)))))
+                   MlMla)
+       [l2 a] Mla]
+      (wrap [(:: Monoid<l> append l1 l2) a]))))
+
+(def: #export (lift Monoid<l> Monad<M>)
+  (All [l M a] (-> (Monoid l) (Monad M) (-> (M a) (M (Writer l a)))))
+  (function [ma]
+    (do Monad<M>
+      [a ma]
+      (wrap [(:: Monoid<l> unit) a]))))
diff --git a/stdlib/source/lux/data/log.lux b/stdlib/source/lux/data/log.lux
deleted file mode 100644
index 19753199f..000000000
--- a/stdlib/source/lux/data/log.lux
+++ /dev/null
@@ -1,59 +0,0 @@
-(;module:
-  lux
-  (lux/control monoid
-               ["A" applicative #*]
-               functor
-               [monad #+ do Monad]))
-
-(type: #export (Log l a)
-  {#;doc "Represents a value with an associated 'log' value to record arbitrary information."}
-  {#log l
-   #value a})
-
-(struct: #export Functor<Log> (All [l]
-                                (Functor (Log l)))
-  (def: (map f fa)
-    (let [[log datum] fa]
-      [log (f datum)])))
-
-(struct: #export (Applicative<Log> mon) (All [l]
-                                          (-> (Monoid l) (Applicative (Log l))))
-  (def: functor Functor<Log>)
-
-  (def: (wrap x)
-    [(:: mon unit) x])
-
-  (def: (apply ff fa)
-    (let [[log1 f] ff
-          [log2 a] fa]
-      [(:: mon append log1 log2) (f a)])))
-
-(struct: #export (Monad<Log> mon) (All [l]
-                                    (-> (Monoid l) (Monad (Log l))))
-  (def: applicative (Applicative<Log> mon))
-
-  (def: (join mma)
-    (let [[log1 [log2 a]] mma]
-      [(:: mon append log1 log2) a])))
-
-(def: #export (log l)
-  {#;doc "Set the log to a particular value."}
-  (All [l] (-> l (Log l Unit)))
-  [l []])
-
-(struct: #export (LogT Monoid<l> Monad<M>)
-  (All [l M] (-> (Monoid l) (Monad M) (Monad (All [a] (M (Log l a))))))
-  (def: applicative (A;compA (get@ #monad;applicative Monad<M>) (Applicative<Log> Monoid<l>)))
-  (def: (join MlMla)
-    (do Monad<M>
-      [[l1 Mla] (: (($ +1) (Log ($ +0) (($ +1) (Log ($ +0) ($ +2)))))
-                   MlMla)
-       [l2 a] Mla]
-      (wrap [(:: Monoid<l> append l1 l2) a]))))
-
-(def: #export (lift Monoid<l> Monad<M>)
-  (All [l M a] (-> (Monoid l) (Monad M) (-> (M a) (M (Log l a)))))
-  (function [ma]
-    (do Monad<M>
-      [a ma]
-      (wrap [(:: Monoid<l> unit) a]))))
-- 
cgit v1.2.3