Frames.ColumnTypeable

Documentation

data Parsed a

Constructors

Possibly a

Definitely a

Instances

Functor Parsed

Defined in Frames.ColumnTypeable

Methods

fmap :: (a -> b) -> Parsed a -> Parsed b

(<$) :: a -> Parsed b -> Parsed a

Eq a => Eq (Parsed a)

Defined in Frames.ColumnTypeable

Methods

(==) :: Parsed a -> Parsed a -> Bool

(/=) :: Parsed a -> Parsed a -> Bool

Ord a => Ord (Parsed a)

Defined in Frames.ColumnTypeable

Methods

compare :: Parsed a -> Parsed a -> Ordering

(<) :: Parsed a -> Parsed a -> Bool

(<=) :: Parsed a -> Parsed a -> Bool

(>) :: Parsed a -> Parsed a -> Bool

(>=) :: Parsed a -> Parsed a -> Bool

max :: Parsed a -> Parsed a -> Parsed a

min :: Parsed a -> Parsed a -> Parsed a

Show a => Show (Parsed a)

Defined in Frames.ColumnTypeable

Methods

showsPrec :: Int -> Parsed a -> ShowS

show :: Parsed a -> String

showList :: [Parsed a] -> ShowS

parsedValue :: Parsed a -> a

class Parseable a where

Values that can be read from a Text with more or less discrimination.

Minimal complete definition

Nothing

Methods

parse :: MonadPlus m => Text -> m (Parsed a)

Returns Nothing if a value of the given type can not be read; 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 :: (Readable a, MonadPlus m) => Text -> m (Parsed a)

Returns Nothing if a value of the given type can not be read; 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."

parseCombine :: MonadPlus m => Parsed a -> Parsed a -> m (Parsed a)

Combine two parse results such that the combination can fail. Useful when we have two Possibly parsed values that are different enough to suggest the parse of each should be considered a failure. The default implementation is to return the first argument.

parseCombine :: MonadPlus m => Parsed a -> Parsed a -> m (Parsed a)

Combine two parse results such that the combination can fail. Useful when we have two Possibly parsed values that are different enough to suggest the parse of each should be considered a failure. The default implementation is to return the first argument.

representableAsType :: Parsed a -> Const (Either (String -> Q [Dec]) Type) a

representableAsType :: Typeable a => Parsed a -> Const (Either (String -> Q [Dec]) Type) a

Instances

Parseable Bool

Defined in Frames.ColumnTypeable

Methods

parse :: MonadPlus m => Text -> m (Parsed Bool)

parseCombine :: MonadPlus m => Parsed Bool -> Parsed Bool -> m (Parsed Bool)

representableAsType :: Parsed Bool -> Const (Either (String -> Q [Dec]) Type) Bool

Parseable Double

Defined in Frames.ColumnTypeable

Methods

parse :: MonadPlus m => Text -> m (Parsed Double)

parseCombine :: MonadPlus m => Parsed Double -> Parsed Double -> m (Parsed Double)

representableAsType :: Parsed Double -> Const (Either (String -> Q [Dec]) Type) Double

Parseable Float

Defined in Frames.ColumnTypeable

Methods

parse :: MonadPlus m => Text -> m (Parsed Float)

parseCombine :: MonadPlus m => Parsed Float -> Parsed Float -> m (Parsed Float)

representableAsType :: Parsed Float -> Const (Either (String -> Q [Dec]) Type) Float

Parseable Int

Defined in Frames.ColumnTypeable

Methods

parse :: MonadPlus m => Text -> m (Parsed Int)

parseCombine :: MonadPlus m => Parsed Int -> Parsed Int -> m (Parsed Int)

representableAsType :: Parsed Int -> Const (Either (String -> Q [Dec]) Type) Int

Parseable Int32

Defined in Frames.ColumnTypeable

Methods

parse :: MonadPlus m => Text -> m (Parsed Int32)

parseCombine :: MonadPlus m => Parsed Int32 -> Parsed Int32 -> m (Parsed Int32)

representableAsType :: Parsed Int32 -> Const (Either (String -> Q [Dec]) Type) Int32

Parseable Int64

Defined in Frames.ColumnTypeable

Methods

parse :: MonadPlus m => Text -> m (Parsed Int64)

parseCombine :: MonadPlus m => Parsed Int64 -> Parsed Int64 -> m (Parsed Int64)

representableAsType :: Parsed Int64 -> Const (Either (String -> Q [Dec]) Type) Int64

Parseable Integer

Defined in Frames.ColumnTypeable

Methods

parse :: MonadPlus m => Text -> m (Parsed Integer)

parseCombine :: MonadPlus m => Parsed Integer -> Parsed Integer -> m (Parsed Integer)

representableAsType :: Parsed Integer -> Const (Either (String -> Q [Dec]) Type) Integer

Parseable Text

Defined in Frames.ColumnTypeable

Methods

parse :: MonadPlus m => Text -> m (Parsed Text)

parseCombine :: MonadPlus m => Parsed Text -> Parsed Text -> m (Parsed Text)

representableAsType :: Parsed Text -> Const (Either (String -> Q [Dec]) Type) Text

KnownNat n => Parseable (Categorical n)

Defined in Frames.Categorical

Methods

parse :: MonadPlus m => Text -> m (Parsed (Categorical n))

parseCombine :: MonadPlus m => Parsed (Categorical n) -> Parsed (Categorical n) -> m (Parsed (Categorical n))

representableAsType :: Parsed (Categorical n) -> Const (Either (String -> Q [Dec]) Type) (Categorical n)

discardConfidence :: Parsed a -> a

Discard any estimate of a parse's ambiguity.

parse' :: (MonadPlus m, Parseable a) => Text -> m a

Acts just like fromText: tries to parse a value from a Text and discards any estimate of the parse's ambiguity.

parseIntish :: (Readable a, MonadPlus f) => Text -> f (Parsed a)

class ColumnTypeable a where

This class relates a universe of possible column types to Haskell types, and provides a mechanism to infer which type best represents some textual data.

Methods

colType :: a -> Either (String -> Q [Dec]) Type

inferType :: Text -> a

Instances

(RPureConstrained Parseable ts, FoldRec ts ts, RecApplicative ts, Text ∈ ts) => ColumnTypeable (CoRec ColInfo ts)

Defined in Frames.ColumnUniverse

Methods

colType :: CoRec ColInfo ts -> Either (String -> Q [Dec]) Type

inferType :: Text -> CoRec ColInfo ts