Frames 0.1.1.0 → 0.1.1.1

raw patch · 2 files changed

+2/−2 lines, 2 filesdep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base

API changes (from Hackage documentation)

- Frames.CSV: [columnNames] :: RowGen a -> [String]

- Frames.CSV: [columnSeparator] :: ParserOptions -> Separator

- Frames.CSV: [columnUniverse] :: RowGen a -> Proxy a

- Frames.CSV: [headerOverride] :: ParserOptions -> Maybe [Text]

- Frames.CSV: [quotingMode] :: ParserOptions -> QuotingMode

- Frames.CSV: [rowTypeName] :: RowGen a -> String

- Frames.CSV: [separator] :: RowGen a -> Separator

- Frames.CSV: [tablePrefix] :: RowGen a -> String

- Frames.CSV: instance (Frames.ColumnTypeable.Parseable t, Frames.CSV.ReadRec ts) => Frames.CSV.ReadRec (s Frames.Col.:-> t : ts)

- Frames.CSV: instance Frames.CSV.ReadRec '[]

- Frames.CSV: instance GHC.Classes.Eq Frames.CSV.ParserOptions

- Frames.CSV: instance GHC.Classes.Eq Frames.CSV.QuotingMode

- Frames.CSV: instance GHC.Show.Show Frames.CSV.ParserOptions

- Frames.CSV: instance GHC.Show.Show Frames.CSV.QuotingMode

- Frames.CSV: instance Language.Haskell.TH.Syntax.Lift Frames.CSV.ParserOptions

- Frames.CSV: instance Language.Haskell.TH.Syntax.Lift Frames.CSV.QuotingMode

- Frames.CoRec: [runOp] :: Op b a -> a -> b

- Frames.CoRec: instance (Frames.TypeLevel.LAll GHC.Show.Show ts, Data.Vinyl.Core.RecApplicative ts) => GHC.Show.Show (Frames.CoRec.CoRec Data.Vinyl.Functor.Identity ts)

- Frames.CoRec: instance (t Data.Vinyl.Lens.∈ ss, Frames.CoRec.FoldRec ss ts) => Frames.CoRec.FoldRec ss (t : ts)

- Frames.CoRec: instance Frames.CoRec.FoldRec ss '[]

- Frames.CoRec: instance GHC.Show.Show (Frames.CoRec.CoRec (Data.Vinyl.Core.Dict GHC.Show.Show) ts)

- Frames.Col: [getCol] :: (:->) a -> a

- Frames.Col: instance (GHC.TypeLits.KnownSymbol s, GHC.Show.Show a) => GHC.Show.Show (Frames.Col.Col' s a)

- Frames.Col: instance (GHC.TypeLits.KnownSymbol s, GHC.Show.Show a) => GHC.Show.Show (s Frames.Col.:-> a)

- Frames.Col: instance GHC.Base.Monoid a => GHC.Base.Monoid (s Frames.Col.:-> a)

- Frames.Col: instance GHC.Classes.Eq a => GHC.Classes.Eq (s Frames.Col.:-> a)

- Frames.Col: instance GHC.Classes.Ord a => GHC.Classes.Ord (s Frames.Col.:-> a)

- Frames.Col: instance GHC.Float.Floating a => GHC.Float.Floating (s Frames.Col.:-> a)

- Frames.Col: instance GHC.Float.RealFloat a => GHC.Float.RealFloat (s Frames.Col.:-> a)

- Frames.Col: instance GHC.Num.Num a => GHC.Num.Num (s Frames.Col.:-> a)

- Frames.Col: instance GHC.Real.Fractional a => GHC.Real.Fractional (s Frames.Col.:-> a)

- Frames.Col: instance GHC.Real.Real a => GHC.Real.Real (s Frames.Col.:-> a)

- Frames.Col: instance GHC.Real.RealFrac a => GHC.Real.RealFrac (s Frames.Col.:-> a)

- Frames.ColumnTypeable: instance Frames.ColumnTypeable.Parseable Data.Text.Internal.Text

- Frames.ColumnTypeable: instance Frames.ColumnTypeable.Parseable GHC.Types.Bool

- Frames.ColumnTypeable: instance Frames.ColumnTypeable.Parseable GHC.Types.Double

- Frames.ColumnTypeable: instance Frames.ColumnTypeable.Parseable GHC.Types.Float

- Frames.ColumnTypeable: instance Frames.ColumnTypeable.Parseable GHC.Types.Int

- Frames.ColumnTypeable: instance GHC.Base.Functor Frames.ColumnTypeable.Parsed

- Frames.ColumnTypeable: instance GHC.Classes.Eq a => GHC.Classes.Eq (Frames.ColumnTypeable.Parsed a)

- Frames.ColumnTypeable: instance GHC.Classes.Ord a => GHC.Classes.Ord (Frames.ColumnTypeable.Parsed a)

- Frames.ColumnTypeable: instance GHC.Show.Show a => GHC.Show.Show (Frames.ColumnTypeable.Parsed a)

- Frames.ColumnUniverse: instance (Data.Text.Internal.Text Data.Vinyl.Lens.∈ ts) => GHC.Base.Monoid (Frames.CoRec.CoRec Frames.ColumnUniverse.ColInfo ts)

- Frames.ColumnUniverse: instance (Frames.TypeLevel.LAll Frames.ColumnTypeable.Parseable ts, Frames.TypeLevel.LAll Data.Typeable.Internal.Typeable ts, Frames.CoRec.FoldRec ts ts, Data.Vinyl.Core.RecApplicative ts, Data.Text.Internal.Text Data.Vinyl.Lens.∈ ts) => Frames.ColumnTypeable.ColumnTypeable (Frames.CoRec.CoRec Frames.ColumnUniverse.ColInfo ts)

- Frames.Frame: [frameLength] :: Frame r -> !Int

- Frames.Frame: [frameRow] :: Frame r -> Int -> r

- Frames.Frame: instance Data.Foldable.Foldable Frames.Frame.Frame

- Frames.Frame: instance GHC.Base.Applicative Frames.Frame.Frame

- Frames.Frame: instance GHC.Base.Functor Frames.Frame.Frame

- Frames.Frame: instance GHC.Base.Monad Frames.Frame.Frame

- Frames.Frame: instance GHC.Base.Monoid (Frames.Frame.Frame r)

- Frames.InCore: instance (Data.Vector.Generic.Mutable.Base.MVector (Frames.InCore.VectorMFor a) a, Data.Vector.Generic.Base.Mutable (Frames.InCore.VectorFor a) ~ Frames.InCore.VectorMFor a, Data.Vector.Generic.Base.Vector (Frames.InCore.VectorFor a) a, Frames.InCore.RecVec rs) => Frames.InCore.RecVec (s Frames.Col.:-> a : rs)

- Frames.InCore: instance Frames.InCore.RecVec '[]

- Frames.Melt: instance (r Data.Vinyl.Lens.∈ ts, Frames.Melt.RowToColumn ts rs) => Frames.Melt.RowToColumn ts (r : rs)

- Frames.Melt: instance Frames.Melt.HasLength '[]

- Frames.Melt: instance Frames.Melt.RowToColumn ts '[]

- Frames.Melt: instance forall (k :: BOX) (t :: k) (ts :: [k]). Frames.Melt.HasLength ts => Frames.Melt.HasLength (t : ts)

- Frames.RecF: instance (Frames.RecF.ColumnHeaders cs, GHC.TypeLits.KnownSymbol s) => Frames.RecF.ColumnHeaders (s Frames.Col.:-> c : cs)

- Frames.RecF: instance (GHC.TypeLits.KnownSymbol s, GHC.Show.Show (f (Frames.Col.Col' s a)), Frames.RecF.ShowRec f rs) => Frames.RecF.ShowRec f (s Frames.Col.:-> a : rs)

- Frames.RecF: instance Frames.RecF.AsVinyl '[]

- Frames.RecF: instance Frames.RecF.AsVinyl ts => Frames.RecF.AsVinyl (s Frames.Col.:-> t : ts)

- Frames.RecF: instance Frames.RecF.ColumnHeaders '[]

- Frames.RecF: instance GHC.Base.Functor f => Frames.RecF.ShowRec f '[]

+ Frames.CSV: columnNames :: RowGen a -> [String]

+ Frames.CSV: columnSeparator :: ParserOptions -> Separator

+ Frames.CSV: columnUniverse :: RowGen a -> Proxy a

+ Frames.CSV: headerOverride :: ParserOptions -> Maybe [Text]

+ Frames.CSV: instance (Parseable t, ReadRec ts) => ReadRec ((s :-> t) : ts)

+ Frames.CSV: instance Eq ParserOptions

+ Frames.CSV: instance Eq QuotingMode

+ Frames.CSV: instance Lift ParserOptions

+ Frames.CSV: instance Lift QuotingMode

+ Frames.CSV: instance ReadRec '[]

+ Frames.CSV: instance Show ParserOptions

+ Frames.CSV: instance Show QuotingMode

+ Frames.CSV: quotingMode :: ParserOptions -> QuotingMode

+ Frames.CSV: rowTypeName :: RowGen a -> String

+ Frames.CSV: separator :: RowGen a -> Separator

+ Frames.CSV: tablePrefix :: RowGen a -> String

+ Frames.CoRec: instance (LAll Show ts, RecApplicative ts) => Show (CoRec Identity ts)

+ Frames.CoRec: instance (t ∈ ss, FoldRec ss ts) => FoldRec ss (t : ts)

+ Frames.CoRec: instance FoldRec ss '[]

+ Frames.CoRec: instance Show (CoRec (Dict Show) ts)

+ Frames.CoRec: runOp :: Op b a -> a -> b

+ Frames.Col: getCol :: (:->) a -> a

+ Frames.Col: instance (KnownSymbol s, Show a) => Show (Col' s a)

+ Frames.Col: instance (KnownSymbol s, Show a) => Show (s :-> a)

+ Frames.Col: instance Eq a => Eq (s :-> a)

+ Frames.Col: instance Floating a => Floating (s :-> a)

+ Frames.Col: instance Fractional a => Fractional (s :-> a)

+ Frames.Col: instance Monoid a => Monoid (s :-> a)

+ Frames.Col: instance Num a => Num (s :-> a)

+ Frames.Col: instance Ord a => Ord (s :-> a)

+ Frames.Col: instance Real a => Real (s :-> a)

+ Frames.Col: instance RealFloat a => RealFloat (s :-> a)

+ Frames.Col: instance RealFrac a => RealFrac (s :-> a)

+ Frames.ColumnTypeable: instance Eq a => Eq (Parsed a)

+ Frames.ColumnTypeable: instance Functor Parsed

+ Frames.ColumnTypeable: instance Ord a => Ord (Parsed a)

+ Frames.ColumnTypeable: instance Parseable Bool

+ Frames.ColumnTypeable: instance Parseable Double

+ Frames.ColumnTypeable: instance Parseable Float

+ Frames.ColumnTypeable: instance Parseable Int

+ Frames.ColumnTypeable: instance Parseable Text

+ Frames.ColumnTypeable: instance Show a => Show (Parsed a)

+ Frames.ColumnUniverse: instance (LAll Parseable ts, LAll Typeable ts, FoldRec ts ts, RecApplicative ts, Text ∈ ts) => ColumnTypeable (CoRec ColInfo ts)

+ Frames.ColumnUniverse: instance Text ∈ ts => Monoid (CoRec ColInfo ts)

+ Frames.Frame: frameLength :: Frame r -> !Int

+ Frames.Frame: frameRow :: Frame r -> Int -> r

+ Frames.Frame: instance Applicative Frame

+ Frames.Frame: instance Foldable Frame

+ Frames.Frame: instance Functor Frame

+ Frames.Frame: instance Monad Frame

+ Frames.Frame: instance Monoid (Frame r)

+ Frames.InCore: instance (MVector (VectorMFor a) a, Mutable (VectorFor a) ~ VectorMFor a, Vector (VectorFor a) a, RecVec rs) => RecVec ((s :-> a) : rs)

+ Frames.InCore: instance RecVec '[]

+ Frames.Melt: instance (r ∈ ts, RowToColumn ts rs) => RowToColumn ts (r : rs)

+ Frames.Melt: instance HasLength '[]

+ Frames.Melt: instance HasLength ts => HasLength (t : ts)

+ Frames.Melt: instance RowToColumn ts '[]

+ Frames.RecF: instance (ColumnHeaders cs, KnownSymbol s) => ColumnHeaders ((s :-> c) : cs)

+ Frames.RecF: instance (KnownSymbol s, Show (f (Col' s a)), ShowRec f rs) => ShowRec f ((s :-> a) : rs)

+ Frames.RecF: instance AsVinyl '[]

+ Frames.RecF: instance AsVinyl ts => AsVinyl ((s :-> t) : ts)

+ Frames.RecF: instance ColumnHeaders '[]

+ Frames.RecF: instance Functor f => ShowRec f '[]

- Frames.Exploration: select :: (fs ⊆ rs) => proxy fs -> Record rs -> Record fs

+ Frames.Exploration: select :: fs ⊆ rs => proxy fs -> Record rs -> Record fs

Files

Frames.cabal +1/−1
src/Frames/RecF.hs +1/−1

Frames.cabal view

@@ -1,5 +1,5 @@ name:                Frames-version:             0.1.1.0+version:             0.1.1.1 synopsis:            Data frames For working with tabular data files description:         User-friendly, type safe, runtime efficient tooling for                      working with tabular data deserialized from

src/Frames/RecF.hs view

@@ -17,7 +17,7 @@                     UnColumn, AsVinyl(..), mapMono, mapMethod,                     ShowRec, showRec, ColFun, ColumnHeaders,                      columnHeaders, reifyDict) where-import Control.Applicative ((<$>))+import Control.Applicative import Data.List (intercalate) import Data.Proxy import qualified Data.Vinyl as V