Data.Aeson.Flow

Derive Flow types using aeson Options.

AST types

class Typeable a => FlowTyped a where

Methods

flowType :: Proxy a -> FlowType

flowTypeName :: Proxy a -> Maybe Text

flowTypeVars :: Proxy a -> [TypeRep]

flowOptions :: Proxy a -> Options

isPrim :: Proxy a -> Bool

flowType :: (Generic a, GFlowTyped (Rep a)) => Proxy a -> FlowType

flowTypeName :: (Generic a, Rep a ~ D1 (MetaData name mod pkg t) c, KnownSymbol name) => Proxy a -> Maybe Text

Instances

FlowTyped Bool

Methods

flowType :: Proxy * Bool -> FlowType

flowTypeName :: Proxy * Bool -> Maybe Text

flowTypeVars :: Proxy * Bool -> [TypeRep]

flowOptions :: Proxy * Bool -> Options

isPrim :: Proxy * Bool -> Bool

FlowTyped Char

Methods

flowType :: Proxy * Char -> FlowType

flowTypeName :: Proxy * Char -> Maybe Text

flowTypeVars :: Proxy * Char -> [TypeRep]

flowOptions :: Proxy * Char -> Options

isPrim :: Proxy * Char -> Bool

FlowTyped Double

Methods

flowType :: Proxy * Double -> FlowType

flowTypeName :: Proxy * Double -> Maybe Text

flowTypeVars :: Proxy * Double -> [TypeRep]

flowOptions :: Proxy * Double -> Options

isPrim :: Proxy * Double -> Bool

FlowTyped Float

Methods

flowType :: Proxy * Float -> FlowType

flowTypeName :: Proxy * Float -> Maybe Text

flowTypeVars :: Proxy * Float -> [TypeRep]

flowOptions :: Proxy * Float -> Options

isPrim :: Proxy * Float -> Bool

FlowTyped Int

Methods

flowType :: Proxy * Int -> FlowType

flowTypeName :: Proxy * Int -> Maybe Text

flowTypeVars :: Proxy * Int -> [TypeRep]

flowOptions :: Proxy * Int -> Options

isPrim :: Proxy * Int -> Bool

FlowTyped Int8

Methods

flowType :: Proxy * Int8 -> FlowType

flowTypeName :: Proxy * Int8 -> Maybe Text

flowTypeVars :: Proxy * Int8 -> [TypeRep]

flowOptions :: Proxy * Int8 -> Options

isPrim :: Proxy * Int8 -> Bool

FlowTyped Int16

Methods

flowType :: Proxy * Int16 -> FlowType

flowTypeName :: Proxy * Int16 -> Maybe Text

flowTypeVars :: Proxy * Int16 -> [TypeRep]

flowOptions :: Proxy * Int16 -> Options

isPrim :: Proxy * Int16 -> Bool

FlowTyped Int32

Methods

flowType :: Proxy * Int32 -> FlowType

flowTypeName :: Proxy * Int32 -> Maybe Text

flowTypeVars :: Proxy * Int32 -> [TypeRep]

flowOptions :: Proxy * Int32 -> Options

isPrim :: Proxy * Int32 -> Bool

FlowTyped Int64

Methods

flowType :: Proxy * Int64 -> FlowType

flowTypeName :: Proxy * Int64 -> Maybe Text

flowTypeVars :: Proxy * Int64 -> [TypeRep]

flowOptions :: Proxy * Int64 -> Options

isPrim :: Proxy * Int64 -> Bool

FlowTyped Word

Methods

flowType :: Proxy * Word -> FlowType

flowTypeName :: Proxy * Word -> Maybe Text

flowTypeVars :: Proxy * Word -> [TypeRep]

flowOptions :: Proxy * Word -> Options

isPrim :: Proxy * Word -> Bool

FlowTyped Word8

Methods

flowType :: Proxy * Word8 -> FlowType

flowTypeName :: Proxy * Word8 -> Maybe Text

flowTypeVars :: Proxy * Word8 -> [TypeRep]

flowOptions :: Proxy * Word8 -> Options

isPrim :: Proxy * Word8 -> Bool

FlowTyped Word16

Methods

flowType :: Proxy * Word16 -> FlowType

flowTypeName :: Proxy * Word16 -> Maybe Text

flowTypeVars :: Proxy * Word16 -> [TypeRep]

flowOptions :: Proxy * Word16 -> Options

isPrim :: Proxy * Word16 -> Bool

FlowTyped Word32

Methods

flowType :: Proxy * Word32 -> FlowType

flowTypeName :: Proxy * Word32 -> Maybe Text

flowTypeVars :: Proxy * Word32 -> [TypeRep]

flowOptions :: Proxy * Word32 -> Options

isPrim :: Proxy * Word32 -> Bool

FlowTyped Word64

Methods

flowType :: Proxy * Word64 -> FlowType

flowTypeName :: Proxy * Word64 -> Maybe Text

flowTypeVars :: Proxy * Word64 -> [TypeRep]

flowOptions :: Proxy * Word64 -> Options

isPrim :: Proxy * Word64 -> Bool

FlowTyped ()

Methods

flowType :: Proxy * () -> FlowType

flowTypeName :: Proxy * () -> Maybe Text

flowTypeVars :: Proxy * () -> [TypeRep]

flowOptions :: Proxy * () -> Options

isPrim :: Proxy * () -> Bool

FlowTyped Scientific

Methods

flowType :: Proxy * Scientific -> FlowType

flowTypeName :: Proxy * Scientific -> Maybe Text

flowTypeVars :: Proxy * Scientific -> [TypeRep]

flowOptions :: Proxy * Scientific -> Options

isPrim :: Proxy * Scientific -> Bool

FlowTyped String

Methods

flowType :: Proxy * String -> FlowType

flowTypeName :: Proxy * String -> Maybe Text

flowTypeVars :: Proxy * String -> [TypeRep]

flowOptions :: Proxy * String -> Options

isPrim :: Proxy * String -> Bool

FlowTyped Text

Methods

flowType :: Proxy * Text -> FlowType

flowTypeName :: Proxy * Text -> Maybe Text

flowTypeVars :: Proxy * Text -> [TypeRep]

flowOptions :: Proxy * Text -> Options

isPrim :: Proxy * Text -> Bool

FlowTyped UTCTime

Methods

flowType :: Proxy * UTCTime -> FlowType

flowTypeName :: Proxy * UTCTime -> Maybe Text

flowTypeVars :: Proxy * UTCTime -> [TypeRep]

flowOptions :: Proxy * UTCTime -> Options

isPrim :: Proxy * UTCTime -> Bool

FlowTyped Value

Methods

flowType :: Proxy * Value -> FlowType

flowTypeName :: Proxy * Value -> Maybe Text

flowTypeVars :: Proxy * Value -> [TypeRep]

flowOptions :: Proxy * Value -> Options

isPrim :: Proxy * Value -> Bool

FlowTyped Text

Methods

flowType :: Proxy * Text -> FlowType

flowTypeName :: Proxy * Text -> Maybe Text

flowTypeVars :: Proxy * Text -> [TypeRep]

flowOptions :: Proxy * Text -> Options

isPrim :: Proxy * Text -> Bool

FlowTyped Void

Methods

flowType :: Proxy * Void -> FlowType

flowTypeName :: Proxy * Void -> Maybe Text

flowTypeVars :: Proxy * Void -> [TypeRep]

flowOptions :: Proxy * Void -> Options

isPrim :: Proxy * Void -> Bool

FlowTyped IntSet

Methods

flowType :: Proxy * IntSet -> FlowType

flowTypeName :: Proxy * IntSet -> Maybe Text

flowTypeVars :: Proxy * IntSet -> [TypeRep]

flowOptions :: Proxy * IntSet -> Options

isPrim :: Proxy * IntSet -> Bool

FlowTyped a => FlowTyped [a]

Methods

flowType :: Proxy * [a] -> FlowType

flowTypeName :: Proxy * [a] -> Maybe Text

flowTypeVars :: Proxy * [a] -> [TypeRep]

flowOptions :: Proxy * [a] -> Options

isPrim :: Proxy * [a] -> Bool

FlowTyped a => FlowTyped (Maybe a)

Methods

flowType :: Proxy * (Maybe a) -> FlowType

flowTypeName :: Proxy * (Maybe a) -> Maybe Text

flowTypeVars :: Proxy * (Maybe a) -> [TypeRep]

flowOptions :: Proxy * (Maybe a) -> Options

isPrim :: Proxy * (Maybe a) -> Bool

Typeable * a => FlowTyped (Fixed a)

Methods

flowType :: Proxy * (Fixed a) -> FlowType

flowTypeName :: Proxy * (Fixed a) -> Maybe Text

flowTypeVars :: Proxy * (Fixed a) -> [TypeRep]

flowOptions :: Proxy * (Fixed a) -> Options

isPrim :: Proxy * (Fixed a) -> Bool

Typeable * a => FlowTyped (Tree a)

This instance is defined recursively. You'll probably need to use dependencies to extract a usable definition

Methods

flowType :: Proxy * (Tree a) -> FlowType

flowTypeName :: Proxy * (Tree a) -> Maybe Text

flowTypeVars :: Proxy * (Tree a) -> [TypeRep]

flowOptions :: Proxy * (Tree a) -> Options

isPrim :: Proxy * (Tree a) -> Bool

FlowTyped a => FlowTyped (Set a)

Methods

flowType :: Proxy * (Set a) -> FlowType

flowTypeName :: Proxy * (Set a) -> Maybe Text

flowTypeVars :: Proxy * (Set a) -> [TypeRep]

flowOptions :: Proxy * (Set a) -> Options

isPrim :: Proxy * (Set a) -> Bool

FlowTyped a => FlowTyped (HashSet a)

Methods

flowType :: Proxy * (HashSet a) -> FlowType

flowTypeName :: Proxy * (HashSet a) -> Maybe Text

flowTypeVars :: Proxy * (HashSet a) -> [TypeRep]

flowOptions :: Proxy * (HashSet a) -> Options

isPrim :: Proxy * (HashSet a) -> Bool

FlowTyped a => FlowTyped (Vector a)

Methods

flowType :: Proxy * (Vector a) -> FlowType

flowTypeName :: Proxy * (Vector a) -> Maybe Text

flowTypeVars :: Proxy * (Vector a) -> [TypeRep]

flowOptions :: Proxy * (Vector a) -> Options

isPrim :: Proxy * (Vector a) -> Bool

FlowTyped a => FlowTyped (Vector a)

Methods

flowType :: Proxy * (Vector a) -> FlowType

flowTypeName :: Proxy * (Vector a) -> Maybe Text

flowTypeVars :: Proxy * (Vector a) -> [TypeRep]

flowOptions :: Proxy * (Vector a) -> Options

isPrim :: Proxy * (Vector a) -> Bool

FlowTyped a => FlowTyped (Vector a)

Methods

flowType :: Proxy * (Vector a) -> FlowType

flowTypeName :: Proxy * (Vector a) -> Maybe Text

flowTypeVars :: Proxy * (Vector a) -> [TypeRep]

flowOptions :: Proxy * (Vector a) -> Options

isPrim :: Proxy * (Vector a) -> Bool

(FlowTyped a, FlowTyped b) => FlowTyped (Either a b)

Methods

flowType :: Proxy * (Either a b) -> FlowType

flowTypeName :: Proxy * (Either a b) -> Maybe Text

flowTypeVars :: Proxy * (Either a b) -> [TypeRep]

flowOptions :: Proxy * (Either a b) -> Options

isPrim :: Proxy * (Either a b) -> Bool

(FlowTyped a, FlowTyped b) => FlowTyped (a, b)

Methods

flowType :: Proxy * (a, b) -> FlowType

flowTypeName :: Proxy * (a, b) -> Maybe Text

flowTypeVars :: Proxy * (a, b) -> [TypeRep]

flowOptions :: Proxy * (a, b) -> Options

isPrim :: Proxy * (a, b) -> Bool

FlowTyped a => FlowTyped (HashMap Text a)

This is at odds with "aeson" which defines ToJSONKey

Methods

flowType :: Proxy * (HashMap Text a) -> FlowType

flowTypeName :: Proxy * (HashMap Text a) -> Maybe Text

flowTypeVars :: Proxy * (HashMap Text a) -> [TypeRep]

flowOptions :: Proxy * (HashMap Text a) -> Options

isPrim :: Proxy * (HashMap Text a) -> Bool

(Typeable k2 a, Typeable * k2) => FlowTyped (Var k2 a)

Methods

flowType :: Proxy * (Var k2 a) -> FlowType

flowTypeName :: Proxy * (Var k2 a) -> Maybe Text

flowTypeVars :: Proxy * (Var k2 a) -> [TypeRep]

flowOptions :: Proxy * (Var k2 a) -> Options

isPrim :: Proxy * (Var k2 a) -> Bool

(FlowTyped a, FlowTyped b, FlowTyped c) => FlowTyped (a, b, c)

Methods

flowType :: Proxy * (a, b, c) -> FlowType

flowTypeName :: Proxy * (a, b, c) -> Maybe Text

flowTypeVars :: Proxy * (a, b, c) -> [TypeRep]

flowOptions :: Proxy * (a, b, c) -> Options

isPrim :: Proxy * (a, b, c) -> Bool

type FlowType = Fix FlowTypeF

newtype Fix f :: (* -> *) -> *

Constructors

Fix (f (Fix f))

Instances

Eq1 f => Eq (Fix f)

Methods

(==) :: Fix f -> Fix f -> Bool

(/=) :: Fix f -> Fix f -> Bool

(Typeable (* -> *) f, Data (f (Fix f))) => Data (Fix f)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fix f -> c (Fix f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Fix f)

toConstr :: Fix f -> Constr

dataTypeOf :: Fix f -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Fix f))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Fix f))

gmapT :: (forall b. Data b => b -> b) -> Fix f -> Fix f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fix f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fix f -> r

gmapQ :: (forall d. Data d => d -> u) -> Fix f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Fix f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fix f -> m (Fix f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fix f -> m (Fix f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fix f -> m (Fix f)

Ord1 f => Ord (Fix f)

Methods

compare :: Fix f -> Fix f -> Ordering

(<) :: Fix f -> Fix f -> Bool

(<=) :: Fix f -> Fix f -> Bool

(>) :: Fix f -> Fix f -> Bool

(>=) :: Fix f -> Fix f -> Bool

max :: Fix f -> Fix f -> Fix f

min :: Fix f -> Fix f -> Fix f

Read1 f => Read (Fix f)

Methods

readsPrec :: Int -> ReadS (Fix f)

readList :: ReadS [Fix f]

readPrec :: ReadPrec (Fix f)

readListPrec :: ReadPrec [Fix f]

Show1 f => Show (Fix f)

Methods

showsPrec :: Int -> Fix f -> ShowS

show :: Fix f -> String

showList :: [Fix f] -> ShowS

Functor f => Recursive (Fix f)

Methods

project :: Fix f -> Base (Fix f) (Fix f)

cata :: (Base (Fix f) a -> a) -> Fix f -> a

para :: (Base (Fix f) (Fix f, a) -> a) -> Fix f -> a

gpara :: (Corecursive (Fix f), Comonad w) => (forall b. Base (Fix f) (w b) -> w (Base (Fix f) b)) -> (Base (Fix f) (EnvT (Fix f) w a) -> a) -> Fix f -> a

prepro :: Corecursive (Fix f) => (forall b. Base (Fix f) b -> Base (Fix f) b) -> (Base (Fix f) a -> a) -> Fix f -> a

gprepro :: (Corecursive (Fix f), Comonad w) => (forall b. Base (Fix f) (w b) -> w (Base (Fix f) b)) -> (forall c. Base (Fix f) c -> Base (Fix f) c) -> (Base (Fix f) (w a) -> a) -> Fix f -> a

Functor f => Corecursive (Fix f)

Methods

embed :: Base (Fix f) (Fix f) -> Fix f

ana :: (a -> Base (Fix f) a) -> a -> Fix f

apo :: (a -> Base (Fix f) (Either (Fix f) a)) -> a -> Fix f

postpro :: Recursive (Fix f) => (forall b. Base (Fix f) b -> Base (Fix f) b) -> (a -> Base (Fix f) a) -> a -> Fix f

gpostpro :: (Recursive (Fix f), Monad m) => (forall b. m (Base (Fix f) b) -> Base (Fix f) (m b)) -> (forall c. Base (Fix f) c -> Base (Fix f) c) -> (a -> Base (Fix f) (m a)) -> a -> Fix f

type Base (Fix f)

type Base (Fix f) = f

data FlowTypeF a

The main AST for flowtypes.

Constructors

Object !(HashMap Text a)

ExactObject !(HashMap Text a)

ObjectMap !Text a

Array a

Tuple !(Vector a)

Fun !(Vector (Text, a)) a

Alt a a

Prim !PrimType

Nullable a

Omitable a

Literal !Value

Tag !Text

Name !FlowName

Instantiate !TypeRep a

PolyVar !TypeRep

PolyApply a ![TypeRep]

Instances

Functor FlowTypeF

Methods

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

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

Foldable FlowTypeF

Methods

fold :: Monoid m => FlowTypeF m -> m

foldMap :: Monoid m => (a -> m) -> FlowTypeF a -> m

foldr :: (a -> b -> b) -> b -> FlowTypeF a -> b

foldr' :: (a -> b -> b) -> b -> FlowTypeF a -> b

foldl :: (b -> a -> b) -> b -> FlowTypeF a -> b

foldl' :: (b -> a -> b) -> b -> FlowTypeF a -> b

foldr1 :: (a -> a -> a) -> FlowTypeF a -> a

foldl1 :: (a -> a -> a) -> FlowTypeF a -> a

toList :: FlowTypeF a -> [a]

null :: FlowTypeF a -> Bool

length :: FlowTypeF a -> Int

elem :: Eq a => a -> FlowTypeF a -> Bool

maximum :: Ord a => FlowTypeF a -> a

minimum :: Ord a => FlowTypeF a -> a

sum :: Num a => FlowTypeF a -> a

product :: Num a => FlowTypeF a -> a

Traversable FlowTypeF

Methods

traverse :: Applicative f => (a -> f b) -> FlowTypeF a -> f (FlowTypeF b)

sequenceA :: Applicative f => FlowTypeF (f a) -> f (FlowTypeF a)

mapM :: Monad m => (a -> m b) -> FlowTypeF a -> m (FlowTypeF b)

sequence :: Monad m => FlowTypeF (m a) -> m (FlowTypeF a)

Show1 FlowTypeF

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> FlowTypeF a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [FlowTypeF a] -> ShowS

Eq a => Eq (FlowTypeF a)

Methods

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

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

Show a => Show (FlowTypeF a)

Methods

showsPrec :: Int -> FlowTypeF a -> ShowS

show :: FlowTypeF a -> String

showList :: [FlowTypeF a] -> ShowS

Code generation

Wholesale ES6/flow modules

data FlowModuleOptions

Constructors

FlowModuleOptions

Fields

• flowPragmas :: [Text]

  You might want to change this to include e.g. flow-runtime

• flowHeader :: [Text]

Instances

Eq FlowModuleOptions

Methods

(==) :: FlowModuleOptions -> FlowModuleOptions -> Bool

(/=) :: FlowModuleOptions -> FlowModuleOptions -> Bool

Show FlowModuleOptions

Methods

showsPrec :: Int -> FlowModuleOptions -> ShowS

show :: FlowModuleOptions -> String

showList :: [FlowModuleOptions] -> ShowS

defaultFlowModuleOptions :: FlowModuleOptions

data Export where

Constructors

Export :: FlowTyped a => Proxy a -> Export

generateFlowModule :: FlowModuleOptions -> [Export] -> Text

writeFlowModule :: FlowModuleOptions -> FilePath -> [Export] -> IO ()

exportFlowTypeAs :: Text -> FlowType -> Text

Generate a export type declaration.

Utility functions

showFlowType :: FlowType -> Text

Pretty-print a flowtype in flowtype syntax

dependencies :: FlowTyped a => Proxy a -> Set FlowName

Compute all the dependencies of a FlowTyped thing, including itself.

Internals

defaultFlowType :: (Generic a, GFlowTyped (Rep a)) => Options -> Proxy a -> FlowType

flowType using Generic

defaultFlowTypeName :: (Generic a, Rep a ~ D1 (MetaData name mod pkg t) c, KnownSymbol name) => Proxy a -> Maybe Text

flowTypeName using Generic

data FlowName where

A name for a flowtyped data-type. These are returned by dependencies.

Constructors

FlowName :: (Typeable a, FlowTyped a) => Proxy a -> Text -> FlowName

Instances

Eq FlowName

Methods

(==) :: FlowName -> FlowName -> Bool

(/=) :: FlowName -> FlowName -> Bool

Ord FlowName

Methods

compare :: FlowName -> FlowName -> Ordering

(<) :: FlowName -> FlowName -> Bool

(<=) :: FlowName -> FlowName -> Bool

(>) :: FlowName -> FlowName -> Bool

(>=) :: FlowName -> FlowName -> Bool

max :: FlowName -> FlowName -> FlowName

min :: FlowName -> FlowName -> FlowName

Show FlowName

Methods

showsPrec :: Int -> FlowName -> ShowS

show :: FlowName -> String

showList :: [FlowName] -> ShowS

data PrimType

A primitive flow/javascript type

Constructors

Boolean

Number

String

Void

Mixed

Any

Instances

Eq PrimType

Methods

(==) :: PrimType -> PrimType -> Bool

(/=) :: PrimType -> PrimType -> Bool

Ord PrimType

Methods

compare :: PrimType -> PrimType -> Ordering

(<) :: PrimType -> PrimType -> Bool

(<=) :: PrimType -> PrimType -> Bool

(>) :: PrimType -> PrimType -> Bool

(>=) :: PrimType -> PrimType -> Bool

max :: PrimType -> PrimType -> PrimType

min :: PrimType -> PrimType -> PrimType

Read PrimType

Methods

readsPrec :: Int -> ReadS PrimType

readList :: ReadS [PrimType]

readPrec :: ReadPrec PrimType

readListPrec :: ReadPrec [PrimType]

Show PrimType

Methods

showsPrec :: Int -> PrimType -> ShowS

show :: PrimType -> String

showList :: [PrimType] -> ShowS

class GFlowTyped g

Minimal complete definition

gflowType

Instances

(KnownSymbol name, GFlowVal * * c) => GFlowTyped (D1 (MetaData name mod pkg t) c)

Methods

gflowType :: Options -> Proxy * (D1 (MetaData name mod pkg t) c x) -> FlowType

type FlowTypeI = Fix (Info `Compose` FlowTypeF)

data Info a

Constructors

Constr !Text FlowTypeI a

NoInfo a

Instances

Functor Info

Methods

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

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

Foldable Info

Methods

fold :: Monoid m => Info m -> m

foldMap :: Monoid m => (a -> m) -> Info a -> m

foldr :: (a -> b -> b) -> b -> Info a -> b

foldr' :: (a -> b -> b) -> b -> Info a -> b

foldl :: (b -> a -> b) -> b -> Info a -> b

foldl' :: (b -> a -> b) -> b -> Info a -> b

foldr1 :: (a -> a -> a) -> Info a -> a

foldl1 :: (a -> a -> a) -> Info a -> a

toList :: Info a -> [a]

null :: Info a -> Bool

length :: Info a -> Int

elem :: Eq a => a -> Info a -> Bool

maximum :: Ord a => Info a -> a

minimum :: Ord a => Info a -> a

sum :: Num a => Info a -> a

product :: Num a => Info a -> a

Traversable Info

Methods

traverse :: Applicative f => (a -> f b) -> Info a -> f (Info b)

sequenceA :: Applicative f => Info (f a) -> f (Info a)

mapM :: Monad m => (a -> m b) -> Info a -> m (Info b)

sequence :: Monad m => Info (m a) -> m (Info a)

Show1 Info

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Info a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Info a] -> ShowS

Show a => Show (Info a)

Methods

showsPrec :: Int -> Info a -> ShowS

show :: Info a -> String

showList :: [Info a] -> ShowS

data Var :: k -> Type where

Constructors

Var :: Var a

Instances

(Typeable k2 a, Typeable * k2) => FlowTyped (Var k2 a)

Methods

flowType :: Proxy * (Var k2 a) -> FlowType

flowTypeName :: Proxy * (Var k2 a) -> Maybe Text

flowTypeVars :: Proxy * (Var k2 a) -> [TypeRep]

flowOptions :: Proxy * (Var k2 a) -> Options

isPrim :: Proxy * (Var k2 a) -> Bool

class Typeable k a

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

typeRep :: Typeable k a => proxy a -> TypeRep

Takes a value of type a and returns a concrete representation of that type.

Since: 4.7.0.0