- Re-named "struct:" to "structure:".

29 files changed, 100 insertions, 100 deletions

diff --git a/stdlib/source/lux/data/bool.lux b/stdlib/source/lux/data/bool.lux
index 88c1011e5..eee9de319 100644
--- a/stdlib/source/lux/data/bool.lux
+++ b/stdlib/source/lux/data/bool.lux
@@ -7,13 +7,13 @@
        function))
 
 ## [Structures]
-(struct: #export _ (Equivalence Bool)
+(structure: #export _ (Equivalence Bool)
   (def: (= x y)
     (if x
       y
       (not y))))
 
-(struct: #export _ (Hash Bool)
+(structure: #export _ (Hash Bool)
   (def: eq Equivalence<Bool>)
   (def: (hash value)
     (case value
@@ -21,7 +21,7 @@
       false +0)))
 
 (do-template [<name> <identity> <op>]
-  [(struct: #export <name> (Monoid Bool)
+  [(structure: #export <name> (Monoid Bool)
      (def: identity <identity>)
      (def: (compose x y)
        (<op> x y)))]
@@ -30,7 +30,7 @@
   [And@Monoid<Bool> true and]
   )
 
-(struct: #export _ (Codec Text Bool)
+(structure: #export _ (Codec Text Bool)
   (def: (encode x)
     (if x
       "true"
diff --git a/stdlib/source/lux/data/coll/array.lux b/stdlib/source/lux/data/coll/array.lux
index 8f3bee0c3..842acec39 100644
--- a/stdlib/source/lux/data/coll/array.lux
+++ b/stdlib/source/lux/data/coll/array.lux
@@ -149,7 +149,7 @@
                #.None
                output)))))
 
-(struct: #export (Equivalence<Array> Equivalence<a>)
+(structure: #export (Equivalence<Array> Equivalence<a>)
   (All [a] (-> (Equivalence a) (Equivalence (Array a))))
   (def: (= xs ys)
     (let [sxs (size xs)
@@ -170,7 +170,7 @@
                       (list.n/range +0 (dec sxs)))))
     ))
 
-(struct: #export Monoid<Array> (All [a] (Monoid (Array a)))
+(structure: #export Monoid<Array> (All [a] (Monoid (Array a)))
   (def: identity (new +0))
 
   (def: (compose xs ys)
@@ -180,7 +180,7 @@
           (copy sxs +0 xs +0)
           (copy sxy +0 ys sxs)))))
 
-(struct: #export _ (Functor Array)
+(structure: #export _ (Functor Array)
   (def: (map f ma)
     (let [arr-size (size ma)]
       (if (n/= +0 arr-size)
@@ -196,7 +196,7 @@
                    (list.n/range +0 (dec arr-size)))
         ))))
 
-(struct: #export _ (Fold Array)
+(structure: #export _ (Fold Array)
   (def: (fold f init xs)
     (let [arr-size (size xs)]
       (loop [so-far init
diff --git a/stdlib/source/lux/data/coll/bits.lux b/stdlib/source/lux/data/coll/bits.lux
index 94d3398a0..426f830d2 100644
--- a/stdlib/source/lux/data/coll/bits.lux
+++ b/stdlib/source/lux/data/coll/bits.lux
@@ -151,7 +151,7 @@
   [xor bit.xor]
   )
 
-(struct: #export _ (Equivalence Bits)
+(structure: #export _ (Equivalence Bits)
   (def: (= reference sample)
     (let [size (n/max (array.size reference)
                       (array.size sample))]
diff --git a/stdlib/source/lux/data/coll/dictionary/ordered.lux b/stdlib/source/lux/data/coll/dictionary/ordered.lux
index 6fbcb5a42..5c616fa0b 100644
--- a/stdlib/source/lux/data/coll/dictionary/ordered.lux
+++ b/stdlib/source/lux/data/coll/dictionary/ordered.lux
@@ -551,7 +551,7 @@
   [values  v     (get@ #value node')]
   )
 
-(struct: #export (Equivalence<Dict> Equivalence<v>) (All [k v] (-> (Equivalence v) (Equivalence (Dict k v))))
+(structure: #export (Equivalence<Dict> Equivalence<v>) (All [k v] (-> (Equivalence v) (Equivalence (Dict k v))))
   (def: (= reference sample)
     (let [Equivalence<k> (:: sample eq)]
       (loop [entriesR (entries reference)
diff --git a/stdlib/source/lux/data/coll/dictionary/unordered.lux b/stdlib/source/lux/data/coll/dictionary/unordered.lux
index bb6d12b24..61d21b425 100644
--- a/stdlib/source/lux/data/coll/dictionary/unordered.lux
+++ b/stdlib/source/lux/data/coll/dictionary/unordered.lux
@@ -671,7 +671,7 @@
                keys)))
 
 ## [Structures]
-(struct: #export (Equivalence<Dict> Equivalence<v>) (All [k v] (-> (Equivalence v) (Equivalence (Dict k v))))
+(structure: #export (Equivalence<Dict> Equivalence<v>) (All [k v] (-> (Equivalence v) (Equivalence (Dict k v))))
   (def: (= test subject)
     (and (n/= (size test)
               (size subject))
diff --git a/stdlib/source/lux/data/coll/list.lux b/stdlib/source/lux/data/coll/list.lux
index 4049fce8e..74ef2e5cc 100644
--- a/stdlib/source/lux/data/coll/list.lux
+++ b/stdlib/source/lux/data/coll/list.lux
@@ -16,7 +16,7 @@
 ##   (#Cons a (List a)))
 
 ## [Functions]
-(struct: #export _ (fold.Fold List)
+(structure: #export _ (fold.Fold List)
   (def: (fold f init xs)
     (case xs
       #.Nil
@@ -265,7 +265,7 @@
       (nth (dec i) xs'))))
 
 ## [Structures]
-(struct: #export (Equivalence<List> Equivalence<a>)
+(structure: #export (Equivalence<List> Equivalence<a>)
   (All [a] (-> (Equivalence a) (Equivalence (List a))))
   (def: (= xs ys)
     (case [xs ys]
@@ -280,7 +280,7 @@
       false
       )))
 
-(struct: #export Monoid<List> (All [a]
+(structure: #export Monoid<List> (All [a]
                                 (Monoid (List a)))
   (def: identity #.Nil)
   (def: (compose xs ys)
@@ -290,7 +290,7 @@
 
 (open: Monoid<List>)
 
-(struct: #export _ (Functor List)
+(structure: #export _ (Functor List)
   (def: (map f ma)
     (case ma
       #.Nil          #.Nil
@@ -298,7 +298,7 @@
 
 (open: Functor<List>)
 
-(struct: #export _ (Apply List)
+(structure: #export _ (Apply List)
   (def: functor Functor<List>)
 
   (def: (apply ff fa)
@@ -309,7 +309,7 @@
       (#.Cons f ff')
       (compose (map f fa) (apply ff' fa)))))
 
-(struct: #export _ (Monad List)
+(structure: #export _ (Monad List)
   (def: functor Functor<List>)
 
   (def: (wrap a)
@@ -511,7 +511,7 @@
   (All [a] (-> (List (List a)) (List a)))
   (:: Monad<List> join xss))
 
-(struct: #export (ListT Monad<M>)
+(structure: #export (ListT Monad<M>)
   (All [M] (-> (Monad M) (Monad (All [a] (M (List a))))))
 
   (def: functor (functor.compose (get@ #monad.functor Monad<M>) Functor<List>))
diff --git a/stdlib/source/lux/data/coll/queue.lux b/stdlib/source/lux/data/coll/queue.lux
index 490351d29..3b144a52a 100644
--- a/stdlib/source/lux/data/coll/queue.lux
+++ b/stdlib/source/lux/data/coll/queue.lux
@@ -67,12 +67,12 @@
     _
     (update@ #rear (|>> (#.Cons val)) queue)))
 
-(struct: #export (Equivalence<Queue> Equivalence<a>)
+(structure: #export (Equivalence<Queue> Equivalence<a>)
   (All [a] (-> (Equivalence a) (Equivalence (Queue a))))
   (def: (= qx qy)
     (:: (list.Equivalence<List> Equivalence<a>) = (to-list qx) (to-list qy))))
 
-(struct: #export _ (F.Functor Queue)
+(structure: #export _ (F.Functor Queue)
   (def: (map f fa)
     {#front (|> fa (get@ #front) (L/map f))
      #rear (|> fa (get@ #rear) (L/map f))}))
diff --git a/stdlib/source/lux/data/coll/row.lux b/stdlib/source/lux/data/coll/row.lux
index 2c50120ec..1d4dc648c 100644
--- a/stdlib/source/lux/data/coll/row.lux
+++ b/stdlib/source/lux/data/coll/row.lux
@@ -343,7 +343,7 @@
   (wrap (list (` (from-list (list (~+ elems)))))))
 
 ## [Structures]
-(struct: #export (Equivalence<Node> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Node a))))
+(structure: #export (Equivalence<Node> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Node a))))
   (def: (= v1 v2)
     (case [v1 v2]
       [(#Base b1) (#Base b2)]
@@ -355,7 +355,7 @@
       _
       false)))
 
-(struct: #export (Equivalence<Row> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Row a))))
+(structure: #export (Equivalence<Row> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Row a))))
   (def: (= v1 v2)
     (and (n/= (get@ #size v1) (get@ #size v2))
          (let [(^open "Node/") (Equivalence<Node> Equivalence<a>)]
@@ -364,7 +364,7 @@
                 (Node/= (#Hierarchy (get@ #root v1))
                         (#Hierarchy (get@ #root v2))))))))
 
-(struct: _ (Fold Node)
+(structure: _ (Fold Node)
   (def: (fold f init xs)
     (case xs
       (#Base base)
@@ -376,7 +376,7 @@
                   hierarchy))
     ))
 
-(struct: #export _ (Fold Row)
+(structure: #export _ (Fold Row)
   (def: (fold f init xs)
     (let [(^open) Fold<Node>]
       (fold f
@@ -386,12 +386,12 @@
             (#Base (get@ #tail xs))))
     ))
 
-(struct: #export Monoid<Row> (All [a] (Monoid (Row a)))
+(structure: #export Monoid<Row> (All [a] (Monoid (Row a)))
   (def: identity empty)
   (def: (compose xs ys)
     (list/fold add xs (to-list ys))))
 
-(struct: _ (Functor Node)
+(structure: _ (Functor Node)
   (def: (map f xs)
     (case xs
       (#Base base)
@@ -401,7 +401,7 @@
       (#Hierarchy (array/map (map f) hierarchy)))
     ))
 
-(struct: #export _ (Functor Row)
+(structure: #export _ (Functor Row)
   (def: (map f xs)
     {#level (get@ #level xs)
      #size (get@ #size xs)
@@ -409,7 +409,7 @@
      #tail (|> xs (get@ #tail) (array/map f))
      }))
 
-(struct: #export _ (Apply Row)
+(structure: #export _ (Apply Row)
   (def: functor Functor<Row>)
 
   (def: (apply ff fa)
@@ -420,7 +420,7 @@
                        ff)]
       (fold compose identity results))))
 
-(struct: #export _ (Monad Row)
+(structure: #export _ (Monad Row)
   (def: functor Functor<Row>)
 
   (def: wrap (|>> row))
diff --git a/stdlib/source/lux/data/coll/sequence.lux b/stdlib/source/lux/data/coll/sequence.lux
index b8908403b..ab8f1d625 100644
--- a/stdlib/source/lux/data/coll/sequence.lux
+++ b/stdlib/source/lux/data/coll/sequence.lux
@@ -117,12 +117,12 @@
   [(filter p xs) (filter (complement p) xs)])
 
 ## [Structures]
-(struct: #export _ (Functor Sequence)
+(structure: #export _ (Functor Sequence)
   (def: (map f fa)
     (let [[h t] (continuation.run fa)]
       (pending [(f h) (map f t)]))))
 
-(struct: #export _ (CoMonad Sequence)
+(structure: #export _ (CoMonad Sequence)
   (def: functor Functor<Sequence>)
   (def: unwrap head)
   (def: (split wa)
diff --git a/stdlib/source/lux/data/coll/set/ordered.lux b/stdlib/source/lux/data/coll/set/ordered.lux
index 0862d62c2..45a6b0cb0 100644
--- a/stdlib/source/lux/data/coll/set/ordered.lux
+++ b/stdlib/source/lux/data/coll/set/ordered.lux
@@ -80,7 +80,7 @@
   (All [a] (-> (Set a) (Set a) Bool))
   (sub? super sub))
 
-(struct: #export Equivalence<Set> (All [a] (Equivalence (Set a)))
+(structure: #export Equivalence<Set> (All [a] (Equivalence (Set a)))
   (def: (= reference sample)
     (:: (list.Equivalence<List> (:: sample eq))
         = (to-list reference) (to-list sample))))
diff --git a/stdlib/source/lux/data/coll/set/unordered.lux b/stdlib/source/lux/data/coll/set/unordered.lux
index 4fcc0c1cc..6f0007412 100644
--- a/stdlib/source/lux/data/coll/set/unordered.lux
+++ b/stdlib/source/lux/data/coll/set/unordered.lux
@@ -63,11 +63,11 @@
   (sub? super sub))
 
 ## [Structures]
-(struct: #export Equivalence<Set> (All [a] (Equivalence (Set a)))
+(structure: #export Equivalence<Set> (All [a] (Equivalence (Set a)))
   (def: (= (^@ test [Hash<a> _]) subject)
     (:: (list.Equivalence<List> (get@ #hash.eq Hash<a>)) = (to-list test) (to-list subject))))
 
-(struct: #export Hash<Set> (All [a] (Hash (Set a)))
+(structure: #export Hash<Set> (All [a] (Hash (Set a)))
   (def: eq Equivalence<Set>)
   
   (def: (hash (^@ set [Hash<a> _]))
diff --git a/stdlib/source/lux/data/coll/tree/rose.lux b/stdlib/source/lux/data/coll/tree/rose.lux
index 8171dcdaa..1fb5fc85a 100644
--- a/stdlib/source/lux/data/coll/tree/rose.lux
+++ b/stdlib/source/lux/data/coll/tree/rose.lux
@@ -54,18 +54,18 @@
                           #children (list (~+ (L/map recur children)))})))))))
 
 ## [Structs]
-(struct: #export (Equivalence<Tree> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Tree a))))
+(structure: #export (Equivalence<Tree> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Tree a))))
   (def: (= tx ty)
     (and (:: Equivalence<a> = (get@ #value tx) (get@ #value ty))
          (:: (list.Equivalence<List> (Equivalence<Tree> Equivalence<a>)) = (get@ #children tx) (get@ #children ty)))))
 
-(struct: #export _ (Functor Tree)
+(structure: #export _ (Functor Tree)
   (def: (map f fa)
     {#value (f (get@ #value fa))
      #children (L/map (map f)
                       (get@ #children fa))}))
 
-(struct: #export _ (Fold Tree)
+(structure: #export _ (Fold Tree)
   (def: (fold f init tree)
     (L/fold (function (_ tree' init') (fold f init' tree'))
             (f (get@ #value tree)
diff --git a/stdlib/source/lux/data/coll/tree/rose/zipper.lux b/stdlib/source/lux/data/coll/tree/rose/zipper.lux
index 845dd4c4c..ba47b9f0a 100644
--- a/stdlib/source/lux/data/coll/tree/rose/zipper.lux
+++ b/stdlib/source/lux/data/coll/tree/rose/zipper.lux
@@ -211,7 +211,7 @@
   [insert-right #rights]
   )
 
-(struct: #export _ (Functor Zipper)
+(structure: #export _ (Functor Zipper)
   (def: (map f fa)
     {#parent (|> fa (get@ #parent) (M/map (map f)))
      #lefts (|> fa (get@ #lefts) (L/map (T/map f)))
@@ -219,7 +219,7 @@
      #node (T/map f (get@ #node fa))}))
 
 ## TODO: Add again once new-luxc becomes the standard compiler.
-## (struct: #export _ (CoMonad Zipper)
+## (structure: #export _ (CoMonad Zipper)
 ##   (def: functor Functor<Zipper>)
 
 ##   (def: unwrap (get@ [#node #rose.value]))
diff --git a/stdlib/source/lux/data/color.lux b/stdlib/source/lux/data/color.lux
index 67c9c3388..7a23be703 100644
--- a/stdlib/source/lux/data/color.lux
+++ b/stdlib/source/lux/data/color.lux
@@ -33,7 +33,7 @@
     (-> Color [Nat Nat Nat])
     (|>> :representation))
 
-  (struct: #export _ (eq.Equivalence Color)
+  (structure: #export _ (eq.Equivalence Color)
     (def: (= reference sample)
       (let [[rr rg rb] (:representation reference)
             [sr sg sb] (:representation sample)]
diff --git a/stdlib/source/lux/data/env.lux b/stdlib/source/lux/data/env.lux
index 880bfa621..68d0affc0 100644
--- a/stdlib/source/lux/data/env.lux
+++ b/stdlib/source/lux/data/env.lux
@@ -7,11 +7,11 @@
   {#env e
    #value a})
 
-(struct: #export Functor<Env> (All [e] (F.Functor (Env e)))
+(structure: #export Functor<Env> (All [e] (F.Functor (Env e)))
   (def: (map f fa)
     (update@ #value f fa)))
 
-(struct: #export CoMonad<Env> (All [e] (CoMonad (Env e)))
+(structure: #export CoMonad<Env> (All [e] (CoMonad (Env e)))
   (def: functor Functor<Env>)
 
   (def: unwrap (get@ #value))
diff --git a/stdlib/source/lux/data/error.lux b/stdlib/source/lux/data/error.lux
index 5e7f07601..6e9f12cb0 100644
--- a/stdlib/source/lux/data/error.lux
+++ b/stdlib/source/lux/data/error.lux
@@ -10,13 +10,13 @@
   (#Success a))
 
 ## [Structures]
-(struct: #export _ (F.Functor Error)
+(structure: #export _ (F.Functor Error)
   (def: (map f ma)
     (case ma
       (#Error msg)     (#Error msg)
       (#Success datum) (#Success (f datum)))))
 
-(struct: #export _ (A.Apply Error)
+(structure: #export _ (A.Apply Error)
   (def: functor Functor<Error>)
 
   (def: (apply ff fa)
@@ -33,7 +33,7 @@
       (#Error msg))
     ))
 
-(struct: #export _ (Monad Error)
+(structure: #export _ (Monad Error)
   (def: functor Functor<Error>)
 
   (def: (wrap a)
@@ -44,7 +44,7 @@
       (#Error msg) (#Error msg)
       (#Success ma) ma)))
 
-(struct: #export (ErrorT Monad<M>)
+(structure: #export (ErrorT Monad<M>)
   (All [M] (-> (Monad M) (Monad (All [a] (M (Error a))))))
   
   (def: functor (F.compose (get@ #M.functor Monad<M>) Functor<Error>))
diff --git a/stdlib/source/lux/data/format/json.lux b/stdlib/source/lux/data/format/json.lux
index 984fbb1aa..01652968f 100644
--- a/stdlib/source/lux/data/format/json.lux
+++ b/stdlib/source/lux/data/format/json.lux
@@ -147,7 +147,7 @@
   [get-object  #Object  Object  "objects"]
   )
 
-(struct: #export _ (Equivalence JSON)
+(structure: #export _ (Equivalence JSON)
   (def: (= x y)
     (case [x y]
       [#Null #Null]
@@ -495,6 +495,6 @@
   (-> Any (l.Lexer JSON))
   ($_ p.alt null~ boolean~ number~ string~ (array~ json~') (object~ json~')))
 
-(struct: #export _ (Codec Text JSON)
+(structure: #export _ (Codec Text JSON)
   (def: encode show-json)
   (def: decode (function (_ input) (l.run input (json~' [])))))
diff --git a/stdlib/source/lux/data/format/xml.lux b/stdlib/source/lux/data/format/xml.lux
index 7d1614fca..ddfb06249 100644
--- a/stdlib/source/lux/data/format/xml.lux
+++ b/stdlib/source/lux/data/format/xml.lux
@@ -220,11 +220,11 @@
                       (text.join-with ""))
                   "</" tag ">")))))))
 
-(struct: #export _ (Codec Text XML)
+(structure: #export _ (Codec Text XML)
   (def: encode write)
   (def: decode read))
 
-(struct: #export _ (Equivalence XML)
+(structure: #export _ (Equivalence XML)
   (def: (= reference sample)
     (case [reference sample]
       [(#Text reference/value) (#Text sample/value)]
diff --git a/stdlib/source/lux/data/ident.lux b/stdlib/source/lux/data/ident.lux
index cb0b35b1f..f75b89ab8 100644
--- a/stdlib/source/lux/data/ident.lux
+++ b/stdlib/source/lux/data/ident.lux
@@ -20,12 +20,12 @@
   )
 
 ## [Structures]
-(struct: #export _ (Equivalence Ident)
+(structure: #export _ (Equivalence Ident)
   (def: (= [xmodule xname] [ymodule yname])
     (and (text/= xmodule ymodule)
          (text/= xname yname))))
 
-(struct: #export _ (Codec Text Ident)
+(structure: #export _ (Codec Text Ident)
   (def: (encode [module name])
     (case module
       "" name
@@ -44,7 +44,7 @@
         _
         (#.Left (text/compose "Invalid format for Ident: " input))))))
 
-(struct: #export _ (Hash Ident)
+(structure: #export _ (Hash Ident)
   (def: eq Equivalence<Ident>)
   
   (def: (hash [module name])
diff --git a/stdlib/source/lux/data/identity.lux b/stdlib/source/lux/data/identity.lux
index b14658619..969b89e4d 100644
--- a/stdlib/source/lux/data/identity.lux
+++ b/stdlib/source/lux/data/identity.lux
@@ -10,20 +10,20 @@
   a)
 
 ## [Structures]
-(struct: #export _ (F.Functor Identity)
+(structure: #export _ (F.Functor Identity)
   (def: map id))
 
-(struct: #export _ (A.Apply Identity)
+(structure: #export _ (A.Apply Identity)
   (def: functor Functor<Identity>)
   (def: (apply ff fa)
     (ff fa)))
 
-(struct: #export _ (Monad Identity)
+(structure: #export _ (Monad Identity)
   (def: functor Functor<Identity>)
   (def: wrap id)
   (def: join id))
 
-(struct: #export _ (CoMonad Identity)
+(structure: #export _ (CoMonad Identity)
   (def: functor Functor<Identity>)
   (def: unwrap id)
   (def: split id))
diff --git a/stdlib/source/lux/data/lazy.lux b/stdlib/source/lux/data/lazy.lux
index 94932a497..5a7228935 100644
--- a/stdlib/source/lux/data/lazy.lux
+++ b/stdlib/source/lux/data/lazy.lux
@@ -33,16 +33,16 @@
   (with-gensyms [g!_]
     (wrap (list (` ((~! freeze') (function ((~ g!_) (~ g!_)) (~ expr))))))))
 
-(struct: #export _ (Functor Lazy)
+(structure: #export _ (Functor Lazy)
   (def: (map f fa)
     (freeze (f (thaw fa)))))
 
-(struct: #export _ (Apply Lazy)
+(structure: #export _ (Apply Lazy)
   (def: functor Functor<Lazy>)
   (def: (apply ff fa)
     (freeze ((thaw ff) (thaw fa)))))
 
-(struct: #export _ (Monad Lazy)
+(structure: #export _ (Monad Lazy)
   (def: functor Functor<Lazy>)
   (def: wrap (|>> freeze))
   (def: join thaw))
diff --git a/stdlib/source/lux/data/maybe.lux b/stdlib/source/lux/data/maybe.lux
index bfdb0fbe5..dfc2a557b 100644
--- a/stdlib/source/lux/data/maybe.lux
+++ b/stdlib/source/lux/data/maybe.lux
@@ -12,20 +12,20 @@
 ##   (#.Some a))
 
 ## [Structures]
-(struct: #export Monoid<Maybe> (All [a] (m.Monoid (Maybe a)))
+(structure: #export Monoid<Maybe> (All [a] (m.Monoid (Maybe a)))
   (def: identity #.None)
   (def: (compose xs ys)
     (case xs
       #.None     ys
       (#.Some x) (#.Some x))))
 
-(struct: #export _ (F.Functor Maybe)
+(structure: #export _ (F.Functor Maybe)
   (def: (map f ma)
     (case ma
       #.None     #.None
       (#.Some a) (#.Some (f a)))))
 
-(struct: #export _ (A.Apply Maybe)
+(structure: #export _ (A.Apply Maybe)
   (def: functor Functor<Maybe>)
 
   (def: (apply ff fa)
@@ -36,7 +36,7 @@
       _
       #.None)))
 
-(struct: #export _ (Monad Maybe)
+(structure: #export _ (Monad Maybe)
   (def: functor Functor<Maybe>)
 
   (def: (wrap x)
@@ -47,7 +47,7 @@
       #.None      #.None
       (#.Some xs) xs)))
 
-(struct: #export (Equivalence<Maybe> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Maybe a))))
+(structure: #export (Equivalence<Maybe> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Maybe a))))
   (def: (= mx my)
     (case [mx my]
       [#.None #.None]
@@ -59,7 +59,7 @@
       _
       false)))
 
-(struct: #export (MaybeT Monad<M>)
+(structure: #export (MaybeT Monad<M>)
   (All [M] (-> (Monad M) (Monad (All [a] (M (Maybe a))))))
 
   (def: functor (F.compose (get@ #monad.functor Monad<M>) Functor<Maybe>))
diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux
index 637d0d0ba..5a32e6ada 100644
--- a/stdlib/source/lux/data/number.lux
+++ b/stdlib/source/lux/data/number.lux
@@ -14,7 +14,7 @@
 
 ## [Structures]
 (do-template [<type> <test>]
-  [(struct: #export _ (Equivalence <type>)
+  [(structure: #export _ (Equivalence <type>)
      (def: = <test>))]
 
   [ Nat n/=]
@@ -24,7 +24,7 @@
   )
 
 (do-template [<type> <eq> <lt> <lte> <gt> <gte>]
-  [(struct: #export _ (order.Order <type>)
+  [(structure: #export _ (order.Order <type>)
      (def: eq <eq>)
      (def: < <lt>)
      (def: <= <lte>)
@@ -37,7 +37,7 @@
   [Frac Equivalence<Frac> f/< f/<= f/> f/>=]
   )
 
-(struct: #export _ (Number Nat)
+(structure: #export _ (Number Nat)
   (def: + n/+)
   (def: - n/-)
   (def: * n/*)
@@ -52,7 +52,7 @@
   )
 
 (do-template [<type> <order> <+> <-> <*> </> <%> <=> <<> <0> <1> <-1>]
-  [(struct: #export _ (Number <type>)
+  [(structure: #export _ (Number <type>)
      (def: + <+>)
      (def: - <->)
      (def: * <*>)
@@ -74,7 +74,7 @@
   [Frac Order<Frac> f/+ f/- f/* f// f/% f/= f/< 0.0 1.0 -1.0]
   )
 
-(struct: #export _ (Number Rev)
+(structure: #export _ (Number Rev)
   (def: + r/+)
   (def: - r/-)
   (def: * r/*)
@@ -86,7 +86,7 @@
     (:coerce Rev -1)))
 
 (do-template [<type> <order> <succ> <pred>]
-  [(struct: #export _ (Enum <type>)
+  [(structure: #export _ (Enum <type>)
      (def: order <order>)
      (def: succ <succ>)
      (def: pred <pred>))]
@@ -98,7 +98,7 @@
   )
 
 (do-template [<type> <enum> <top> <bottom>]
-  [(struct: #export _ (Interval <type>)
+  [(structure: #export _ (Interval <type>)
      (def: enum <enum>)
      (def: top <top>)
      (def: bottom <bottom>))]
@@ -110,7 +110,7 @@
   )
 
 (do-template [<name> <type> <identity> <compose>]
-  [(struct: #export <name> (Monoid <type>)
+  [(structure: #export <name> (Monoid <type>)
      (def: identity <identity>)
      (def: compose <compose>))]
 
@@ -155,7 +155,7 @@
            (f/= negative-infinity value))))
 
 (do-template [<type> <encoder> <decoder> <error>]
-  [(struct: #export _ (Codec Text <type>)
+  [(structure: #export _ (Codec Text <type>)
      (def: (encode x)
        (<encoder> [x]))
 
@@ -288,7 +288,7 @@
     _ #.None))
 
 (do-template [<struct> <base> <to-character> <to-value> <error>]
-  [(struct: #export <struct> (Codec Text Nat)
+  [(structure: #export <struct> (Codec Text Nat)
      (def: (encode value)
        (loop [input value
               output ""]
@@ -328,7 +328,7 @@
   )
 
 (do-template [<struct> <base> <to-character> <to-value> <error>]
-  [(struct: #export <struct> (Codec Text Int)
+  [(structure: #export <struct> (Codec Text Int)
      (def: (encode value)
        (if (i/= 0 value)
          "0"
@@ -379,7 +379,7 @@
   (maybe.assume ("lux text clip" input +1 ("lux text size" input))))
 
 (do-template [<struct> <nat> <char-bit-size> <error>]
-  [(struct: #export <struct> (Codec Text Rev)
+  [(structure: #export <struct> (Codec Text Rev)
      (def: (encode value)
        (let [raw-output (de-prefix (:: <nat> encode (:coerce Nat value)))
              max-num-chars (n// <char-bit-size> +64)
@@ -412,7 +412,7 @@
   )
 
 (do-template [<struct> <int> <base> <char-set> <error>]
-  [(struct: #export <struct> (Codec Text Frac)
+  [(structure: #export <struct> (Codec Text Frac)
      (def: (encode value)
        (let [whole (frac-to-int value)
              whole-part (:: <int> encode whole)
@@ -602,7 +602,7 @@
   )
 
 (do-template [<struct> <error> <from> <to>]
-  [(struct: #export <struct> (Codec Text Frac)
+  [(structure: #export <struct> (Codec Text Frac)
      (def: (encode value)
        (let [sign (:: Number<Frac> signum value)
              raw-bin (:: Binary@Codec<Text,Frac> encode value)
@@ -853,7 +853,7 @@
              (digits-sub-once! idx (digits-get idx param) output))
       output)))
 
-(struct: #export _ (Codec Text Rev)
+(structure: #export _ (Codec Text Rev)
   (def: (encode input)
     (let [input (:coerce Nat input)
           last-idx (dec bit.width)]
@@ -994,19 +994,19 @@
               (f/* -1.0 shifted))))))
 
 ## [Hash]
-(struct: #export _ (Hash Nat)
+(structure: #export _ (Hash Nat)
   (def: eq Equivalence<Nat>)
   (def: hash id))
 
-(struct: #export _ (Hash Int)
+(structure: #export _ (Hash Int)
   (def: eq Equivalence<Int>)
   (def: hash .nat))
 
-(struct: #export _ (Hash Frac)
+(structure: #export _ (Hash Frac)
   (def: eq Equivalence<Frac>)
   
   (def: hash frac-to-bits))
 
-(struct: #export _ (Hash Rev)
+(structure: #export _ (Hash Rev)
   (def: eq Equivalence<Rev>)
   (def: hash (|>> (:coerce Nat))))
diff --git a/stdlib/source/lux/data/number/complex.lux b/stdlib/source/lux/data/number/complex.lux
index a7e535f08..91a10fd59 100644
--- a/stdlib/source/lux/data/number/complex.lux
+++ b/stdlib/source/lux/data/number/complex.lux
@@ -56,7 +56,7 @@
   [- f/-]
   )
 
-(struct: #export _ (Equivalence Complex)
+(structure: #export _ (Equivalence Complex)
   (def: = ..=))
 
 (def: #export negate
@@ -187,7 +187,7 @@
                         (frac/abs real))))
                ))))
 
-(struct: #export _ (Number Complex)
+(structure: #export _ (Number Complex)
   (def: + ..+)
   (def: - ..-)
   (def: * ..*)
diff --git a/stdlib/source/lux/data/number/ratio.lux b/stdlib/source/lux/data/number/ratio.lux
index c96c66882..b23128348 100644
--- a/stdlib/source/lux/data/number/ratio.lux
+++ b/stdlib/source/lux/data/number/ratio.lux
@@ -100,17 +100,17 @@
   [max >]
   )
 
-(struct: #export _ (Equivalence Ratio)
+(structure: #export _ (Equivalence Ratio)
   (def: = ..=))
 
-(struct: #export _ (order.Order Ratio)
+(structure: #export _ (order.Order Ratio)
   (def: eq Equivalence<Ratio>)
   (def: < ..<)
   (def: <= ..<=)
   (def: > ..>)
   (def: >= ..>=))
 
-(struct: #export _ (Number Ratio)
+(structure: #export _ (Number Ratio)
   (def: + ..+)
   (def: - ..-)
   (def: * ..*)
@@ -134,7 +134,7 @@
   (-> Text (E.Error Nat))
   (|>> (format "+") nat/decode))
 
-(struct: #export _ (Codec Text Ratio)
+(structure: #export _ (Codec Text Ratio)
   (def: (encode (^slots [#numerator #denominator]))
     ($_ text/compose (part-encode numerator) separator (part-encode denominator)))
 
diff --git a/stdlib/source/lux/data/store.lux b/stdlib/source/lux/data/store.lux
index 06b1315a2..96e4988b3 100644
--- a/stdlib/source/lux/data/store.lux
+++ b/stdlib/source/lux/data/store.lux
@@ -13,13 +13,13 @@
   {#cursor (get@ #cursor wa)
    #peek (function (_ s) (f (set@ #cursor s wa)))})
 
-(struct: #export Functor<Store> (All [s] (F.Functor (Store s)))
+(structure: #export Functor<Store> (All [s] (F.Functor (Store s)))
   (def: (map f fa)
     (extend (function (_ store)
               (f (:: store peek (:: store cursor))))
             fa)))
 
-(struct: #export CoMonad<Store> (All [s] (CoMonad (Store s)))
+(structure: #export CoMonad<Store> (All [s] (CoMonad (Store s)))
   (def: functor Functor<Store>)
 
   (def: (unwrap wa) (::: peek (::: cursor)))
diff --git a/stdlib/source/lux/data/text.lux b/stdlib/source/lux/data/text.lux
index 04af675c4..d09b713c9 100644
--- a/stdlib/source/lux/data/text.lux
+++ b/stdlib/source/lux/data/text.lux
@@ -123,11 +123,11 @@
   (split-all-with "\n"))
 
 ## [Structures]
-(struct: #export _ (Equivalence Text)
+(structure: #export _ (Equivalence Text)
   (def: (= test subject)
     ("lux text =" subject test)))
 
-(struct: #export _ (order.Order Text)
+(structure: #export _ (order.Order Text)
   (def: eq Equivalence<Text>)
 
   (def: (< test subject)
@@ -145,7 +145,7 @@
         ("lux text =" test subject)))
   )
 
-(struct: #export _ (Monoid Text)
+(structure: #export _ (Monoid Text)
   (def: identity "")
   (def: (compose left right)
     ("lux text concat" left right)))
@@ -166,7 +166,7 @@
                     )]
     ($_ text/compose "\"" escaped "\"")))
 
-(struct: #export _ (Hash Text)
+(structure: #export _ (Hash Text)
   (def: eq Equivalence<Text>)
   
   (def: (hash input)
diff --git a/stdlib/source/lux/data/text/unicode.lux b/stdlib/source/lux/data/text/unicode.lux
index 6f76d053b..e00f23e84 100644
--- a/stdlib/source/lux/data/text/unicode.lux
+++ b/stdlib/source/lux/data/text/unicode.lux
@@ -15,7 +15,7 @@
 
   (def: empty (:abstraction (interval.between number.Enum<Nat> nat/top nat/bottom)))
 
-  (struct: _ (Monoid Segment)
+  (structure: _ (Monoid Segment)
     (def: identity ..empty)
     (def: (compose left right)
       (let [left (:representation left)
diff --git a/stdlib/source/lux/data/trace.lux b/stdlib/source/lux/data/trace.lux
index 5bd37bbca..9958d94be 100644
--- a/stdlib/source/lux/data/trace.lux
+++ b/stdlib/source/lux/data/trace.lux
@@ -9,11 +9,11 @@
   {#monoid (Monoid t)
    #trace (-> t a)})
 
-(struct: #export Functor<Trace> (All [t] (Functor (Trace t)))
+(structure: #export Functor<Trace> (All [t] (Functor (Trace t)))
   (def: (map f fa)
     (update@ #trace (compose f) fa)))
 
-(struct: #export CoMonad<Trace> (All [t] (CoMonad (Trace t)))
+(structure: #export CoMonad<Trace> (All [t] (CoMonad (Trace t)))
   (def: functor Functor<Trace>)
 
   (def: (unwrap wa)