diff --git a/dataframe-lazy.cabal b/dataframe-lazy.cabal
--- a/dataframe-lazy.cabal
+++ b/dataframe-lazy.cabal
@@ -1,6 +1,6 @@
 cabal-version:      3.4
 name:               dataframe-lazy
-version:            2.2.0.0
+version:            2.3.0.0
 synopsis:           Lazy query engine for the dataframe ecosystem.
 description:
     The lazy/streaming query engine: relational-algebra plans, optimizer,
@@ -45,13 +45,13 @@
                         attoparsec >= 0.12 && < 0.16,
                         bytestring >= 0.11 && < 0.14,
                         containers >= 0.6.7 && < 0.10,
-                        dataframe-core >= 2.1 && < 2.2,
-                        dataframe-core >= 2.1 && < 2.2,
-                        dataframe-csv >= 2.2 && < 2.3,
-                        dataframe-csv >= 2.2 && < 2.3,
-                        dataframe-operations >= 2.1 && < 2.2,
-                        dataframe-parquet >= 1.4 && < 1.5,
-                        dataframe-parsing >= 2.1 && < 2.2,
+                        dataframe-core >= 2.2 && < 2.3,
+                        dataframe-core >= 2.2 && < 2.3,
+                        dataframe-csv >= 2.3 && < 2.4,
+                        dataframe-csv >= 2.3 && < 2.4,
+                        dataframe-operations >= 2.2 && < 2.3,
+                        dataframe-parquet >= 1.5 && < 1.6,
+                        dataframe-parsing >= 2.2 && < 2.3,
                         directory >= 1.3.0.0 && < 2,
                         filepath >= 1.4 && < 2,
                         Glob >= 0.10 && < 1,
diff --git a/src/DataFrame/Typed/Lazy.hs b/src/DataFrame/Typed/Lazy.hs
--- a/src/DataFrame/Typed/Lazy.hs
+++ b/src/DataFrame/Typed/Lazy.hs
@@ -21,13 +21,13 @@
 import qualified DataFrame.Typed.Lazy as TL
 import DataFrame.Typed (Column)
 
-type Schema = '[Column \"id\" Int, Column \"name\" Text, Column \"score\" Double]
+type Schema = '[ '(\"id\", Int), '(\"name\", Text), '(\"score\", Double)]
 
 main = do
     let query = TL.scanCsv \@Schema \"data.csv\"
               & TL.filter (TL.col \@\"score\" TL..>. TL.lit 0.5)
               & TL.select \@'[\"id\", \"name\"]
-    df <- TL.run query   -- TypedDataFrame '[Column \"id\" Int, Column \"name\" Text]
+    df <- TL.run query   -- TypedDataFrame '[ '(\"id\", Int), '(\"name\", Text)]
     print df
 @
 -}
@@ -91,7 +91,7 @@
 import DataFrame.Typed.Types
 
 -- | A lazy query with compile-time schema tracking.
-newtype TypedLazyDataFrame (cols :: [Type]) = TLD {_unTLD :: LazyDataFrame}
+newtype TypedLazyDataFrame (cols :: [(Symbol, Type)]) = TLD {_unTLD :: LazyDataFrame}
 
 instance Show (TypedLazyDataFrame cols) where
     show (TLD ldf) = "TypedLazyDataFrame { " ++ show ldf ++ " }"
@@ -140,7 +140,7 @@
     (KnownSymbol name, C.Columnable a, AssertAbsent name cols) =>
     TExpr cols a ->
     TypedLazyDataFrame cols ->
-    TypedLazyDataFrame (Snoc cols (Column name a))
+    TypedLazyDataFrame (Snoc cols '(name, a))
 derive (TExpr expr) (TLD ldf) =
     TLD (L.derive (T.pack (symbolVal (Proxy @name))) expr ldf)
 
@@ -153,7 +153,7 @@
 select (TLD ldf) = TLD (L.select (DataFrame.Typed.Schema.symbolVals @names) ldf)
 
 -- | A typed lazy grouped query.
-newtype TypedLazyGrouped (keys :: [Symbol]) (cols :: [Type]) = TLG
+newtype TypedLazyGrouped (keys :: [Symbol]) (cols :: [(Symbol, Type)]) = TLG
     { _unTLG :: ([T.Text], LazyDataFrame)
     }