chore: Remove t prefix from operations.

Author: mchav

src/DataFrame/Typed.hs

@@ -68,8 +68,8 @@ module DataFrame.Typed (
     col,
     lit,
     ifThenElse,
-    tlift,
-    tlift2,
+    lift,
+    lift2,
 
     -- * Comparison operators
     (.==.),
@@ -82,15 +82,15 @@ module DataFrame.Typed (
     -- * Logical operators
     (.&&.),
     (.||.),
-    tnot,
+    DataFrame.Typed.Expr.not,
 
     -- * Aggregation expression combinators
-    tsum,
-    tmean,
-    tcount,
-    tminimum,
-    tmaximum,
-    tcollect,
+    DataFrame.Typed.Expr.sum,
+    mean,
+    count,
+    DataFrame.Typed.Expr.minimum,
+    DataFrame.Typed.Expr.maximum,
+    collect,
 
     -- * Typed sort orders
     TSortOrder (..),

src/DataFrame/Typed/Aggregate.hs

@@ -79,7 +79,7 @@ Result schema = grouping key columns ++ aggregated columns (in declaration order
 
 @
 result = aggregate
-    (agg \@\"total\" (tsum salary) $ agg \@\"count\" (tcount salary) $ aggNil)
+    (agg \@\"total\" (tsum (col @"salary")) $ agg \@\"count\" (tcount (col @"salary") $ aggNil)
     (groupBy \@'[\"dept\"] employees)
 -- result :: TDF '[Column \"dept\" Text, Column \"total\" Double, Column \"count\" Int]
 @

src/DataFrame/Typed/Expr.hs

@@ -51,8 +51,8 @@ module DataFrame.Typed.Expr (
     ifThenElse,
 
     -- * Unary / binary lifting
-    tlift,
-    tlift2,
+    lift,
+    lift2,
 
     -- * Comparison operators
     (.==.),
@@ -65,15 +65,15 @@ module DataFrame.Typed.Expr (
     -- * Logical operators
     (.&&.),
     (.||.),
-    tnot,
+    DataFrame.Typed.Expr.not,
 
     -- * Aggregation combinators
-    tsum,
-    tmean,
-    tcount,
-    tminimum,
-    tmaximum,
-    tcollect,
+    sum,
+    mean,
+    count,
+    minimum,
+    maximum,
+    collect,
 
     -- * Named expression helper
     as,
@@ -98,12 +98,10 @@ import DataFrame.Internal.Expression (
     UExpr (..),
     UnaryOp (..),
  )
+import DataFrame.Internal.Statistics
 import DataFrame.Typed.Schema (AssertPresent, Lookup)
 import DataFrame.Typed.Types (TExpr (..), TSortOrder (..))
-
--------------------------------------------------------------------------------
--- Column reference — the core type-safe construction point
--------------------------------------------------------------------------------
+import Prelude hiding (maximum, minimum, sum)
 
 {- | Create a typed column reference. This is the key type-safety entry point.
 
@@ -181,19 +179,15 @@ instance (IsString a, Columnable a) => IsString (TExpr cols a) where
 -------------------------------------------------------------------------------
 
 -- | Lift a unary function into a typed expression.
-tlift ::
+lift ::
     (Columnable a, Columnable b) => (a -> b) -> TExpr cols a -> TExpr cols b
-tlift f (TExpr e) = TExpr (Unary (MkUnaryOp f "unaryUdf" Nothing) e)
+lift f (TExpr e) = TExpr (Unary (MkUnaryOp f "unaryUdf" Nothing) e)
 
 -- | Lift a binary function into typed expressions.
-tlift2 ::
+lift2 ::
     (Columnable a, Columnable b, Columnable c) =>
     (a -> b -> c) -> TExpr cols a -> TExpr cols b -> TExpr cols c
-tlift2 f (TExpr a) (TExpr b) = TExpr (Binary (MkBinaryOp f "binaryUdf" Nothing False 0) a b)
-
--------------------------------------------------------------------------------
--- Comparison operators
--------------------------------------------------------------------------------
+lift2 f (TExpr a) (TExpr b) = TExpr (Binary (MkBinaryOp f "binaryUdf" Nothing False 0) a b)
 
 infixl 4 .==., ./=., .<., .<=., .>=., .>.
 infixr 3 .&&.
@@ -229,35 +223,30 @@ infixr 2 .||.
 (.||.) :: TExpr cols Bool -> TExpr cols Bool -> TExpr cols Bool
 (.||.) (TExpr a) (TExpr b) = TExpr (Binary (MkBinaryOp (||) "or" (Just "||") True 2) a b)
 
-tnot :: TExpr cols Bool -> TExpr cols Bool
-tnot (TExpr e) = TExpr (Unary (MkUnaryOp not "not" (Just "!")) e)
+not :: TExpr cols Bool -> TExpr cols Bool
+not (TExpr e) = TExpr (Unary (MkUnaryOp Prelude.not "not" (Just "!")) e)
 
 -------------------------------------------------------------------------------
 -- Aggregation combinators
 -------------------------------------------------------------------------------
 
-tsum :: (Columnable a, Num a) => TExpr cols a -> TExpr cols a
-tsum (TExpr e) = TExpr (Agg (FoldAgg "sum" Nothing (+)) e)
+sum :: (Columnable a, Num a) => TExpr cols a -> TExpr cols a
+sum (TExpr e) = TExpr (Agg (FoldAgg "sum" Nothing (+)) e)
 
-tmean :: (Columnable a, Real a, VU.Unbox a) => TExpr cols a -> TExpr cols Double
-tmean (TExpr e) = TExpr (Agg (CollectAgg "mean" mean') e)
-  where
-    mean' v =
-        let s = VU.foldl' (\acc x -> acc + realToFrac x) (0 :: Double) v
-            n = VU.length v
-         in if n == 0 then 0 else s / fromIntegral n
+mean :: (Columnable a, Real a, VU.Unbox a) => TExpr cols a -> TExpr cols Double
+mean (TExpr e) = TExpr (Agg (CollectAgg "mean" mean') e)
 
-tcount :: (Columnable a) => TExpr cols a -> TExpr cols Int
-tcount (TExpr e) = TExpr (Agg (FoldAgg "count" (Just 0) (\acc _ -> acc + 1)) e)
+count :: (Columnable a) => TExpr cols a -> TExpr cols Int
+count (TExpr e) = TExpr (Agg (FoldAgg "count" (Just 0) (\acc _ -> acc + 1)) e)
 
-tminimum :: (Columnable a, Ord a) => TExpr cols a -> TExpr cols a
-tminimum (TExpr e) = TExpr (Agg (FoldAgg "minimum" Nothing min) e)
+minimum :: (Columnable a, Ord a) => TExpr cols a -> TExpr cols a
+minimum (TExpr e) = TExpr (Agg (FoldAgg "minimum" Nothing min) e)
 
-tmaximum :: (Columnable a, Ord a) => TExpr cols a -> TExpr cols a
-tmaximum (TExpr e) = TExpr (Agg (FoldAgg "maximum" Nothing max) e)
+maximum :: (Columnable a, Ord a) => TExpr cols a -> TExpr cols a
+maximum (TExpr e) = TExpr (Agg (FoldAgg "maximum" Nothing max) e)
 
-tcollect :: (Columnable a) => TExpr cols a -> TExpr cols [a]
-tcollect (TExpr e) = TExpr (Agg (FoldAgg "collect" (Just []) (flip (:))) e)
+collect :: (Columnable a) => TExpr cols a -> TExpr cols [a]
+collect (TExpr e) = TExpr (Agg (FoldAgg "collect" (Just []) (flip (:))) e)
 
 -------------------------------------------------------------------------------
 -- Named expression helper
@@ -267,10 +256,6 @@ tcollect (TExpr e) = TExpr (Agg (FoldAgg "collect" (Just []) (flip (:))) e)
 as :: (Columnable a) => TExpr cols a -> T.Text -> NamedExpr
 as (TExpr e) name = (name, UExpr e)
 
--------------------------------------------------------------------------------
--- Sort helpers
--------------------------------------------------------------------------------
-
 -- | Create an ascending sort order from a typed expression.
 asc :: (Columnable a) => TExpr cols a -> TSortOrder cols
 asc = Asc

src/DataFrame/Typed/Freeze.hs

@@ -54,10 +54,6 @@ Used internally after delegation where the library guarantees schema correctness
 unsafeFreeze :: D.DataFrame -> TypedDataFrame cols
 unsafeFreeze = TDF
 
--------------------------------------------------------------------------------
--- Internal validation
--------------------------------------------------------------------------------
-
 validateSchema ::
     forall cols.
     (KnownSchema cols) =>

src/DataFrame/Typed/Schema.hs

@@ -67,10 +67,6 @@ import DataFrame.Internal.Column (Columnable)
 import DataFrame.Internal.Types (If)
 import DataFrame.Typed.Types (Column)
 
--------------------------------------------------------------------------------
--- Core type families
--------------------------------------------------------------------------------
-
 -- | Look up the element type of a column by name.
 type family Lookup (name :: Symbol) (cols :: [Type]) :: Type where
     Lookup name (Column name a ': _) = a
@@ -79,6 +75,7 @@ type family Lookup (name :: Symbol) (cols :: [Type]) :: Type where
         TypeError
             ('Text "Column '" ':<>: 'Text name ':<>: 'Text "' not found in schema")
 
+-- | Unwrap a Maybe from a type after we impute values.
 type family Impute (name :: Symbol) (cols :: [Type]) :: [Type] where
     Impute name (Column name (Maybe a) ': rest) = Column name a ': rest
     Impute name (Column name _ ': rest) =
@@ -186,10 +183,6 @@ type family
         TypeError
             ('Text "Column '" ':<>: 'Text name ':<>: 'Text "' not found in schema")
 
--------------------------------------------------------------------------------
--- Maybe-stripping families
--------------------------------------------------------------------------------
-
 {- | Strip 'Maybe' from all columns. Used by 'filterAllJust'.
 
 @Column "x" (Maybe Double)@ becomes @Column "x" Double@.
@@ -213,10 +206,6 @@ type family StripMaybeAt (name :: Symbol) (cols :: [Type]) :: [Type] where
         TypeError
             ('Text "Column '" ':<>: 'Text name ':<>: 'Text "' not found in schema")
 
--------------------------------------------------------------------------------
--- Join schema families
--------------------------------------------------------------------------------
-
 -- | Extract column names that appear in both schemas.
 type family SharedNames (left :: [Type]) (right :: [Type]) :: [Symbol] where
     SharedNames '[] right = '[]
@@ -324,10 +313,6 @@ type family GroupKeyColumns (keys :: [Symbol]) (cols :: [Type]) :: [Type] where
             (Column n a ': GroupKeyColumns keys rest)
             (GroupKeyColumns keys rest)
 
--------------------------------------------------------------------------------
--- KnownSchema class
--------------------------------------------------------------------------------
-
 -- | Provides runtime evidence of a schema: a list of (name, TypeRep) pairs.
 class KnownSchema (cols :: [Type]) where
     schemaEvidence :: [(T.Text, SomeTypeRep)]
@@ -343,10 +328,6 @@ instance
         (T.pack (symbolVal (Proxy @name)), someTypeRep (Proxy @a))
             : schemaEvidence @rest
 
--------------------------------------------------------------------------------
--- AllKnownSymbol helper
--------------------------------------------------------------------------------
-
 -- | A class that provides a list of 'Text' values for a type-level list of Symbols.
 class AllKnownSymbol (names :: [Symbol]) where
     symbolVals :: [T.Text]

src/DataFrame/Typed/TH.hs

@@ -53,10 +53,6 @@ deriveSchemaFromCsvFile typeName path = do
     df <- liftIO (D.readCsv path)
     deriveSchema typeName df
 
--------------------------------------------------------------------------------
--- Internal helpers
--------------------------------------------------------------------------------
-
 getSchemaInfo :: D.DataFrame -> [(T.Text, String)]
 getSchemaInfo df =
     let orderedNames =