Rename [Top.id] to avoid clash with [Basis.id]

3 files changed, 10 insertions, 10 deletions

diff --git a/demo/more/dbgrid.ur b/demo/more/dbgrid.ur
index d29b6a1f..fc593533 100644
--- a/demo/more/dbgrid.ur
+++ b/demo/more/dbgrid.ur
@@ -385,19 +385,19 @@ functor Make(M : sig
                        val wholeRow = @Folder.concat ! M.keyFolder M.rowFolder
 
                        fun ensql [env] (r : $(M.key ++ M.row)) =
-                           @map2 [rawMeta] [id] [sql_exp env [] []]
+                           @map2 [rawMeta] [ident] [sql_exp env [] []]
                             (fn [t] meta v => @sql_inject meta.Inj v)
                             wholeRow M.raw r
 
                        val new =
-                           row <- @Monad.mapR _ [rawMeta] [id]
+                           row <- @Monad.mapR _ [rawMeta] [ident]
                                    (fn [nm :: Name] [t :: Type] meta => meta.New)
                                    wholeRow M.raw;
                            dml (insert M.tab (ensql row));
                            return row
 
                        fun selector (r : $M.key) : sql_exp [T = M.key ++ M.row] [] [] bool =
-                         @foldR2 [rawMeta] [id]
+                         @foldR2 [rawMeta] [ident]
                           [fn key => rest :: {Type} -> [rest ~ key] => sql_exp [T = key ++ rest] [] [] bool]
                           (fn [nm :: Name] [t :: Type] [key :: {Type}] [[nm] ~ key]
                                            (meta : rawMeta t) (v : t)
diff --git a/demo/more/grid.ur b/demo/more/grid.ur
index dd0cb813..a281bab7 100644
--- a/demo/more/grid.ur
+++ b/demo/more/grid.ur
@@ -253,17 +253,17 @@ functor Make(M : sig
                       grid.Rows}
 
             <dyn signal={rows <- Dlist.foldl (fn row : listT =>
-                                                 @Monad.mapR2 _ [aggregateMeta M.row] [id] [id]
+                                                 @Monad.mapR2 _ [aggregateMeta M.row] [ident] [ident]
                                                   (fn [nm :: Name] [t :: Type] meta acc =>
                                                       Monad.mp (fn v => meta.Step v acc)
                                                                (signal row.Row))
                                                   M.aggFolder M.aggregates)
-                                 (@mp [aggregateMeta M.row] [id]
+                                 (@mp [aggregateMeta M.row] [ident]
                                   (fn [t] meta => meta.Initial)
                                   M.aggFolder M.aggregates) grid.Rows;
                          return <xml><tr>
                            <th colspan={3}>Aggregates</th>
-                           {@mapX2 [aggregateMeta M.row] [id] [_]
+                           {@mapX2 [aggregateMeta M.row] [ident] [_]
                              (fn [nm :: Name] [t :: Type] [rest :: {Type}] [[nm] ~ rest] meta acc =>
                                  <xml><td class={agg}>{meta.Display acc}</td></xml>)
                              M.aggFolder M.aggregates rows}
diff --git a/demo/more/versioned.ur b/demo/more/versioned.ur
index 0ab15e32..d08ebcb0 100644
--- a/demo/more/versioned.ur
+++ b/demo/more/versioned.ur
@@ -24,7 +24,7 @@ functor Make(M : sig
                          Eq : eq t}
 
     fun keyRecd (r : $(M.key ++ M.data)) =
-        @map2 [sql_injectable] [id] [sql_exp [] [] []]
+        @map2 [sql_injectable] [ident] [sql_exp [] [] []]
          (fn [t] => @sql_inject)
          M.keyFolder M.key (r --- M.data)
 
@@ -33,14 +33,14 @@ functor Make(M : sig
         dml (Basis.insert t
                           ({Version = (SQL {[vr]}), When = (SQL CURRENT_TIMESTAMP)}
                                ++ keyRecd r
-                               ++ @map2 [dmeta] [id]
+                               ++ @map2 [dmeta] [ident]
                                [fn t => sql_exp [] [] [] (option t)]
                                (fn [t] x v => @sql_inject (@sql_option_prim x.Inj)
                                                (Some v))
                                M.dataFolder M.data (r --- M.key)))
 
     fun keyExp (r : $M.key) : sql_exp [T = all] [] [] bool =
-        @foldR2 [sql_injectable] [id] [fn before => after :: {Type} -> [before ~ after]
+        @foldR2 [sql_injectable] [ident] [fn before => after :: {Type} -> [before ~ after]
                                           => sql_exp [T = before ++ after] [] [] bool]
          (fn [nm :: Name] [t :: Type] [before :: {Type}] [[nm] ~ before]
                           (inj : sql_injectable t) (v : t)
@@ -113,7 +113,7 @@ functor Make(M : sig
           | Some cur =>
             vr <- nextval s;
             let
-                val r' = @map3 [dmeta] [id] [id] [fn t => sql_exp [] [] [] (option t)]
+                val r' = @map3 [dmeta] [ident] [ident] [fn t => sql_exp [] [] [] (option t)]
                           (fn [t] (meta : dmeta t) old new =>
                               @sql_inject (@sql_option_prim meta.Inj)
                                (if @@eq [_] meta.Eq old new then