1 files changed, 17 insertions, 17 deletions

diff --git a/stdlib/source/lux/control/writer.lux b/stdlib/source/lux/control/writer.lux
index 4007cb6cb..152bc9e71 100644
--- a/stdlib/source/lux/control/writer.lux
+++ b/stdlib/source/lux/control/writer.lux
@@ -2,39 +2,39 @@
   [lux #*
    [control
     monoid
-    ["F" functor]
-    ["A" apply]
-    ["." monad (#+ do Monad)]]])
+    [functor (#+ Functor)]
+    [apply (#+ Apply)]
+    ["." monad (#+ Monad do)]]])
 
 (type: #export (Writer l a)
   {#.doc "Represents a value with an associated 'log' value to record arbitrary information."}
   {#log l
    #value a})
 
-(structure: #export Functor<Writer>
+(structure: #export functor
   (All [l]
-    (F.Functor (Writer l)))
+    (Functor (Writer l)))
   
   (def: (map f fa)
     (let [[log datum] fa]
       [log (f datum)])))
 
-(structure: #export (Apply<Writer> mon)
+(structure: #export (apply mon)
   (All [l]
-    (-> (Monoid l) (A.Apply (Writer l))))
+    (-> (Monoid l) (Apply (Writer l))))
   
-  (def: functor Functor<Writer>)
+  (def: &functor ..functor)
 
   (def: (apply ff fa)
     (let [[log1 f] ff
           [log2 a] fa]
       [(:: mon compose log1 log2) (f a)])))
 
-(structure: #export (Monad<Writer> mon)
+(structure: #export (monad mon)
   (All [l]
     (-> (Monoid l) (Monad (Writer l))))
   
-  (def: functor Functor<Writer>)
+  (def: &functor ..functor)
 
   (def: (wrap x)
     [(:: mon identity) x])
@@ -48,17 +48,17 @@
   (All [l] (-> l (Writer l Any)))
   [l []])
 
-(structure: #export (WriterT Monoid<l> Monad<M>)
+(structure: #export (with-writer Monoid<l> monad)
   (All [l M] (-> (Monoid l) (Monad M) (Monad (All [a] (M (Writer l a))))))
 
-  (def: functor (F.compose (get@ #monad.functor Monad<M>) Functor<Writer>))
+  (def: &functor (F.compose (get@ #monad.&functor monad) ..functor))
 
   (def: wrap
-    (let [monad (Monad<Writer> Monoid<l>)]
-      (|>> (:: monad wrap) (:: Monad<M> wrap))))
+    (let [monad (..monad Monoid<l>)]
+      (|>> (:: monad wrap) (:: monad wrap))))
   
   (def: (join MlMla)
-    (do Monad<M>
+    (do monad
       [## TODO: Remove once new-luxc is the standard compiler.
        [l1 Mla] (: (($ 1) (Writer ($ 0) (($ 1) (Writer ($ 0) ($ 2)))))
                    MlMla)
@@ -66,9 +66,9 @@
        [l2 a] Mla]
       (wrap [(:: Monoid<l> compose l1 l2) a]))))
 
-(def: #export (lift Monoid<l> Monad<M>)
+(def: #export (lift Monoid<l> monad)
   (All [l M a] (-> (Monoid l) (Monad M) (-> (M a) (M (Writer l a)))))
   (function (_ ma)
-    (do Monad<M>
+    (do monad
       [a ma]
       (wrap [(:: Monoid<l> identity) a]))))