Make dataframe work with 9.12.2

Author: mchav

dataframe.cabal

@@ -14,7 +14,7 @@ maintainer:         mschavinda@gmail.com
 
 copyright: (c) 2024-2024 Michael Chavinda
 category: Data
-tested-with: GHC ==9.8.3 || ==9.6.6 || == 9.4.8 || ==9.10.1 || ==9.12.1
+tested-with: GHC ==9.8.3 || ==9.6.6 || == 9.4.8 || ==9.10.1 || ==9.12.1 || ==9.12.2
 extra-doc-files: CHANGELOG.md README.md
 
 source-repository head

src/DataFrame/Internal/DataFrame.hs

@@ -5,6 +5,7 @@
 {-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE StrictData #-}
+{-# LANGUAGE FlexibleContexts #-}
 module DataFrame.Internal.DataFrame where
 
 import qualified Data.Map as M
@@ -45,6 +46,7 @@ asText :: DataFrame -> Bool -> T.Text
 asText d properMarkdown =
   let header = "index" : map fst (sortBy (compare `on` snd) $ M.toList (columnIndices d))
       types = V.toList $ V.filter (/= "") $ V.map getType (columns d)
+      getType :: Maybe Column -> T.Text
       getType Nothing = ""
       getType (Just (BoxedColumn (column :: V.Vector a))) = T.pack $ show (typeRep @a)
       getType (Just (UnboxedColumn (column :: VU.Vector a))) = T.pack $ show (typeRep @a)
@@ -53,6 +55,7 @@ asText d properMarkdown =
       getType (Just (GroupedUnboxedColumn (column :: V.Vector a))) = T.pack $ show (typeRep @a)
       -- Separate out cases dynamically so we don't end up making round trip string
       -- copies.
+      get :: Maybe Column -> V.Vector T.Text
       get (Just (BoxedColumn (column :: V.Vector a))) = case testEquality (typeRep @a) (typeRep @T.Text) of
               Just Refl -> column
               Nothing -> case testEquality (typeRep @a) (typeRep @String) of

src/DataFrame/Internal/Row.hs

@@ -1,4 +1,8 @@
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE ExistentialQuantification #-}
+{-# LANGUAGE ExplicitNamespaces #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE InstanceSigs #-}
 module DataFrame.Internal.Row where
 
 import qualified Data.List as L
@@ -17,6 +21,33 @@ import DataFrame.Internal.Column
 import DataFrame.Internal.DataFrame
 import DataFrame.Internal.Types
 import Data.Function (on)
+import Data.Maybe (fromMaybe)
+import Data.Typeable (Typeable, type (:~:) (..))
+import Data.Word ( Word8, Word16, Word32, Word64 )
+import Type.Reflection (TypeRep, typeOf, typeRep)
+import Data.Type.Equality (TestEquality(..))
+
+data RowValue where
+    Value :: (Columnable' a) => a -> RowValue
+
+instance Eq RowValue where
+    (==) :: RowValue -> RowValue -> Bool
+    (Value a) == (Value b) = fromMaybe False $ do
+        Refl <- testEquality (typeOf a) (typeOf b)
+        return $ a == b
+
+instance Ord RowValue where
+    (<=) :: RowValue -> RowValue -> Bool
+    (Value a) <= (Value b) = fromMaybe False $ do
+        Refl <- testEquality (typeOf a) (typeOf b)
+        return $ a <= b
+
+instance Show RowValue where
+    show :: RowValue -> String
+    show (Value a) = show a
+
+toRowValue :: forall a . (Columnable' a) => a -> RowValue
+toRowValue =  Value
 
 type Row = V.Vector RowValue
 

src/DataFrame/Internal/Types.hs

@@ -19,54 +19,4 @@ import Data.Word ( Word8, Word16, Word32, Word64 )
 import Type.Reflection (TypeRep, typeOf, typeRep)
 import Data.Type.Equality (TestEquality(..))
 
--- We need an "Object" type as an intermediate representation
--- for rows. Useful for things like sorting and function application.
 type Columnable' a = (Typeable a, Show a, Ord a, Eq a)
-
-data RowValue where
-    Value :: (Columnable' a) => a -> RowValue
-
-instance Eq RowValue where
-    (==) :: RowValue -> RowValue -> Bool
-    (Value a) == (Value b) = fromMaybe False $ do
-        Refl <- testEquality (typeOf a) (typeOf b)
-        return $ a == b
-
-instance Ord RowValue where
-    (<=) :: RowValue -> RowValue -> Bool
-    (Value a) <= (Value b) = fromMaybe False $ do
-        Refl <- testEquality (typeOf a) (typeOf b)
-        return $ a <= b
-
-instance Show RowValue where
-    show :: RowValue -> String
-    show (Value a) = show a
-
-toRowValue :: forall a . (Columnable' a) => a -> RowValue
-toRowValue =  Value
-
--- Convenience functions for types.
-unboxableTypes :: TypeRepList '[Int, Int8, Int16, Int32, Int64,
-                                Word, Word8, Word16, Word32, Word64,
-                                Char, Double, Float, Bool]
-unboxableTypes = Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep Nil)))))))))))))
-
-numericTypes :: TypeRepList '[Int, Int8, Int16, Int32, Int64, Double, Float]
-numericTypes = Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep (Cons typeRep Nil))))))
-
-data TypeRepList (xs :: [Type]) where
-  Nil  :: TypeRepList '[]
-  Cons :: Typeable x => TypeRep x -> TypeRepList xs -> TypeRepList (x ': xs)
-
-matchesAnyType :: forall a xs. (Typeable a) => TypeRepList xs -> TypeRep a -> Bool
-matchesAnyType Nil _ = False
-matchesAnyType (Cons ty tys) rep =
-  case testEquality ty rep of
-    Just Refl -> True
-    Nothing   -> matchesAnyType tys rep
-
-testUnboxable :: forall a . Typeable a => TypeRep a -> Bool
-testUnboxable x = matchesAnyType unboxableTypes (typeRep @a)
-
-testNumeric :: forall a . Typeable a => TypeRep a -> Bool
-testNumeric x = matchesAnyType numericTypes (typeRep @a)

src/DataFrame/Operations/Subset.hs

@@ -21,8 +21,7 @@ import DataFrame.Errors (DataFrameException(..))
 import DataFrame.Internal.Column
 import DataFrame.Internal.DataFrame (DataFrame(..), getColumn, empty)
 import DataFrame.Internal.Expression
-import DataFrame.Internal.Row (mkRowFromArgs)
-import DataFrame.Internal.Types (RowValue, toRowValue)
+import DataFrame.Internal.Row (mkRowFromArgs, RowValue, toRowValue)
 import DataFrame.Operations.Core
 import DataFrame.Operations.Transformations (apply)
 import Data.Function ((&))

src/DataFrame/Operations/Transformations.hs

@@ -17,8 +17,7 @@ import DataFrame.Errors (DataFrameException(..))
 import DataFrame.Internal.Column (Column(..), columnTypeString, itransform, ifoldrColumn, TypedColumn (TColumn), Columnable, transform, unwrapTypedColumn)
 import DataFrame.Internal.DataFrame (DataFrame(..), getColumn)
 import DataFrame.Internal.Expression
-import DataFrame.Internal.Row (mkRowFromArgs)
-import DataFrame.Internal.Types (RowValue, toRowValue)
+import DataFrame.Internal.Row (mkRowFromArgs, RowValue, toRowValue)
 import DataFrame.Operations.Core
 import Data.Maybe
 import Type.Reflection (typeRep, typeOf)