diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ # Revision history for dataframe +## 0.2.0.1 +* Fix bug with new comparison expressions. gt and geq were actually implemented as lt and leq. +* Changes to make library work with ghc 9.10.1 and 9.12.2 + ## 0.2.0.0 ### Replace `Function` adt with a column expression syntax. diff --git a/dataframe.cabal b/dataframe.cabal --- a/dataframe.cabal +++ b/dataframe.cabal @@ -1,6 +1,6 @@ cabal-version: 2.4 name: dataframe -version: 0.2.0.0 +version: 0.2.0.1 synopsis: An intuitive, dynamically-typed DataFrame library. @@ -14,7 +14,7 @@ copyright: (c) 2024-2024 Michael Chavinda category: Data -tested-with: GHC ==9.8.3 || ==9.6.6 || == 9.4.8 +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 @@ -41,7 +41,7 @@ DataFrame.Operations.Aggregation, DataFrame.Display.Terminal.Plot, DataFrame.IO.CSV - build-depends: base >= 4.17.2.0 && < 4.21, + build-depends: base >= 4.17.2.0 && < 4.22, array ^>= 0.5, attoparsec >= 0.12 && <= 0.14.4, bytestring >= 0.11 && <= 0.12.2.0, @@ -77,7 +77,7 @@ DataFrame.Operations.Aggregation, DataFrame.Display.Terminal.Plot, DataFrame.IO.CSV - build-depends: base >= 4.17.2.0 && < 4.21, + build-depends: base >= 4.17.2.0 && < 4.22, array ^>= 0.5, attoparsec >= 0.12 && <= 0.14.4, bytestring >= 0.11 && <= 0.12.2.0, @@ -97,7 +97,7 @@ type: exitcode-stdio-1.0 main-is: Main.hs hs-source-dirs: benchmark - build-depends: base >= 4.17.2.0 && < 4.21, + build-depends: base >= 4.17.2.0 && < 4.22, criterion >= 1 && <= 1.6.4.0, text >= 2.0 && <= 2.1.2, random >= 1 && <= 1.3.1, @@ -116,7 +116,7 @@ Operations.InsertColumn, Operations.Sort, Operations.Take - build-depends: base >= 4.17.2.0 && < 4.21, + build-depends: base >= 4.17.2.0 && < 4.22, HUnit ^>= 1.6, random >= 1, random-shuffle >= 0.0.4, diff --git a/src/DataFrame/Internal/DataFrame.hs b/src/DataFrame/Internal/DataFrame.hs --- a/src/DataFrame/Internal/DataFrame.hs +++ b/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 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 @@ 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 diff --git a/src/DataFrame/Internal/Expression.hs b/src/DataFrame/Internal/Expression.hs --- a/src/DataFrame/Internal/Expression.hs +++ b/src/DataFrame/Internal/Expression.hs @@ -126,10 +126,10 @@ lt = BinOp "lt" (<) gt :: (Columnable a, Ord a) => Expr a -> Expr a -> Expr Bool -gt = BinOp "gt" (<) +gt = BinOp "gt" (>) leq :: (Columnable a, Ord a, Eq a) => Expr a -> Expr a -> Expr Bool leq = BinOp "leq" (<=) geq :: (Columnable a, Ord a, Eq a) => Expr a -> Expr a -> Expr Bool -geq = BinOp "geq" (<=) +geq = BinOp "geq" (>=) diff --git a/src/DataFrame/Internal/Row.hs b/src/DataFrame/Internal/Row.hs --- a/src/DataFrame/Internal/Row.hs +++ b/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.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 diff --git a/src/DataFrame/Internal/Types.hs b/src/DataFrame/Internal/Types.hs --- a/src/DataFrame/Internal/Types.hs +++ b/src/DataFrame/Internal/Types.hs @@ -19,54 +19,4 @@ 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) diff --git a/src/DataFrame/Operations/Subset.hs b/src/DataFrame/Operations/Subset.hs --- a/src/DataFrame/Operations/Subset.hs +++ b/src/DataFrame/Operations/Subset.hs @@ -21,8 +21,7 @@ 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 ((&)) diff --git a/src/DataFrame/Operations/Transformations.hs b/src/DataFrame/Operations/Transformations.hs --- a/src/DataFrame/Operations/Transformations.hs +++ b/src/DataFrame/Operations/Transformations.hs @@ -17,8 +17,7 @@ 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)