Frames-0.1.9: Data frames For working with tabular data files

Safe HaskellNone
LanguageHaskell2010

Frames.Col

Description

Column types

Synopsis

Documentation

newtype s :-> a Source #

A column's type includes a textual name and the data type of each element.

Constructors

Col 

Fields

Instances

(KnownSymbol s, Show (f (Col' s a)), ShowRec f rs) => ShowRec f ((:) * ((:->) s a) rs) Source # 

Methods

showRec' :: Rec * f ((* ': (s :-> a)) rs) -> [String]

Eq a => Eq ((:->) s a) Source # 

Methods

(==) :: (s :-> a) -> (s :-> a) -> Bool #

(/=) :: (s :-> a) -> (s :-> a) -> Bool #

Floating a => Floating ((:->) s a) Source # 

Methods

pi :: s :-> a #

exp :: (s :-> a) -> s :-> a #

log :: (s :-> a) -> s :-> a #

sqrt :: (s :-> a) -> s :-> a #

(**) :: (s :-> a) -> (s :-> a) -> s :-> a #

logBase :: (s :-> a) -> (s :-> a) -> s :-> a #

sin :: (s :-> a) -> s :-> a #

cos :: (s :-> a) -> s :-> a #

tan :: (s :-> a) -> s :-> a #

asin :: (s :-> a) -> s :-> a #

acos :: (s :-> a) -> s :-> a #

atan :: (s :-> a) -> s :-> a #

sinh :: (s :-> a) -> s :-> a #

cosh :: (s :-> a) -> s :-> a #

tanh :: (s :-> a) -> s :-> a #

asinh :: (s :-> a) -> s :-> a #

acosh :: (s :-> a) -> s :-> a #

atanh :: (s :-> a) -> s :-> a #

log1p :: (s :-> a) -> s :-> a #

expm1 :: (s :-> a) -> s :-> a #

log1pexp :: (s :-> a) -> s :-> a #

log1mexp :: (s :-> a) -> s :-> a #

Fractional a => Fractional ((:->) s a) Source # 

Methods

(/) :: (s :-> a) -> (s :-> a) -> s :-> a #

recip :: (s :-> a) -> s :-> a #

fromRational :: Rational -> s :-> a #

Num a => Num ((:->) s a) Source # 

Methods

(+) :: (s :-> a) -> (s :-> a) -> s :-> a #

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

(*) :: (s :-> a) -> (s :-> a) -> s :-> a #

negate :: (s :-> a) -> s :-> a #

abs :: (s :-> a) -> s :-> a #

signum :: (s :-> a) -> s :-> a #

fromInteger :: Integer -> s :-> a #

Ord a => Ord ((:->) s a) Source # 

Methods

compare :: (s :-> a) -> (s :-> a) -> Ordering #

(<) :: (s :-> a) -> (s :-> a) -> Bool #

(<=) :: (s :-> a) -> (s :-> a) -> Bool #

(>) :: (s :-> a) -> (s :-> a) -> Bool #

(>=) :: (s :-> a) -> (s :-> a) -> Bool #

max :: (s :-> a) -> (s :-> a) -> s :-> a #

min :: (s :-> a) -> (s :-> a) -> s :-> a #

Real a => Real ((:->) s a) Source # 

Methods

toRational :: (s :-> a) -> Rational #

RealFloat a => RealFloat ((:->) s a) Source # 

Methods

floatRadix :: (s :-> a) -> Integer #

floatDigits :: (s :-> a) -> Int #

floatRange :: (s :-> a) -> (Int, Int) #

decodeFloat :: (s :-> a) -> (Integer, Int) #

encodeFloat :: Integer -> Int -> s :-> a #

exponent :: (s :-> a) -> Int #

significand :: (s :-> a) -> s :-> a #

scaleFloat :: Int -> (s :-> a) -> s :-> a #

isNaN :: (s :-> a) -> Bool #

isInfinite :: (s :-> a) -> Bool #

isDenormalized :: (s :-> a) -> Bool #

isNegativeZero :: (s :-> a) -> Bool #

isIEEE :: (s :-> a) -> Bool #

atan2 :: (s :-> a) -> (s :-> a) -> s :-> a #

RealFrac a => RealFrac ((:->) s a) Source # 

Methods

properFraction :: Integral b => (s :-> a) -> (b, s :-> a) #

truncate :: Integral b => (s :-> a) -> b #

round :: Integral b => (s :-> a) -> b #

ceiling :: Integral b => (s :-> a) -> b #

floor :: Integral b => (s :-> a) -> b #

(KnownSymbol s, Show a) => Show ((:->) s a) Source # 

Methods

showsPrec :: Int -> (s :-> a) -> ShowS #

show :: (s :-> a) -> String #

showList :: [s :-> a] -> ShowS #

Monoid a => Monoid ((:->) s a) Source # 

Methods

mempty :: s :-> a #

mappend :: (s :-> a) -> (s :-> a) -> s :-> a #

mconcat :: [s :-> a] -> s :-> a #

AsVinyl ts => AsVinyl ((:) * ((:->) s t) ts) Source # 

Methods

toVinyl :: Functor f => Rec * f ((* ': (s :-> t)) ts) -> Rec * f (UnColumn ((* ': (s :-> t)) ts)) Source #

fromVinyl :: Functor f => Rec * f (UnColumn ((* ': (s :-> t)) ts)) -> Rec * f ((* ': (s :-> t)) ts) Source #

(ColumnHeaders cs, KnownSymbol s) => ColumnHeaders ((:) * ((:->) s c) cs) Source # 

Methods

columnHeaders :: proxy (Rec * f ((* ': (s :-> c)) cs)) -> [String] Source #

(MVector (VectorMFor a) a, Vector (VectorFor a) a, RecVec rs) => RecVec ((:) * ((:->) s a) rs) Source # 

Methods

allocRec :: PrimMonad m => proxy ((* ': (s :-> a)) rs) -> m (Record (VectorMs m ((* ': (s :-> a)) rs))) Source #

freezeRec :: PrimMonad m => proxy ((* ': (s :-> a)) rs) -> Int -> Record (VectorMs m ((* ': (s :-> a)) rs)) -> m (Record (Vectors ((* ': (s :-> a)) rs))) Source #

growRec :: PrimMonad m => proxy ((* ': (s :-> a)) rs) -> Record (VectorMs m ((* ': (s :-> a)) rs)) -> m (Record (VectorMs m ((* ': (s :-> a)) rs))) Source #

writeRec :: PrimMonad m => proxy ((* ': (s :-> a)) rs) -> Int -> Record (VectorMs m ((* ': (s :-> a)) rs)) -> Record ((* ': (s :-> a)) rs) -> m () Source #

indexRec :: proxy ((* ': (s :-> a)) rs) -> Int -> Record (Vectors ((* ': (s :-> a)) rs)) -> Record ((* ': (s :-> a)) rs) Source #

produceRec :: proxy ((* ': (s :-> a)) rs) -> Record (Vectors ((* ': (s :-> a)) rs)) -> Rec * ((->) Int) ((* ': (s :-> a)) rs) Source #

(Parseable t, ReadRec ts) => ReadRec ((:) * ((:->) s t) ts) Source # 

Methods

readRec :: [Text] -> Rec * Maybe ((* ': (s :-> t)) ts) Source #

newtype Col' s a Source #

Used only for a show instance that parenthesizes the value.

Constructors

Col' (s :-> a) 

Instances

(KnownSymbol s, Show a) => Show (Col' s a) Source # 

Methods

showsPrec :: Int -> Col' s a -> ShowS #

show :: Col' s a -> String #

showList :: [Col' s a] -> ShowS #

col' :: a -> Col' s a Source #

Helper for making a Col'