Safe Haskell	None
Language	Haskell2010

Frames

Description

User-friendly, type safe, runtime efficient tooling for working with tabular data deserialized from comma-separated values (CSV) files. The type of each row of data is inferred from data, which can then be streamed from disk, or worked with in memory.

Synopsis

module Data.Readable
(<+>) :: forall {k} (f :: k -> Type) (as :: [k]) (bs :: [k]). Rec f as -> Rec f bs -> Rec f (as ++ bs)
data Rec (a :: u -> Type) (b :: [u])
data ElField (t :: (Symbol, Type))
rsubset :: forall {k1} k2 (rs :: [k2]) (ss :: [k2]) (f :: k1 -> Type) g record (is :: [Nat]). (RecSubset record rs ss is, Functor g, RecSubsetFCtx record f) => (record f rs -> g (record f rs)) -> record f ss -> g (record f ss)
rcast :: forall {k1} {k2} (rs :: [k1]) (ss :: [k1]) (f :: k2 -> Type) record (is :: [Nat]). (RecSubset record rs ss is, RecSubsetFCtx record f) => record f ss -> record f rs
type Field = CoRec Identity
onCoRec :: forall {k1} {k2} c f (ts :: [k1]) (b :: k2) g. RPureConstrained c ts => (forall (a :: k1). (a ∈ ts, c a) => f a -> g b) -> CoRec f ts -> g b
onField :: forall c (ts :: [Type]) b. RPureConstrained c ts => (forall a. (a ∈ ts, c a) => a -> b) -> Field ts -> b
rfield :: forall f a b (s :: Symbol). Functor f => (a -> f b) -> ElField '(s, a) -> f (ElField '(s, b))
type (:.) (f :: l -> Type) (g :: k -> l) = Compose f g
module Data.Vinyl.Lens
type family AllAllSat (cs :: k) (ts :: [k1]) where ...
class AllSatisfied (cs :: k) (t :: k1)
type family AllConstrained (c :: u -> Constraint) (ts :: [u]) where ...
type family RecAll (f :: u -> Type) (rs :: [u]) (c :: Type -> Constraint) where ...
type family RDelete (r :: a) (rs :: [a]) :: [a] where ...
type (:->) (a :: Symbol) b = '(a, b)
pattern Col :: forall (s :: Symbol) t. KnownSymbol s => t -> ElField '(s, t)
module Frames.ColumnUniverse
readTable :: forall (m :: Type -> Type) (rs :: [(Symbol, Type)]). (MonadSafe m, ReadRec rs, RMap rs) => FilePath -> Producer (Record rs) m ()
readTableOpt :: forall (m :: Type -> Type) (rs :: [(Symbol, Type)]). (MonadSafe m, ReadRec rs, RMap rs) => ParserOptions -> FilePath -> Producer (Record rs) m ()
readTableMaybe :: forall (m :: Type -> Type) (rs :: [(Symbol, Type)]). (MonadSafe m, ReadRec rs, RMap rs) => FilePath -> Producer (Rec (Maybe :. ElField) rs) m ()
readTableDebug :: forall (m :: Type -> Type) (rs :: [(Symbol, Type)]). (MonadSafe m, ReadRec rs, RMap rs, RecMapMethod ShowCSV (Either Text :. ElField) rs, RecordToList rs) => FilePath -> Producer (Record rs) m ()
pipeTable :: forall (rs :: [(Symbol, Type)]) (m :: Type -> Type). (ReadRec rs, RMap rs, Monad m) => Pipe [Text] (Record rs) m ()
pipeTableMaybe :: forall (m :: Type -> Type) (rs :: [(Symbol, Type)]). (Monad m, ReadRec rs, RMap rs) => Pipe [Text] (Rec (Maybe :. ElField) rs) m ()
module Frames.Exploration
module Frames.Frame
inCoreAoS :: forall m (rs :: [(Symbol, Type)]). (PrimMonad m, MonadIO m, MonadMask m, RecVec rs) => Producer (Record rs) (SafeT m) () -> m (FrameRec rs)
inCoreAoS' :: forall m (rs :: [(Symbol, Type)]) (ss :: [(Symbol, Type)]). (PrimMonad m, MonadIO m, MonadMask m, RecVec rs) => (Rec ((->) Int :. ElField) rs -> Rec ((->) Int :. ElField) ss) -> Producer (Record rs) (SafeT m) () -> m (FrameRec ss)
inCore :: forall m (rs :: [(Symbol, Type)]) (n :: Type -> Type). (PrimMonad m, MonadIO m, MonadMask m, RecVec rs, Monad n) => Producer (Record rs) (SafeT m) () -> m (Producer (Record rs) n ())
inCoreSoA :: forall m (rs :: [(Symbol, Type)]). (PrimMonad m, MonadIO m, MonadMask m, RecVec rs) => Producer (Record rs) (SafeT m) () -> m (Int, Rec ((->) Int :. ElField) rs)
toAoS :: forall (rs :: [(Symbol, Type)]). Int -> Rec ((->) Int :. ElField) rs -> FrameRec rs
toFrame :: forall f (rs :: [(Symbol, Type)]). (Foldable f, RecVec rs) => f (Record rs) -> Frame (Record rs)
filterFrame :: forall (rs :: [(Symbol, Type)]). RecVec rs => (Record rs -> Bool) -> FrameRec rs -> FrameRec rs
module Frames.Joins
melt :: forall (vs :: [(Symbol, Type)]) (ts :: [(Symbol, Type)]) (ss :: [(Symbol, Type)]) proxy. (vs ⊆ ts, ss ⊆ ts, vs ~ RDeleteAll ss ts, HasLength vs, Disjoint ss ts ~ 'True, ts ≅ (vs ++ ss), ColumnHeaders vs, RowToColumn vs vs) => proxy ss -> FrameRec ts -> FrameRec (ss ++ '["value" :-> CoRec ElField vs])
meltRow :: forall (vs :: [(Symbol, Type)]) (ts :: [(Symbol, Type)]) (ss :: [(Symbol, Type)]) proxy. (vs ⊆ ts, ss ⊆ ts, vs ~ RDeleteAll ss ts, Disjoint ss ts ~ 'True, ts ≅ (vs ++ ss), ColumnHeaders vs, RowToColumn vs vs) => proxy ss -> Record ts -> [Record (ss ++ '["value" :-> CoRec ElField vs])]
module Frames.Rec
module Frames.RecF
tableTypes :: String -> FilePath -> DecsQ
tableTypes' :: forall (a :: [Type]) c. (c ~ CoRec ColInfo a, ColumnTypeable c, Semigroup c, RPureConstrained (ShowF ColInfo) a) => RowGen a -> DecsQ
declareColumn :: Text -> Name -> DecsQ
module Frames.TypeLevel
class (MonadCatch m, MonadMask m, MonadIO m, MonadIO (Base m)) => MonadSafe (m :: Type -> Type)
data SafeT (m :: Type -> Type) r
runSafeT :: (MonadMask m, MonadIO m) => SafeT m r -> m r
runSafeP :: forall (m :: Type -> Type) r. (MonadMask m, MonadIO m) => Effect (SafeT m) r -> Effect' m r
runSafeEffect :: (MonadIO m, MonadMask m) => Effect (SafeT m) r -> m r
data Text

Documentation

module Data.Readable

(<+>) :: forall {k} (f :: k -> Type) (as :: [k]) (bs :: [k]). Rec f as -> Rec f bs -> Rec f (as ++ bs) infixr 5 #

A shorthand for rappend.

data Rec (a :: u -> Type) (b :: [u]) #

A record is parameterized by a universe u, an interpretation f and a list of rows rs. The labels or indices of the record are given by inhabitants of the kind u; the type of values at any label r :: u is given by its interpretation f r :: *.

Instances

Instances details

RecSubset (Rec :: (k -> Type) -> [k] -> Type) ('[] :: [k]) (ss :: [k]) ('[] :: [Nat])

Instance details

Defined in Data.Vinyl.Lens

Methods

rsubsetC :: forall g (f :: k -> Type). (Functor g, RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) f) => (Rec f ('[] :: [k]) -> g (Rec f ('[] :: [k]))) -> Rec f ss -> g (Rec f ss) #

rcastC :: forall (f :: k -> Type). RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) f => Rec f ss -> Rec f ('[] :: [k]) #

rreplaceC :: forall (f :: k -> Type). RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) f => Rec f ('[] :: [k]) -> Rec f ss -> Rec f ss #

(RElem r ss i, RSubset rs ss is) => RecSubset (Rec :: (k -> Type) -> [k] -> Type) (r ': rs :: [k]) (ss :: [k]) (i ': is)

Instance details

Defined in Data.Vinyl.Lens

Methods

rsubsetC :: forall g (f :: k -> Type). (Functor g, RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) f) => (Rec f (r ': rs) -> g (Rec f (r ': rs))) -> Rec f ss -> g (Rec f ss) #

rcastC :: forall (f :: k -> Type). RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) f => Rec f ss -> Rec f (r ': rs) #

rreplaceC :: forall (f :: k -> Type). RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) f => Rec f (r ': rs) -> Rec f ss -> Rec f ss #

RecElem (Rec :: (a -> Type) -> [a] -> Type) (r :: a) (r' :: a) (r ': rs :: [a]) (r' ': rs :: [a]) 'Z

Instance details

Defined in Data.Vinyl.Lens

Methods

rlensC :: (Functor g, RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) f) => (f r -> g (f r')) -> Rec f (r ': rs) -> g (Rec f (r' ': rs)) #

rgetC :: (RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) f, r ~ r') => Rec f (r ': rs) -> f r #

rputC :: RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) f => f r' -> Rec f (r ': rs) -> Rec f (r' ': rs) #

(RIndex r (s ': rs) ~ 'S i, RecElem (Rec :: (a -> Type) -> [a] -> Type) r r' rs rs' i) => RecElem (Rec :: (a -> Type) -> [a] -> Type) (r :: a) (r' :: a) (s ': rs :: [a]) (s ': rs' :: [a]) ('S i)

Instance details

Defined in Data.Vinyl.Lens

Methods

rlensC :: (Functor g, RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) f) => (f r -> g (f r')) -> Rec f (s ': rs) -> g (Rec f (s ': rs')) #

rgetC :: (RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) f, r ~ r') => Rec f (s ': rs) -> f r #

rputC :: RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) f => f r' -> Rec f (s ': rs) -> Rec f (s ': rs') #

(AllCols Grouping rs, Grouping (Record rs), Grouping (ElField (s :-> r)), Grouping r) => Grouping (Record ((s :-> r) ': rs)) Source #

Instance details

Defined in Frames.ExtraInstances

Methods

grouping :: Group (Record ((s :-> r) ': rs)) #

Grouping (Record ('[] :: [(Symbol, Type)])) Source #

Instance details

Defined in Frames.ExtraInstances

Methods

grouping :: Group (Record ('[] :: [(Symbol, Type)])) #

TestCoercion f => TestCoercion (Rec f :: [u] -> Type)

Instance details

Defined in Data.Vinyl.Core

Methods

testCoercion :: forall (a :: [u]) (b :: [u]). Rec f a -> Rec f b -> Maybe (Coercion a b) #

TestEquality f => TestEquality (Rec f :: [u] -> Type)

Instance details

Defined in Data.Vinyl.Core

Methods

testEquality :: forall (a :: [u]) (b :: [u]). Rec f a -> Rec f b -> Maybe (a :~: b) #

(Storable (f r), Storable (Rec f rs)) => Storable (Rec f (r ': rs))

Instance details

Defined in Data.Vinyl.Core

Methods

sizeOf :: Rec f (r ': rs) -> Int #

alignment :: Rec f (r ': rs) -> Int #

peekElemOff :: Ptr (Rec f (r ': rs)) -> Int -> IO (Rec f (r ': rs)) #

pokeElemOff :: Ptr (Rec f (r ': rs)) -> Int -> Rec f (r ': rs) -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Rec f (r ': rs)) #

pokeByteOff :: Ptr b -> Int -> Rec f (r ': rs) -> IO () #

peek :: Ptr (Rec f (r ': rs)) -> IO (Rec f (r ': rs)) #

poke :: Ptr (Rec f (r ': rs)) -> Rec f (r ': rs) -> IO () #

Storable (Rec f ('[] :: [u]))

Instance details

Defined in Data.Vinyl.Core

Methods

sizeOf :: Rec f ('[] :: [u]) -> Int #

alignment :: Rec f ('[] :: [u]) -> Int #

peekElemOff :: Ptr (Rec f ('[] :: [u])) -> Int -> IO (Rec f ('[] :: [u])) #

pokeElemOff :: Ptr (Rec f ('[] :: [u])) -> Int -> Rec f ('[] :: [u]) -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Rec f ('[] :: [u])) #

pokeByteOff :: Ptr b -> Int -> Rec f ('[] :: [u]) -> IO () #

peek :: Ptr (Rec f ('[] :: [u])) -> IO (Rec f ('[] :: [u])) #

poke :: Ptr (Rec f ('[] :: [u])) -> Rec f ('[] :: [u]) -> IO () #

(Monoid (f r), Monoid (Rec f rs)) => Monoid (Rec f (r ': rs))

Instance details

Defined in Data.Vinyl.Core

Methods

mempty :: Rec f (r ': rs) #

mappend :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) #

mconcat :: [Rec f (r ': rs)] -> Rec f (r ': rs) #

Monoid (Rec f ('[] :: [u]))

Instance details

Defined in Data.Vinyl.Core

Methods

mempty :: Rec f ('[] :: [u]) #

mappend :: Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) #

mconcat :: [Rec f ('[] :: [u])] -> Rec f ('[] :: [u]) #

(Semigroup (f r), Semigroup (Rec f rs)) => Semigroup (Rec f (r ': rs))

Instance details

Defined in Data.Vinyl.Core

Methods

(<>) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) #

sconcat :: NonEmpty (Rec f (r ': rs)) -> Rec f (r ': rs) #

stimes :: Integral b => b -> Rec f (r ': rs) -> Rec f (r ': rs) #

Semigroup (Rec f ('[] :: [u]))

Instance details

Defined in Data.Vinyl.Core

Methods

(<>) :: Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) #

sconcat :: NonEmpty (Rec f ('[] :: [u])) -> Rec f ('[] :: [u]) #

stimes :: Integral b => b -> Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) #

Generic (Rec f rs) => Generic (Rec f (r ': rs))

Instance details

Defined in Data.Vinyl.Core

Associated Types

type Rep (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core type Rep (Rec f (r ': rs)) = C1 ('MetaCons ":&" ('InfixI 'RightAssociative 7) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (f r)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rep (Rec f rs)))

Methods

from :: Rec f (r ': rs) -> Rep (Rec f (r ': rs)) x #

to :: Rep (Rec f (r ': rs)) x -> Rec f (r ': rs) #

Generic (Rec f ('[] :: [u]))

Instance details

Defined in Data.Vinyl.Core

Associated Types

type Rep (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core type Rep (Rec f ('[] :: [u])) = C1 ('MetaCons "RNil" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (U1 :: Type -> Type))

Methods

from :: Rec f ('[] :: [u]) -> Rep (Rec f ('[] :: [u])) x #

to :: Rep (Rec f ('[] :: [u])) x -> Rec f ('[] :: [u]) #

(RMap rs, ReifyConstraint Show f rs, RecordToList rs) => Show (Rec f rs)

Records may be shown insofar as their points may be shown. reifyConstraint is used to great effect here.

Instance details

Defined in Data.Vinyl.Core

Methods

showsPrec :: Int -> Rec f rs -> ShowS #

show :: Rec f rs -> String #

showList :: [Rec f rs] -> ShowS #

NFData (Rec f ('[] :: [u])) Source #

Instance details

Defined in Frames.ExtraInstances

Methods

rnf :: Rec f ('[] :: [u]) -> () #

ReifyConstraint NFData f xs => NFData (Rec f xs)

Instance details

Defined in Data.Vinyl.Core

Methods

rnf :: Rec f xs -> () #

(Eq (f r), Eq (Rec f rs)) => Eq (Rec f (r ': rs))

Instance details

Defined in Data.Vinyl.Core

Methods

(==) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool #

(/=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool #

Eq (Rec f ('[] :: [u]))

Instance details

Defined in Data.Vinyl.Core

Methods

(==) :: Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) -> Bool #

(/=) :: Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) -> Bool #

(Ord (f r), Ord (Rec f rs)) => Ord (Rec f (r ': rs))

Instance details

Defined in Data.Vinyl.Core

Methods

compare :: Rec f (r ': rs) -> Rec f (r ': rs) -> Ordering #

(<) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool #

(<=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool #

(>) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool #

(>=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool #

max :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) #

min :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) #

Ord (Rec f ('[] :: [u]))

Instance details

Defined in Data.Vinyl.Core

Methods

compare :: Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) -> Ordering #

(<) :: Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) -> Bool #

(<=) :: Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) -> Bool #

(>) :: Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) -> Bool #

(>=) :: Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) -> Bool #

max :: Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) #

min :: Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) -> Rec f ('[] :: [u]) #

type RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) (f :: k -> Type)

Instance details

Defined in Data.Vinyl.Lens

type RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) (f :: k -> Type) = ()

type RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) (f :: k -> Type)

Instance details

Defined in Data.Vinyl.Lens

type RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) (f :: k -> Type) = ()

type RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) (f :: a -> Type)

Instance details

Defined in Data.Vinyl.Lens

type RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) (f :: a -> Type) = ()

type RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) (f :: a -> Type)

Instance details

Defined in Data.Vinyl.Lens

type RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) (f :: a -> Type) = ()

type Rep (Rec f (r ': rs))

Instance details

Defined in Data.Vinyl.Core

type Rep (Rec f (r ': rs)) = C1 ('MetaCons ":&" ('InfixI 'RightAssociative 7) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (f r)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rep (Rec f rs)))

type Rep (Rec f ('[] :: [u]))

Instance details

Defined in Data.Vinyl.Core

type Rep (Rec f ('[] :: [u])) = C1 ('MetaCons "RNil" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (U1 :: Type -> Type))

data ElField (t :: (Symbol, Type)) #

A value with a phantom Symbol label. It is not a Haskell Functor, but it is used in many of the same places a Functor is used in vinyl.

Morally: newtype ElField (s, t) = Field t But GHC doesn't allow that

Instances

Instances details

(KnownSymbol s, Storable t) => Storable (ElField '(s, t))

Instance details

Defined in Data.Vinyl.Functor

Methods

sizeOf :: ElField '(s, t) -> Int #

alignment :: ElField '(s, t) -> Int #

peekElemOff :: Ptr (ElField '(s, t)) -> Int -> IO (ElField '(s, t)) #

pokeElemOff :: Ptr (ElField '(s, t)) -> Int -> ElField '(s, t) -> IO () #

peekByteOff :: Ptr b -> Int -> IO (ElField '(s, t)) #

pokeByteOff :: Ptr b -> Int -> ElField '(s, t) -> IO () #

peek :: Ptr (ElField '(s, t)) -> IO (ElField '(s, t)) #

poke :: Ptr (ElField '(s, t)) -> ElField '(s, t) -> IO () #

(KnownSymbol s, Monoid t) => Monoid (ElField '(s, t))

Instance details

Defined in Data.Vinyl.Functor

Methods

mempty :: ElField '(s, t) #

mappend :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) #

mconcat :: [ElField '(s, t)] -> ElField '(s, t) #

Semigroup t => Semigroup (ElField '(s, t))

Instance details

Defined in Data.Vinyl.Functor

Methods

(<>) :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) #

sconcat :: NonEmpty (ElField '(s, t)) -> ElField '(s, t) #

stimes :: Integral b => b -> ElField '(s, t) -> ElField '(s, t) #

(Floating t, KnownSymbol s) => Floating (ElField '(s, t))

Instance details

Defined in Data.Vinyl.Functor

Methods

pi :: ElField '(s, t) #

exp :: ElField '(s, t) -> ElField '(s, t) #

log :: ElField '(s, t) -> ElField '(s, t) #

sqrt :: ElField '(s, t) -> ElField '(s, t) #

(**) :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) #

logBase :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) #

sin :: ElField '(s, t) -> ElField '(s, t) #

cos :: ElField '(s, t) -> ElField '(s, t) #

tan :: ElField '(s, t) -> ElField '(s, t) #

asin :: ElField '(s, t) -> ElField '(s, t) #

acos :: ElField '(s, t) -> ElField '(s, t) #

atan :: ElField '(s, t) -> ElField '(s, t) #

sinh :: ElField '(s, t) -> ElField '(s, t) #

cosh :: ElField '(s, t) -> ElField '(s, t) #

tanh :: ElField '(s, t) -> ElField '(s, t) #

asinh :: ElField '(s, t) -> ElField '(s, t) #

acosh :: ElField '(s, t) -> ElField '(s, t) #

atanh :: ElField '(s, t) -> ElField '(s, t) #

log1p :: ElField '(s, t) -> ElField '(s, t) #

expm1 :: ElField '(s, t) -> ElField '(s, t) #

log1pexp :: ElField '(s, t) -> ElField '(s, t) #

log1mexp :: ElField '(s, t) -> ElField '(s, t) #

KnownSymbol s => Generic (ElField '(s, a))

Instance details

Defined in Data.Vinyl.Functor

Associated Types

type Rep (ElField '(s, a))
Instance details Defined in Data.Vinyl.Functor type Rep (ElField '(s, a)) = C1 ('MetaCons s 'PrefixI 'False) (Rec0 a)

Methods

from :: ElField '(s, a) -> Rep (ElField '(s, a)) x #

to :: Rep (ElField '(s, a)) x -> ElField '(s, a) #

(Num t, KnownSymbol s) => Num (ElField '(s, t))

Instance details

Defined in Data.Vinyl.Functor

Methods

(+) :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) #

(-) :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) #

(*) :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) #

negate :: ElField '(s, t) -> ElField '(s, t) #

abs :: ElField '(s, t) -> ElField '(s, t) #

signum :: ElField '(s, t) -> ElField '(s, t) #

fromInteger :: Integer -> ElField '(s, t) #

(Fractional t, KnownSymbol s) => Fractional (ElField '(s, t))

Instance details

Defined in Data.Vinyl.Functor

Methods

(/) :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) #

recip :: ElField '(s, t) -> ElField '(s, t) #

fromRational :: Rational -> ElField '(s, t) #

(Real t, KnownSymbol s) => Real (ElField '(s, t))

Instance details

Defined in Data.Vinyl.Functor

Methods

toRational :: ElField '(s, t) -> Rational #

(RealFrac t, KnownSymbol s) => RealFrac (ElField '(s, t))

Instance details

Defined in Data.Vinyl.Functor

Methods

properFraction :: Integral b => ElField '(s, t) -> (b, ElField '(s, t)) #

truncate :: Integral b => ElField '(s, t) -> b #

round :: Integral b => ElField '(s, t) -> b #

ceiling :: Integral b => ElField '(s, t) -> b #

floor :: Integral b => ElField '(s, t) -> b #

(Show t, KnownSymbol s) => Show (ElField '(s, t))

Instance details

Defined in Data.Vinyl.Functor

Methods

showsPrec :: Int -> ElField '(s, t) -> ShowS #

show :: ElField '(s, t) -> String #

showList :: [ElField '(s, t)] -> ShowS #

NFData a => NFData (ElField (s :-> a)) Source #

Instance details

Defined in Frames.ExtraInstances

Methods

rnf :: ElField (s :-> a) -> () #

(AllCols Grouping rs, Grouping (Record rs), Grouping (ElField (s :-> r)), Grouping r) => Grouping (Record ((s :-> r) ': rs)) Source #

Instance details

Defined in Frames.ExtraInstances

Methods

grouping :: Group (Record ((s :-> r) ': rs)) #

Grouping (Record ('[] :: [(Symbol, Type)])) Source #

Instance details

Defined in Frames.ExtraInstances

Methods

grouping :: Group (Record ('[] :: [(Symbol, Type)])) #

Grouping a => Grouping (ElField (s :-> a)) Source #

Instance details

Defined in Frames.ExtraInstances

Methods

grouping :: Group (ElField (s :-> a)) #

Eq t => Eq (ElField '(s, t))

Instance details

Defined in Data.Vinyl.Functor

Methods

(==) :: ElField '(s, t) -> ElField '(s, t) -> Bool #

(/=) :: ElField '(s, t) -> ElField '(s, t) -> Bool #

Ord t => Ord (ElField '(s, t))

Instance details

Defined in Data.Vinyl.Functor

Methods

compare :: ElField '(s, t) -> ElField '(s, t) -> Ordering #

(<) :: ElField '(s, t) -> ElField '(s, t) -> Bool #

(<=) :: ElField '(s, t) -> ElField '(s, t) -> Bool #

(>) :: ElField '(s, t) -> ElField '(s, t) -> Bool #

(>=) :: ElField '(s, t) -> ElField '(s, t) -> Bool #

max :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) #

min :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) #

KnownSymbol s => IsoHKD ElField ('(s, a) :: (Symbol, Type))

Work with values of type ElField '(s,a) as if they were of type a.

Instance details

Defined in Data.Vinyl.XRec

Associated Types

type HKD ElField ('(s, a) :: (Symbol, Type))
Instance details Defined in Data.Vinyl.XRec type HKD ElField ('(s, a) :: (Symbol, Type)) = a

Methods

unHKD :: HKD ElField '(s, a) -> ElField '(s, a) #

toHKD :: ElField '(s, a) -> HKD ElField '(s, a) #

(i ~ RIndex t ts, NatToInt i, FieldOffset ElField ts t, Storable (Rec ElField ts), AllConstrained (FieldOffset ElField ts) ts) => RecElem (SRec2 ElField) (t :: (Symbol, Type)) (t :: (Symbol, Type)) (ts :: [(Symbol, Type)]) (ts :: [(Symbol, Type)]) i

Field accessors for SRec2 specialized to ElField as the functor.

Instance details

Defined in Data.Vinyl.SRec

Associated Types

type RecElemFCtx (SRec2 ElField) (f :: (Symbol, Type) -> Type)
Instance details Defined in Data.Vinyl.SRec type RecElemFCtx (SRec2 ElField) (f :: (Symbol, Type) -> Type) = f ~ ElField

Methods

rlensC :: (Functor g, RecElemFCtx (SRec2 ElField) f) => (f t -> g (f t)) -> SRec2 ElField f ts -> g (SRec2 ElField f ts) #

rgetC :: (RecElemFCtx (SRec2 ElField) f, t ~ t) => SRec2 ElField f ts -> f t #

rputC :: RecElemFCtx (SRec2 ElField) f => f t -> SRec2 ElField f ts -> SRec2 ElField f ts #

(is ~ RImage rs ss, RecSubset (Rec :: ((Symbol, Type) -> Type) -> [(Symbol, Type)] -> Type) rs ss is, Storable (Rec ElField rs), Storable (Rec ElField ss), RPureConstrained (FieldOffset ElField ss) rs, RPureConstrained (FieldOffset ElField rs) rs, RFoldMap rs, RMap rs, RApply rs) => RecSubset (SRec2 ElField) (rs :: [(Symbol, Type)]) (ss :: [(Symbol, Type)]) is

Instance details

Defined in Data.Vinyl.SRec

Associated Types

type RecSubsetFCtx (SRec2 ElField) (f :: (Symbol, Type) -> Type)
Instance details Defined in Data.Vinyl.SRec type RecSubsetFCtx (SRec2 ElField) (f :: (Symbol, Type) -> Type) = f ~ ElField

Methods

rsubsetC :: forall g (f :: (Symbol, Type) -> Type). (Functor g, RecSubsetFCtx (SRec2 ElField) f) => (SRec2 ElField f rs -> g (SRec2 ElField f rs)) -> SRec2 ElField f ss -> g (SRec2 ElField f ss) #

rcastC :: forall (f :: (Symbol, Type) -> Type). RecSubsetFCtx (SRec2 ElField) f => SRec2 ElField f ss -> SRec2 ElField f rs #

rreplaceC :: forall (f :: (Symbol, Type) -> Type). RecSubsetFCtx (SRec2 ElField) f => SRec2 ElField f rs -> SRec2 ElField f ss -> SRec2 ElField f ss #

type Rep (ElField '(s, a))

Instance details

Defined in Data.Vinyl.Functor

type Rep (ElField '(s, a)) = C1 ('MetaCons s 'PrefixI 'False) (Rec0 a)

type HKD ElField ('(s, a) :: (Symbol, Type))

Instance details

Defined in Data.Vinyl.XRec

type HKD ElField ('(s, a) :: (Symbol, Type)) = a

type RecElemFCtx (SRec2 ElField) (f :: (Symbol, Type) -> Type)

Instance details

Defined in Data.Vinyl.SRec

type RecElemFCtx (SRec2 ElField) (f :: (Symbol, Type) -> Type) = f ~ ElField

type RecSubsetFCtx (SRec2 ElField) (f :: (Symbol, Type) -> Type)

Instance details

Defined in Data.Vinyl.SRec

type RecSubsetFCtx (SRec2 ElField) (f :: (Symbol, Type) -> Type) = f ~ ElField

rsubset :: forall {k1} k2 (rs :: [k2]) (ss :: [k2]) (f :: k1 -> Type) g record (is :: [Nat]). (RecSubset record rs ss is, Functor g, RecSubsetFCtx record f) => (record f rs -> g (record f rs)) -> record f ss -> g (record f ss) #

A lens into a slice of the larger record. This is rsubsetC with the type arguments reordered for more convenient usage with TypeApplications.

rcast :: forall {k1} {k2} (rs :: [k1]) (ss :: [k1]) (f :: k2 -> Type) record (is :: [Nat]). (RecSubset record rs ss is, RecSubsetFCtx record f) => record f ss -> record f rs #

Takes a larger record to a smaller one by forgetting fields. This is rcastC with the type arguments reordered for more convenient usage with TypeApplications.

type Field = CoRec Identity #

A Field of a Rec Identity is a CoRec Identity.

onCoRec :: forall {k1} {k2} c f (ts :: [k1]) (b :: k2) g. RPureConstrained c ts => (forall (a :: k1). (a ∈ ts, c a) => f a -> g b) -> CoRec f ts -> g b #

Apply methods from a type class to a CoRec. Intended for use with TypeApplications, e.g. onCoRec @Show show r

onField :: forall c (ts :: [Type]) b. RPureConstrained c ts => (forall a. (a ∈ ts, c a) => a -> b) -> Field ts -> b #

Apply a type class method to a Field. Intended for use with TypeApplications, e.g. onField @Show show r.

rfield :: forall f a b (s :: Symbol). Functor f => (a -> f b) -> ElField '(s, a) -> f (ElField '(s, b)) #

Lens for an ElField's data payload.

type (:.) (f :: l -> Type) (g :: k -> l) = Compose f g infixr 9 #

module Data.Vinyl.Lens

type family AllAllSat (cs :: k) (ts :: [k1]) where ... #

Constraint that all types in a type-level list satisfy each constraint from a list of constraints.

AllAllSat cs ts should be equivalent to AllConstrained (AllSatisfied cs) ts if partial application of type families were legal.

Equations

AllAllSat (cs :: k1) ('[] :: [k2]) = ()
AllAllSat (cs :: k1) (t ': ts :: [k2]) = (AllSatisfied cs t, AllAllSat cs ts)

class AllSatisfied (cs :: k) (t :: k1) #

Constraint that each Constraint in a type-level list is satisfied by a particular type.

Instances

Instances details

AllSatisfied ('[] :: [a]) (t :: k)
Instance details Defined in Data.Vinyl.TypeLevel
(c t, AllSatisfied cs t) => AllSatisfied (c ': cs :: [k -> Constraint]) (t :: k)
Instance details Defined in Data.Vinyl.TypeLevel

type family AllConstrained (c :: u -> Constraint) (ts :: [u]) where ... #

Constraint that all types in a type-level list satisfy a constraint.

Equations

AllConstrained (c :: u -> Constraint) ('[] :: [u]) = ()
AllConstrained (c :: u -> Constraint) (t ': ts :: [u]) = (c t, AllConstrained c ts)

type family RecAll (f :: u -> Type) (rs :: [u]) (c :: Type -> Constraint) where ... #

A constraint-former which applies to every field in a record.

Equations

RecAll (f :: u -> Type) ('[] :: [u]) c = ()
RecAll (f :: u -> Type) (r ': rs :: [u]) c = (c (f r), RecAll f rs c)

type family RDelete (r :: a) (rs :: [a]) :: [a] where ... #

Remove the first occurrence of a type from a type-level list.

Equations

RDelete (r :: a) (r ': rs :: [a]) = rs
RDelete (r :: a) (s ': rs :: [a]) = s ': RDelete r rs

type (:->) (a :: Symbol) b = '(a, b) Source #

pattern Col :: forall (s :: Symbol) t. KnownSymbol s => t -> ElField '(s, t) Source #

module Frames.ColumnUniverse

readTable :: forall (m :: Type -> Type) (rs :: [(Symbol, Type)]). (MonadSafe m, ReadRec rs, RMap rs) => FilePath -> Producer (Record rs) m () Source #

Returns a producer of rows for which each column was successfully parsed.

readTableOpt :: forall (m :: Type -> Type) (rs :: [(Symbol, Type)]). (MonadSafe m, ReadRec rs, RMap rs) => ParserOptions -> FilePath -> Producer (Record rs) m () Source #

Returns a producer of rows for which each column was successfully parsed.

readTableMaybe :: forall (m :: Type -> Type) (rs :: [(Symbol, Type)]). (MonadSafe m, ReadRec rs, RMap rs) => FilePath -> Producer (Rec (Maybe :. ElField) rs) m () Source #

Produce rows where any given entry can fail to parse.

readTableDebug :: forall (m :: Type -> Type) (rs :: [(Symbol, Type)]). (MonadSafe m, ReadRec rs, RMap rs, RecMapMethod ShowCSV (Either Text :. ElField) rs, RecordToList rs) => FilePath -> Producer (Record rs) m () Source #

Similar to readTable except that rows that fail to parse are printed to stderr with columns that failed to parse printed as "Left rawtext" while those that were successfully parsed are shown as "Right text".

pipeTable :: forall (rs :: [(Symbol, Type)]) (m :: Type -> Type). (ReadRec rs, RMap rs, Monad m) => Pipe [Text] (Record rs) m () Source #

Pipe lines of CSV text into rows for which each column was successfully parsed.

pipeTableMaybe :: forall (m :: Type -> Type) (rs :: [(Symbol, Type)]). (Monad m, ReadRec rs, RMap rs) => Pipe [Text] (Rec (Maybe :. ElField) rs) m () Source #

Stream lines of CSV data into rows of ’Rec’ values where any given entry can fail to parse.

module Frames.Exploration

module Frames.Frame

inCoreAoS :: forall m (rs :: [(Symbol, Type)]). (PrimMonad m, MonadIO m, MonadMask m, RecVec rs) => Producer (Record rs) (SafeT m) () -> m (FrameRec rs) Source #

Stream a finite sequence of rows into an efficient in-memory representation for further manipulation. Each column of the input table will be stored optimally based on its type, making use of the resulting generators a matter of indexing into a densely packed representation. Returns a Frame that provides a function to index into the table.

inCoreAoS' :: forall m (rs :: [(Symbol, Type)]) (ss :: [(Symbol, Type)]). (PrimMonad m, MonadIO m, MonadMask m, RecVec rs) => (Rec ((->) Int :. ElField) rs -> Rec ((->) Int :. ElField) ss) -> Producer (Record rs) (SafeT m) () -> m (FrameRec ss) Source #

Like inCoreAoS, but applies the provided function to the record of columns before building the Frame.

inCore :: forall m (rs :: [(Symbol, Type)]) (n :: Type -> Type). (PrimMonad m, MonadIO m, MonadMask m, RecVec rs, Monad n) => Producer (Record rs) (SafeT m) () -> m (Producer (Record rs) n ()) Source #

Stream a finite sequence of rows into an efficient in-memory representation for further manipulation. Each column of the input table will be stored optimally based on its type, making use of the resulting generator a matter of indexing into a densely packed representation.

inCoreSoA :: forall m (rs :: [(Symbol, Type)]). (PrimMonad m, MonadIO m, MonadMask m, RecVec rs) => Producer (Record rs) (SafeT m) () -> m (Int, Rec ((->) Int :. ElField) rs) Source #

Stream a finite sequence of rows into an efficient in-memory representation for further manipulation. Each column of the input table will be stored optimally based on its type, making use of the resulting generators a matter of indexing into a densely packed representation. Returns the number of rows and a record of column 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.

toAoS :: forall (rs :: [(Symbol, Type)]). Int -> Rec ((->) Int :. ElField) rs -> FrameRec rs Source #

Convert a structure-of-arrays to an array-of-structures. This can simplify usage of an in-memory representation.

toFrame :: forall f (rs :: [(Symbol, Type)]). (Foldable f, RecVec rs) => f (Record rs) -> Frame (Record rs) Source #

Build a Frame from a collection of Records using efficient column-based storage.

filterFrame :: forall (rs :: [(Symbol, Type)]). RecVec rs => (Record rs -> Bool) -> FrameRec rs -> FrameRec rs Source #

Keep only those rows of a FrameRec that satisfy a predicate.

module Frames.Joins

melt :: forall (vs :: [(Symbol, Type)]) (ts :: [(Symbol, Type)]) (ss :: [(Symbol, Type)]) proxy. (vs ⊆ ts, ss ⊆ ts, vs ~ RDeleteAll ss ts, HasLength vs, Disjoint ss ts ~ 'True, ts ≅ (vs ++ ss), ColumnHeaders vs, RowToColumn vs vs) => proxy ss -> FrameRec ts -> FrameRec (ss ++ '["value" :-> CoRec ElField vs]) Source #

Applies meltRow to each row of a FrameRec.

meltRow :: forall (vs :: [(Symbol, Type)]) (ts :: [(Symbol, Type)]) (ss :: [(Symbol, Type)]) proxy. (vs ⊆ ts, ss ⊆ ts, vs ~ RDeleteAll ss ts, Disjoint ss ts ~ 'True, ts ≅ (vs ++ ss), ColumnHeaders vs, RowToColumn vs vs) => proxy ss -> Record ts -> [Record (ss ++ '["value" :-> CoRec ElField vs])] Source #

Like melt in the reshape2 package for the R language. It stacks multiple columns into a single column over multiple rows. Takes a specification of the id columns that remain unchanged. The remaining columns will be stacked.

Suppose we have a record, r :: Record [Name,Age,Weight]. If we apply melt [pr1|Name|] r, we get two values with type Record [Name, "value" :-> CoRec Identity [Age,Weight]]. The first will contain Age in the value column, and the second will contain Weight in the value column.

module Frames.Rec

module Frames.RecF

tableTypes :: String -> FilePath -> DecsQ Source #

Generate types for a row of a table. This will be something like Record ["x" :-> a, "y" :-> b, "z" :-> c]. This splice additionally generates a type synonym for each column, and a proxy value of that type. If the CSV file has column names "foo", "bar", and "baz", then this will declare type Foo = "foo" :-> Int, for example, foo = rlens @Foo, and foo' = rlens' @Foo.

See tableTypes' if you need to customize parsing to do things like override the separator character (default is a single comma), or supply column names.

tableTypes' :: forall (a :: [Type]) c. (c ~ CoRec ColInfo a, ColumnTypeable c, Semigroup c, RPureConstrained (ShowF ColInfo) a) => RowGen a -> DecsQ Source #

Generate a type for a row of a table. This will be something like Record ["x" :-> a, "y" :-> b, "z" :-> c]. Additionally generates a type synonym for each column, and a proxy value of that type. If the CSV file has column names "foo", "bar", and "baz", then this will declare type Foo = "foo" :-> Int, for example, foo = rlens @Foo, and foo' = rlens' @Foo.

The supplied RowGen value is also used to produce a value of type ParserOptions that can be passed to functions like readTableOpt. This is useful if you need to customize parsing to support something like a special separator string. This value of type ParserOptions will be given a name based on the row type name. If the row type is Row, then thsi splice will generate a value rowParser :: ParserOptions.

declareColumn :: Text -> Name -> DecsQ Source #

Splice for manually declaring a column of a given type. For example, declareColumn "x2" ''Double will declare a type synonym type X2 = "x2" :-> Double and a lens x2.

module Frames.TypeLevel

class (MonadCatch m, MonadMask m, MonadIO m, MonadIO (Base m)) => MonadSafe (m :: Type -> Type) #

MonadSafe lets you register and release finalizers that execute in a Base monad

Minimal complete definition

liftBase, register, release

Instances

Instances details

MonadSafe m => MonadSafe (CatchT m)

Instance details

Defined in Pipes.Safe

Associated Types

type Base (CatchT m)
Instance details Defined in Pipes.Safe type Base (CatchT m) = Base m

Methods

liftBase :: Base (CatchT m) r -> CatchT m r #

register :: Base (CatchT m) () -> CatchT m ReleaseKey #

release :: ReleaseKey -> CatchT m () #

(MonadIO m, MonadCatch m, MonadMask m) => MonadSafe (SafeT m)

Instance details

Defined in Pipes.Safe

Associated Types

type Base (SafeT m)
Instance details Defined in Pipes.Safe type Base (SafeT m) = m

Methods

liftBase :: Base (SafeT m) r -> SafeT m r #

register :: Base (SafeT m) () -> SafeT m ReleaseKey #

release :: ReleaseKey -> SafeT m () #

MonadSafe m => MonadSafe (IdentityT m)

Instance details

Defined in Pipes.Safe

Associated Types

type Base (IdentityT m)
Instance details Defined in Pipes.Safe type Base (IdentityT m) = Base m

Methods

liftBase :: Base (IdentityT m) r -> IdentityT m r #

register :: Base (IdentityT m) () -> IdentityT m ReleaseKey #

release :: ReleaseKey -> IdentityT m () #

MonadSafe m => MonadSafe (ReaderT i m)

Instance details

Defined in Pipes.Safe

Associated Types

type Base (ReaderT i m)
Instance details Defined in Pipes.Safe type Base (ReaderT i m) = Base m

Methods

liftBase :: Base (ReaderT i m) r -> ReaderT i m r #

register :: Base (ReaderT i m) () -> ReaderT i m ReleaseKey #

release :: ReleaseKey -> ReaderT i m () #

MonadSafe m => MonadSafe (StateT s m)

Instance details

Defined in Pipes.Safe

Associated Types

type Base (StateT s m)
Instance details Defined in Pipes.Safe type Base (StateT s m) = Base m

Methods

liftBase :: Base (StateT s m) r -> StateT s m r #

register :: Base (StateT s m) () -> StateT s m ReleaseKey #

release :: ReleaseKey -> StateT s m () #

MonadSafe m => MonadSafe (StateT s m)

Instance details

Defined in Pipes.Safe

Associated Types

type Base (StateT s m)
Instance details Defined in Pipes.Safe type Base (StateT s m) = Base m

Methods

liftBase :: Base (StateT s m) r -> StateT s m r #

register :: Base (StateT s m) () -> StateT s m ReleaseKey #

release :: ReleaseKey -> StateT s m () #

(MonadSafe m, Monoid w) => MonadSafe (WriterT w m)

Instance details

Defined in Pipes.Safe

Associated Types

type Base (WriterT w m)
Instance details Defined in Pipes.Safe type Base (WriterT w m) = Base m

Methods

liftBase :: Base (WriterT w m) r -> WriterT w m r #

register :: Base (WriterT w m) () -> WriterT w m ReleaseKey #

release :: ReleaseKey -> WriterT w m () #

(MonadSafe m, Monoid w) => MonadSafe (WriterT w m)

Instance details

Defined in Pipes.Safe

Associated Types

type Base (WriterT w m)
Instance details Defined in Pipes.Safe type Base (WriterT w m) = Base m

Methods

liftBase :: Base (WriterT w m) r -> WriterT w m r #

register :: Base (WriterT w m) () -> WriterT w m ReleaseKey #

release :: ReleaseKey -> WriterT w m () #

(MonadSafe m, Monoid w) => MonadSafe (RWST i w s m)

Instance details

Defined in Pipes.Safe

Associated Types

type Base (RWST i w s m)
Instance details Defined in Pipes.Safe type Base (RWST i w s m) = Base m

Methods

liftBase :: Base (RWST i w s m) r -> RWST i w s m r #

register :: Base (RWST i w s m) () -> RWST i w s m ReleaseKey #

release :: ReleaseKey -> RWST i w s m () #

(MonadSafe m, Monoid w) => MonadSafe (RWST i w s m)

Instance details

Defined in Pipes.Safe

Associated Types

type Base (RWST i w s m)
Instance details Defined in Pipes.Safe type Base (RWST i w s m) = Base m

Methods

liftBase :: Base (RWST i w s m) r -> RWST i w s m r #

register :: Base (RWST i w s m) () -> RWST i w s m ReleaseKey #

release :: ReleaseKey -> RWST i w s m () #

MonadSafe m => MonadSafe (Proxy a' a b' b m)

Instance details

Defined in Pipes.Safe

Associated Types

type Base (Proxy a' a b' b m)
Instance details Defined in Pipes.Safe type Base (Proxy a' a b' b m) = Base m

Methods

liftBase :: Base (Proxy a' a b' b m) r -> Proxy a' a b' b m r #

register :: Base (Proxy a' a b' b m) () -> Proxy a' a b' b m ReleaseKey #

release :: ReleaseKey -> Proxy a' a b' b m () #

data SafeT (m :: Type -> Type) r #

SafeT is a monad transformer that extends the base monad with the ability to register and release finalizers.

All unreleased finalizers are called at the end of the SafeT block, even in the event of exceptions.

Instances

Instances details

MonadTrans SafeT

Instance details

Defined in Pipes.Safe

Methods

lift :: Monad m => m a -> SafeT m a #

MonadBaseControl b m => MonadBaseControl b (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

liftBaseWith :: (RunInBase (SafeT m) b -> b a) -> SafeT m a #

restoreM :: StM (SafeT m) a -> SafeT m a #

MonadError e m => MonadError e (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

throwError :: e -> SafeT m a #

catchError :: SafeT m a -> (e -> SafeT m a) -> SafeT m a #

MonadState s m => MonadState s (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

get :: SafeT m s #

put :: s -> SafeT m () #

state :: (s -> (a, s)) -> SafeT m a #

MonadWriter w m => MonadWriter w (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

writer :: (a, w) -> SafeT m a #

tell :: w -> SafeT m () #

listen :: SafeT m a -> SafeT m (a, w) #

pass :: SafeT m (a, w -> w) -> SafeT m a #

MonadBase b m => MonadBase b (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

liftBase :: b α -> SafeT m α #

MonadFail m => MonadFail (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

fail :: String -> SafeT m a #

MonadFix m => MonadFix (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

mfix :: (a -> SafeT m a) -> SafeT m a #

MonadIO m => MonadIO (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

liftIO :: IO a -> SafeT m a #

Alternative m => Alternative (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

empty :: SafeT m a #

(<|>) :: SafeT m a -> SafeT m a -> SafeT m a #

some :: SafeT m a -> SafeT m [a] #

many :: SafeT m a -> SafeT m [a] #

Applicative m => Applicative (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

pure :: a -> SafeT m a #

(<*>) :: SafeT m (a -> b) -> SafeT m a -> SafeT m b #

liftA2 :: (a -> b -> c) -> SafeT m a -> SafeT m b -> SafeT m c #

(*>) :: SafeT m a -> SafeT m b -> SafeT m b #

(<*) :: SafeT m a -> SafeT m b -> SafeT m a #

Functor m => Functor (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

fmap :: (a -> b) -> SafeT m a -> SafeT m b #

(<$) :: a -> SafeT m b -> SafeT m a #

Monad m => Monad (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

(>>=) :: SafeT m a -> (a -> SafeT m b) -> SafeT m b #

(>>) :: SafeT m a -> SafeT m b -> SafeT m b #

return :: a -> SafeT m a #

MonadPlus m => MonadPlus (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

mzero :: SafeT m a #

mplus :: SafeT m a -> SafeT m a -> SafeT m a #

MonadCatch m => MonadCatch (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

catch :: (HasCallStack, Exception e) => SafeT m a -> (e -> SafeT m a) -> SafeT m a #

MonadMask m => MonadMask (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

mask :: HasCallStack => ((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b #

uninterruptibleMask :: HasCallStack => ((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b #

generalBracket :: HasCallStack => SafeT m a -> (a -> ExitCase b -> SafeT m c) -> (a -> SafeT m b) -> SafeT m (b, c) #

MonadThrow m => MonadThrow (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

throwM :: (HasCallStack, Exception e) => e -> SafeT m a #

MonadCont m => MonadCont (SafeT m)

Instance details

Defined in Pipes.Safe

Methods

callCC :: ((a -> SafeT m b) -> SafeT m a) -> SafeT m a #

(MonadIO m, MonadCatch m, MonadMask m) => MonadSafe (SafeT m)

Instance details

Defined in Pipes.Safe

Associated Types

type Base (SafeT m)
Instance details Defined in Pipes.Safe type Base (SafeT m) = m

Methods

liftBase :: Base (SafeT m) r -> SafeT m r #

register :: Base (SafeT m) () -> SafeT m ReleaseKey #

release :: ReleaseKey -> SafeT m () #

PrimMonad m => PrimMonad (SafeT m)

Instance details

Defined in Pipes.Safe

Associated Types

type PrimState (SafeT m)
Instance details Defined in Pipes.Safe type PrimState (SafeT m) = PrimState m

Methods

primitive :: (State# (PrimState (SafeT m)) -> (# State# (PrimState (SafeT m)), a #)) -> SafeT m a #

type Base (SafeT m)

Instance details

Defined in Pipes.Safe

type Base (SafeT m) = m

type PrimState (SafeT m)

Instance details

Defined in Pipes.Safe

type PrimState (SafeT m) = PrimState m

type StM (SafeT m) a

Instance details

Defined in Pipes.Safe

type StM (SafeT m) a = StM m a

runSafeT :: (MonadMask m, MonadIO m) => SafeT m r -> m r #

Run the SafeT monad transformer, executing all unreleased finalizers at the end of the computation

runSafeP :: forall (m :: Type -> Type) r. (MonadMask m, MonadIO m) => Effect (SafeT m) r -> Effect' m r #

Run SafeT in the base monad, executing all unreleased finalizers at the end of the computation

Use runSafeP to safely flush all unreleased finalizers and ensure prompt finalization without exiting the Proxy monad.

runSafeEffect :: (MonadIO m, MonadMask m) => Effect (SafeT m) r -> m r Source #

Run a self-contained ’Pipes.Effect’ and execute the finalizers associated with the ’SafeT’ transformer.

data Text #

A space efficient, packed, unboxed Unicode text type.

Instances

Instances details

Parseable Text Source #
Instance details Defined in Frames.ColumnTypeable Methods parse :: MonadPlus m => Text -> m (Parsed Text) Source # parseCombine :: MonadPlus m => Parsed Text -> Parsed Text -> m (Parsed Text) Source # representableAsType :: Parsed Text -> Const (Either (String -> Q [Dec]) Type) Text Source #
ShowCSV Text Source #
Instance details Defined in Frames.ShowCSV Methods showCSV :: Text -> Text Source #
Grouping Text Source #
Instance details Defined in Frames.ExtraInstances Methods grouping :: Group Text #
Hashable Text
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Readable Text
Instance details Defined in Data.Readable Methods fromText :: MonadPlus m => Text -> m Text # fromBS :: MonadPlus m => ByteString -> m Text #
type VectorFor Text Source #
Instance details Defined in Frames.InCore type VectorFor Text = Vector
type Item Text
Instance details Defined in Data.Text type Item Text = Char