Frames 0.1.2.1 → 0.1.3

raw patch · 12 files changed

+186/−36 lines, 12 filesdep ~Chartdep ~Chart-diagramsdep ~basenew-component:exe:kata04PVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: Chart, Chart-diagrams, base, foldl, ghc-prim, pipes, readable, template-haskell, text, transformers, vector, vinyl

API changes (from Hackage documentation)

Files

• CHANGELOG.md +4/−0
• Frames.cabal +21/−10
• demo/Kata04.hs +57/−0
• src/Frames/CSV.hs +26/−3
• src/Frames/CoRec.hs +26/−6
• src/Frames/Col.hs +4/−1
• src/Frames/ColumnTypeable.hs +3/−3
• src/Frames/ColumnUniverse.hs +3/−0
• src/Frames/Frame.hs +3/−2
• src/Frames/InCore.hs +28/−9
• src/Frames/RecF.hs +6/−1
• src/Frames/TypeLevel.hs +5/−1

@@ -1,3 +1,7 @@+# 0.1.3++GHC-8.0.1 compatibility+ # 0.1.2.1  Improved documentation based on suggestions by Alexander Kjeldaas

@@ -1,5 +1,5 @@ name:                Frames-version:             0.1.2.1+version:             0.1.3 synopsis:            Data frames For working with tabular data files description:         User-friendly, type safe, runtime efficient tooling for                      working with tabular data deserialized from@@ -18,6 +18,7 @@                      demo/Main.hs CHANGELOG.md                      data/GetData.hs cabal-version:       >=1.10+tested-with:         GHC == 7.10.3, GHC == 8.0.1  source-repository head   type:     git@@ -47,8 +48,8 @@                        TypeOperators, ConstraintKinds, StandaloneDeriving,                        UndecidableInstances, ScopedTypeVariables,                        OverloadedStrings-  build-depends:       base >=4.7 && <4.9,-                       ghc-prim >=0.3 && <0.5,+  build-depends:       base >=4.7 && <4.10,+                       ghc-prim >=0.3 && <0.6,                        primitive >= 0.6 && < 0.7,                        text >= 1.1.1.0,                        template-haskell,@@ -82,8 +83,8 @@                    lens-family-core, vector, text,                    template-haskell,                    pipes >= 4.1.5 && < 4.2, -                   Chart >= 1.5 && < 1.6,-                   Chart-diagrams >= 1.5 && < 1.6,+                   Chart >= 1.5 && < 1.8,+                   Chart-diagrams >= 1.5 && < 1.8,                    diagrams-rasterific >= 1.3 && < 1.4,                    diagrams-lib >= 1.3 && < 1.4,                    readable, containers, statistics@@ -98,8 +99,8 @@     build-depends: base, Frames,                    lens-family-core, vector, text, template-haskell,                    pipes >= 4.1.5 && < 4.2,-                   Chart >= 1.5 && < 1.6,-                   Chart-diagrams >= 1.5 && < 1.6,+                   Chart >= 1.5 && < 1.8,+                   Chart-diagrams >= 1.5 && < 1.8,                    diagrams-rasterific >= 1.3 && < 1.4,                    diagrams-lib >= 1.3 && < 1.4,                     readable, containers, statistics@@ -126,7 +127,7 @@   if flag(demos)     build-depends: base, Frames,                    lens-family-core, vector, text, template-haskell, readable,-                   foldl >= 1.1.0 && < 1.2,+                   foldl >= 1.1.0 && < 1.3,                    pipes >= 4.1.5 && < 4.2   hs-source-dirs: demo   default-language: Haskell2010@@ -138,7 +139,7 @@   main-is:          BenchDemo.hs   if flag(demos)     build-depends:    base, Frames, lens-family-core,-                      foldl >= 1.1.0 && < 1.2,+                      foldl >= 1.1.0 && < 1.3,                       pipes >= 4.1.5 && < 4.2   hs-source-dirs:   benchmarks   default-language: Haskell2010@@ -162,5 +163,15 @@   main-is:          InsuranceBench.hs   build-depends:    base, criterion, Frames, lens-family-core, transformers,                     pipes >= 4.1.5 && < 4.2-  ghc-options:      -O2 -fllvm+  ghc-options:      -O2+  default-language: Haskell2010++-- Demonstration of tab-separated value parsing+executable kata04+  if !flag(demos)+    buildable: False+  main-is: Kata04.hs+  if flag(demos)+    build-depends: base, Frames, vinyl, text, readable+  hs-source-dirs: demo   default-language: Haskell2010

@@ -0,0 +1,57 @@+{-# LANGUAGE DataKinds, FlexibleContexts, OverloadedStrings,+             TemplateHaskell, TypeFamilies, TypeOperators,+             MultiParamTypeClasses, ScopedTypeVariables,+             FlexibleContexts, FlexibleInstances #-}+module Main where+import qualified Data.Foldable as F+import Data.Ord (comparing)+import Data.Proxy+import qualified Data.Text as T+import qualified Data.Text.IO as T+import Data.Vinyl.Functor (Identity(..))+import Data.Vinyl.TypeLevel (Nat(..))+import Frames++-- Data set from http://codekata.com/data/04/weather.dat+-- Associated with this problem set:+-- http://codekata.com/kata/kata04-data-munging/+tableTypes "Row" "data/weather.csv"++getTemperatureRange :: (MxT ∈ rs, MnT ∈ rs) => Record rs -> Double+getTemperatureRange row = rget mxT row - rget mnT row++partOne :: IO T.Text+partOne = do tbl <- inCoreAoS (readTable "data/weather.csv") :: IO (Frame Row)+             return $ rget dy (F.maximumBy (comparing getTemperatureRange) tbl)+++-- shapr: Fight the dying of the light!++type family Find i xs where+  Find 'Z ((s :-> x) ': xs) = x+  Find ('S i) (x ': xs) = Find i xs++class GetFieldByIndex i rs where+  getFieldByIndex :: proxy i -> Record rs -> Find i rs++instance GetFieldByIndex 'Z ((s :-> r) ': rs) where+  getFieldByIndex _ (Identity x :& _) = x++instance GetFieldByIndex i rs => GetFieldByIndex ('S i) ((s :-> r) ': rs) where+  getFieldByIndex _ (_ :& xs) = getFieldByIndex (Proxy :: Proxy i) xs++getTemperatureRange' :: (GetFieldByIndex (S Z) rs, GetFieldByIndex (S (S Z)) rs,+                         Find (S Z) rs ~ Double, Find (S (S Z)) rs ~ Double )+                     => Record rs -> Double+getTemperatureRange' row = mx - mn+  where mx = getFieldByIndex (Proxy::Proxy ('S 'Z)) row+        mn = getFieldByIndex (Proxy::Proxy ('S ('S 'Z))) row++partOne' :: IO T.Text+partOne' = do tbl <- inCoreAoS (readTable "data/weather.csv") :: IO (Frame Row)+              return . getFieldByIndex (Proxy::Proxy Z) $+                F.maximumBy (comparing getTemperatureRange') tbl++main :: IO ()+main = do partOne >>= T.putStrLn+          partOne' >>= T.putStrLn

@@ -369,14 +369,37 @@  -- * Customized Data Set Parsing --- | Generate a type for a row a table. This will be something like--- @Record ["x" :-> a, "y" :-> b, "z" :-> c]@.  Column type synonyms are--- /not/ generated (see 'tableTypes'').+-- | Generate a type for a row of a table. This will be something like+-- @Record ["x" :-> a, "y" :-> b, "z" :-> c]@.  Column type synonyms+-- are /not/ generated (see 'tableTypes''). tableType' :: forall a. (ColumnTypeable a, Monoid a)            => RowGen a -> FilePath -> DecsQ tableType' (RowGen {..}) csvFile =     pure . TySynD (mkName rowTypeName) [] <$>     (runIO (readColHeaders opts csvFile) >>= recDec')+  where recDec' = recDec :: [(T.Text, a)] -> Q Type+        colNames' | null columnNames = Nothing+                  | otherwise = Just (map T.pack columnNames)+        opts = ParserOptions colNames' separator (RFC4180Quoting '\"')++-- | Generate a type for a row of a table all of whose columns remain+-- unparsed 'Text' values.+tableTypesText' :: forall a. (ColumnTypeable a, Monoid a)+                => RowGen a -> FilePath -> DecsQ+tableTypesText' (RowGen {..}) csvFile =+  do colNames <- runIO $ withFile csvFile ReadMode $ \h ->+       maybe (tokenizeRow opts <$> T.hGetLine h)+             pure+             (headerOverride opts)+     let headers = zip colNames (repeat (inferType " "))+     recTy <- tySynD (mkName rowTypeName) [] (recDec' headers)+     let optsName = case rowTypeName of+                      [] -> error "Row type name shouldn't be empty"+                      h:t -> mkName $ toLower h : t ++ "Parser"+     optsTy <- sigD optsName [t|ParserOptions|]+     optsDec <- valD (varP optsName) (normalB $ lift opts) []+     colDecs <- concat <$> mapM (uncurry $ colDec (T.pack tablePrefix)) headers+     return (recTy : optsTy : optsDec : colDecs)   where recDec' = recDec :: [(T.Text, a)] -> Q Type         colNames' | null columnNames = Nothing                   | otherwise = Just (map T.pack columnNames)

@@ -1,5 +1,6 @@ {-# LANGUAGE BangPatterns,              ConstraintKinds,+             CPP,              DataKinds,              FlexibleContexts,              FlexibleInstances,@@ -23,11 +24,15 @@ import Data.Maybe(fromJust) import Data.Proxy import Data.Vinyl-import Data.Vinyl.Functor (Compose(..), (:.), Identity(..))-import Data.Vinyl.TypeLevel (RIndex)+import Data.Vinyl.Functor (Compose(..), (:.), Identity(..), Const(..))+import Data.Vinyl.TypeLevel (RIndex, RecAll) import Frames.RecF (reifyDict) import Frames.TypeLevel (LAll, HasInstances, AllHave)+#if __GLASGOW_HASKELL__ < 800 import GHC.Prim (Constraint)+#else+import Data.Kind (Constraint)+#endif  -- | Generalize algebraic sum types. data CoRec :: (* -> *) -> [*] -> * where@@ -54,6 +59,21 @@           shower = reifyDict (Proxy::Proxy Show) (Op show)           show' = runOp (rget Proxy shower) +instance forall ts. (RecAll Maybe ts Eq, RecApplicative ts)+  => Eq (CoRec Identity ts) where+  crA == crB = and . recordToList+             $ zipRecsWith f (toRec crA) (corecToRec' crB)+    where+      f :: forall a. (Dict Eq :. Maybe) a -> Maybe a -> Const Bool a+      f (Compose (Dict a)) b = Const $ a == b+      toRec = reifyConstraint (Proxy :: Proxy Eq) . corecToRec'++-- | 'zipWith' for Rec's.+zipRecsWith :: (forall a. f a -> g a -> h a) -> Rec f as -> Rec g as -> Rec h as+zipRecsWith _ RNil      _         = RNil+zipRecsWith f (r :& rs) (s :& ss) = f r s :& zipRecsWith f rs ss++ -- | Remove a 'Dict' wrapper from a value. dictId :: Dict c a -> Identity a dictId (Dict x) = Identity x@@ -191,10 +211,10 @@ match'      :: RecApplicative ts => CoRec Identity ts -> Handlers ts b -> Maybe b match' c hs = match'' hs $ corecToRec' c   where-    match''                            :: Handlers ts b -> Rec Maybe ts -> Maybe b-    match'' RNil        RNil           = Nothing-    match'' (H f :& _)  (Just x  :& _) = Just $ f x-    match'' (H _ :& fs) (Nothing :& c) = match'' fs c+    match''                             :: Handlers ts b -> Rec Maybe ts -> Maybe b+    match'' RNil        RNil            = Nothing+    match'' (H f :& _)  (Just x  :& _)  = Just $ f x+    match'' (H _ :& fs) (Nothing :& c') = match'' fs c'   -- | Newtype around functions for a to b

@@ -1,11 +1,14 @@-{-# LANGUAGE DataKinds,+{-# LANGUAGE CPP,+             DataKinds,              GeneralizedNewtypeDeriving,              KindSignatures,              ScopedTypeVariables,              TypeOperators #-} -- | Column types module Frames.Col where+#if __GLASGOW_HASKELL__ < 800 import Data.Monoid+#endif import Data.Proxy import GHC.TypeLits 

@@ -18,8 +18,8 @@   -- returns 'Just Possibly' if a value can be read, but is likely   -- ambiguous (e.g. an empty string); returns 'Just Definitely' if a   -- value can be read and is unlikely to be ambiguous."-  parse :: (Functor m, MonadPlus m) => T.Text -> m (Parsed a)-  default parse :: (Readable a, Functor m, MonadPlus m)+  parse :: MonadPlus m => T.Text -> m (Parsed a)+  default parse :: (Readable a, MonadPlus m)                 => T.Text -> m (Parsed a)   parse = fmap Definitely . fromText   {-# INLINE parse #-}@@ -31,7 +31,7 @@  -- | Acts just like 'fromText': tries to parse a value from a 'T.Text' -- and discards any estimate of the parse's ambiguity.-parse' :: (Functor m, MonadPlus m, Parseable a) => T.Text -> m a+parse' :: (MonadPlus m, Parseable a) => T.Text -> m a parse' = fmap discardConfidence . parse  instance Parseable Bool where

@@ -1,5 +1,6 @@ {-# LANGUAGE BangPatterns,              ConstraintKinds,+             CPP,              DataKinds,              FlexibleContexts,              FlexibleInstances,@@ -19,7 +20,9 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Frames.ColumnUniverse (CoRec, Columns, ColumnUniverse, CommonColumns) where import Language.Haskell.TH+#if __GLASGOW_HASKELL__ < 800 import Data.Monoid+#endif import Data.Proxy import qualified Data.Text as T import Data.Typeable (Typeable, showsTypeRep, typeRep)

@@ -1,9 +1,10 @@-{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE CPP, TypeOperators #-} -- | A 'Frame' is a finite 'Int'-indexed collection of rows. module Frames.Frame where-import Control.Applicative import Data.Foldable+#if __GLASGOW_HASKELL__ < 800 import Data.Monoid+#endif import qualified Data.Vector as V import Data.Vinyl.TypeLevel import Frames.Rec (Record)

@@ -1,4 +1,5 @@ {-# LANGUAGE BangPatterns,+             CPP,              DataKinds,              EmptyCase,              FlexibleInstances,@@ -9,7 +10,6 @@              UndecidableInstances #-} -- | Efficient in-memory (in-core) storage of tabular data. module Frames.InCore where-import Control.Applicative import Control.Monad.Primitive import Control.Monad.ST (runST) import Data.Proxy@@ -24,7 +24,9 @@ import Frames.Frame import Frames.Rec import Frames.RecF+#if __GLASGOW_HASKELL__ < 800 import GHC.Prim (RealWorld)+#endif import qualified Pipes as P import qualified Pipes.Prelude as P @@ -60,12 +62,12 @@ -- | Tooling to allocate, grow, write to, freeze, and index into -- records of vectors. class RecVec rs where-  allocRec   :: (Applicative m, PrimMonad m)+  allocRec   :: PrimMonad m              => proxy rs -> m (Record (VectorMs m rs))-  freezeRec  :: (Applicative m, PrimMonad m)+  freezeRec  :: PrimMonad m              => proxy rs -> Int -> Record (VectorMs m rs)              -> m (Record (Vectors rs))-  growRec    :: (Applicative m, PrimMonad m)+  growRec    :: PrimMonad m              => proxy rs -> Record (VectorMs m rs) -> m (Record (VectorMs m rs))   writeRec   :: PrimMonad m              => proxy rs -> Int -> Record (VectorMs m rs) -> Record rs -> m ()@@ -82,27 +84,34 @@   {-# INLINE allocRec #-}    freezeRec _ _ V.RNil = return V.RNil+#if __GLASGOW_HASKELL__ < 800   freezeRec _ _ x = case x of+#endif   {-# INLINE freezeRec #-}    growRec _ V.RNil = return V.RNil+#if __GLASGOW_HASKELL__ < 800   growRec _ x = case x of+#endif   {-# INLINE growRec #-}    indexRec _ _ _ = V.RNil   {-# INLINE indexRec #-}    writeRec _ _ V.RNil V.RNil = return ()+#if __GLASGOW_HASKELL__ < 800   writeRec _ _ x _ = case x of+#endif   {-# INLINE writeRec #-}    produceRec _ V.RNil = V.RNil+#if __GLASGOW_HASKELL__ < 800   produceRec _ x = case x of+#endif   {-# INLINE produceRec #-}  instance forall s a rs.   (VGM.MVector (VectorMFor a) a,-   VG.Mutable (VectorFor a) ~ VectorMFor a,    VG.Vector (VectorFor a) a,    RecVec rs)   => RecVec (s :-> a ': rs) where@@ -112,27 +121,37 @@   freezeRec _ n (Identity (Col x) V.:& xs) =     (&:) <$> (VG.unsafeFreeze $ VGM.unsafeSlice 0 n x)          <*> freezeRec (Proxy::Proxy rs) n xs+#if __GLASGOW_HASKELL__ < 800   freezeRec _ _ x = case x of+#endif   {-# INLINE freezeRec #-}    growRec _ (Identity (Col x) V.:& xs) = (&:) <$> VGM.grow x (VGM.length x)                                               <*> growRec (Proxy :: Proxy rs) xs+#if __GLASGOW_HASKELL__ < 800   growRec _ x = case x of+#endif   {-# INLINE growRec #-}    writeRec _ !i !(Identity (Col v) V.:& vs) (Identity (Col x) V.:& xs) =     VGM.unsafeWrite v i x >> writeRec (Proxy::Proxy rs) i vs xs+#if __GLASGOW_HASKELL__ < 800   writeRec _ _ _ x = case x of+#endif   {-# INLINE writeRec #-}    indexRec _ !i !(Identity (Col x) V.:& xs) =     x VG.! i &: indexRec (Proxy :: Proxy rs) i xs+#if __GLASGOW_HASKELL__ < 800   indexRec _ _ x = case x of+#endif   {-# INLINE indexRec #-}    produceRec _ (Identity (Col v) V.:& vs) = frameCons (v VG.!) $                                             produceRec (Proxy::Proxy rs) vs+#if __GLASGOW_HASKELL__ < 800   produceRec _ x = case x of+#endif   {-# INLINE produceRec #-}  -- | Stream a finite sequence of rows into an efficient in-memory@@ -143,7 +162,7 @@ -- indexing functions. See 'toAoS' to convert the result to a 'Frame' -- which provides an easier-to-use function that indexes into the -- table in a row-major fashion.-inCoreSoA :: forall m rs. (Applicative m, PrimMonad m, RecVec rs)+inCoreSoA :: forall m rs. (PrimMonad m, RecVec rs)           => P.Producer (Record rs) m () -> m (Int, V.Rec ((->) Int) rs) inCoreSoA xs =   do mvs <- allocRec (Proxy :: Proxy rs)@@ -164,13 +183,13 @@ -- resulting generators a matter of indexing into a densely packed -- representation. Returns a 'Frame' that provides a function to index -- into the table.-inCoreAoS :: (Applicative m, PrimMonad m, RecVec rs)+inCoreAoS :: (PrimMonad m, RecVec rs)           => P.Producer (Record rs) m () -> m (FrameRec rs) inCoreAoS = fmap (uncurry toAoS) . inCoreSoA  -- | Like 'inCoreAoS', but applies the provided function to the record -- of columns before building the 'Frame'.-inCoreAoS' :: (Applicative m, PrimMonad m, RecVec rs)+inCoreAoS' :: (PrimMonad m, RecVec rs)            => (V.Rec ((->) Int) rs -> V.Rec ((->) Int) ss)            -> P.Producer (Record rs) m () -> m (FrameRec ss) inCoreAoS' f = fmap (uncurry toAoS . aux) . inCoreSoA@@ -187,7 +206,7 @@ -- table will be stored optimally based on its type, making use of the -- resulting generator a matter of indexing into a densely packed -- representation.-inCore :: forall m n rs. (Applicative m, PrimMonad m, RecVec rs, Monad n)+inCore :: forall m n rs. (PrimMonad m, RecVec rs, Monad n)        => P.Producer (Record rs) m () -> m (P.Producer (Record rs) n ()) inCore xs =   do mvs <- allocRec (Proxy :: Proxy rs)

@@ -1,4 +1,5 @@ {-# LANGUAGE ConstraintKinds,+             CPP,              DataKinds,              FlexibleContexts,              FlexibleInstances,@@ -17,7 +18,6 @@                     UnColumn, AsVinyl(..), mapMono, mapMethod,                     ShowRec, showRec, ColFun, ColumnHeaders,                      columnHeaders, reifyDict) where-import Control.Applicative import Data.List (intercalate) import Data.Proxy import qualified Data.Vinyl as V@@ -49,7 +49,10 @@ frameSnoc r x = V.rappend r (x V.:& RNil) {-# INLINE frameSnoc #-} +-- Nil :: Rec f '[] pattern Nil = V.RNil++-- (:&) :: Functor f => f r -> Rec f rs -> Rec f (r ': rs) pattern x :& xs <- (frameUncons -> (x, xs))  -- NOTE: A bidirectional pattern synonym would be great, but we'll@@ -94,7 +97,9 @@ instance AsVinyl ts => AsVinyl (s :-> t ': ts) where   toVinyl (x V.:& xs) = fmap getCol x V.:& toVinyl xs   fromVinyl (x V.:& xs) = fmap Col x V.:& fromVinyl xs+#if __GLASGOW_HASKELL__ < 800   fromVinyl _ = error "GHC coverage checker isn't great"+#endif  -- | Map a function across a homogeneous, monomorphic 'V.Rec'. mapMonoV :: (Functor f, AllAre a ts) => (a -> a) -> V.Rec f ts -> V.Rec f ts

@@ -1,7 +1,11 @@-{-# LANGUAGE DataKinds, TypeFamilies, TypeOperators #-}+{-# LANGUAGE CPP, DataKinds, TypeFamilies, TypeOperators #-} -- | Helpers for working with type-level lists. module Frames.TypeLevel where+#if __GLASGOW_HASKELL__ < 800 import GHC.Prim (Constraint)+#else+import Data.Kind (Constraint)+#endif  -- | Remove the first occurence of a type from a type-level list. type family RDelete r rs where