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

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

flowOptions :: Proxy * Bool -> Options

isPrim :: Proxy * Bool -> Bool

FlowTyped Char

Methods

flowType :: Proxy * Char -> FlowType

flowTypeName :: Proxy * Char -> Maybe Text

flowOptions :: Proxy * Char -> Options

isPrim :: Proxy * Char -> Bool

FlowTyped Double

Methods

flowType :: Proxy * Double -> FlowType

flowTypeName :: Proxy * Double -> Maybe Text

flowOptions :: Proxy * Double -> Options

isPrim :: Proxy * Double -> Bool

FlowTyped Float

Methods

flowType :: Proxy * Float -> FlowType

flowTypeName :: Proxy * Float -> Maybe Text

flowOptions :: Proxy * Float -> Options

isPrim :: Proxy * Float -> Bool

FlowTyped Int

Methods

flowType :: Proxy * Int -> FlowType

flowTypeName :: Proxy * Int -> Maybe Text

flowOptions :: Proxy * Int -> Options

isPrim :: Proxy * Int -> Bool

FlowTyped Int8

Methods

flowType :: Proxy * Int8 -> FlowType

flowTypeName :: Proxy * Int8 -> Maybe Text

flowOptions :: Proxy * Int8 -> Options

isPrim :: Proxy * Int8 -> Bool

FlowTyped Int16

Methods

flowType :: Proxy * Int16 -> FlowType

flowTypeName :: Proxy * Int16 -> Maybe Text

flowOptions :: Proxy * Int16 -> Options

isPrim :: Proxy * Int16 -> Bool

FlowTyped Int32

Methods

flowType :: Proxy * Int32 -> FlowType

flowTypeName :: Proxy * Int32 -> Maybe Text

flowOptions :: Proxy * Int32 -> Options

isPrim :: Proxy * Int32 -> Bool

FlowTyped Int64

Methods

flowType :: Proxy * Int64 -> FlowType

flowTypeName :: Proxy * Int64 -> Maybe Text

flowOptions :: Proxy * Int64 -> Options

isPrim :: Proxy * Int64 -> Bool

FlowTyped Word

Methods

flowType :: Proxy * Word -> FlowType

flowTypeName :: Proxy * Word -> Maybe Text

flowOptions :: Proxy * Word -> Options

isPrim :: Proxy * Word -> Bool

FlowTyped Word8

Methods

flowType :: Proxy * Word8 -> FlowType

flowTypeName :: Proxy * Word8 -> Maybe Text

flowOptions :: Proxy * Word8 -> Options

isPrim :: Proxy * Word8 -> Bool

FlowTyped Word16

Methods

flowType :: Proxy * Word16 -> FlowType

flowTypeName :: Proxy * Word16 -> Maybe Text

flowOptions :: Proxy * Word16 -> Options

isPrim :: Proxy * Word16 -> Bool

FlowTyped Word32

Methods

flowType :: Proxy * Word32 -> FlowType

flowTypeName :: Proxy * Word32 -> Maybe Text

flowOptions :: Proxy * Word32 -> Options

isPrim :: Proxy * Word32 -> Bool

FlowTyped Word64

Methods

flowType :: Proxy * Word64 -> FlowType

flowTypeName :: Proxy * Word64 -> Maybe Text

flowOptions :: Proxy * Word64 -> Options

isPrim :: Proxy * Word64 -> Bool

FlowTyped Scientific

Methods

flowType :: Proxy * Scientific -> FlowType

flowTypeName :: Proxy * Scientific -> Maybe Text

flowOptions :: Proxy * Scientific -> Options

isPrim :: Proxy * Scientific -> Bool

FlowTyped String

Methods

flowType :: Proxy * String -> FlowType

flowTypeName :: Proxy * String -> Maybe Text

flowOptions :: Proxy * String -> Options

isPrim :: Proxy * String -> Bool

FlowTyped Text

Methods

flowType :: Proxy * Text -> FlowType

flowTypeName :: Proxy * Text -> Maybe Text

flowOptions :: Proxy * Text -> Options

isPrim :: Proxy * Text -> Bool

FlowTyped UTCTime

Methods

flowType :: Proxy * UTCTime -> FlowType

flowTypeName :: Proxy * UTCTime -> Maybe Text

flowOptions :: Proxy * UTCTime -> Options

isPrim :: Proxy * UTCTime -> Bool

FlowTyped Value

Methods

flowType :: Proxy * Value -> FlowType

flowTypeName :: Proxy * Value -> Maybe Text

flowOptions :: Proxy * Value -> Options

isPrim :: Proxy * Value -> Bool

FlowTyped Text

Methods

flowType :: Proxy * Text -> FlowType

flowTypeName :: Proxy * Text -> Maybe Text

flowOptions :: Proxy * Text -> Options

isPrim :: Proxy * Text -> Bool

FlowTyped Void

Methods

flowType :: Proxy * Void -> FlowType

flowTypeName :: Proxy * Void -> Maybe Text

flowOptions :: Proxy * Void -> Options

isPrim :: Proxy * Void -> Bool

FlowTyped a => FlowTyped [a]

Methods

flowType :: Proxy * [a] -> FlowType

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

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

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

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

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

FlowTyped a => FlowTyped (Vector a)

Methods

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

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

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

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

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

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

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

isPrim :: Proxy * (a, b) -> 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

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

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

type FlowType = Fix FlowTypeF

data FlowTypeF a

The main AST for flowtypes.

Constructors

Object !(HashMap Text a)

ExactObject !(HashMap Text a)

Map !(Vector (Text, a))

Array a

Tuple !(Vector a)

Fun !(Vector (Text, a)) a

Alt a a

Prim !PrimType

Nullable a

Literal !Value

Tag !Text

Name !FlowName

Poly !Var !(Vector a)

PolyVar !Var

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

newtype Var

Constructors

Var

Fields

• varName :: Text

Instances

Eq Var

Methods

(==) :: Var -> Var -> Bool

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

Ord Var

Methods

compare :: Var -> Var -> Ordering

(<) :: Var -> Var -> Bool

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

(>) :: Var -> Var -> Bool

(>=) :: Var -> Var -> Bool

max :: Var -> Var -> Var

min :: Var -> Var -> Var

Read Var

Methods

readsPrec :: Int -> ReadS Var

readList :: ReadS [Var]

readPrec :: ReadPrec Var

readListPrec :: ReadPrec [Var]

Show Var

Methods

showsPrec :: Int -> Var -> ShowS

show :: Var -> String

showList :: [Var] -> ShowS