-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | CAES Language for Synchronous Hardware - As a Library
--   
--   CλaSH (pronounced ‘clash’) is a functional hardware description
--   language that borrows both its syntax and semantics from the
--   functional programming language Haskell. The CλaSH compiler transforms
--   these high-level descriptions to low-level synthesizable VHDL,
--   Verilog, or SystemVerilog.
--   
--   Features of CλaSH:
--   
--   <ul>
--   <li>Strongly typed (like VHDL), yet with a very high degree of type
--   inference, enabling both safe and fast prototying using consise
--   descriptions (like Verilog).</li>
--   <li>Interactive REPL: load your designs in an interpreter and easily
--   test all your component without needing to setup a test bench.</li>
--   <li>Higher-order functions, with type inference, result in designs
--   that are fully parametric by default.</li>
--   <li>Synchronous sequential circuit design based on streams of values,
--   called <tt>Signal</tt>s, lead to natural descriptions of feedback
--   loops.</li>
--   <li>Support for multiple clock domains, with type safe clock domain
--   crossing.</li>
--   </ul>
--   
--   This package provides:
--   
--   <ul>
--   <li>The CoreHW internal language: SystemF + Letrec +
--   Case-decomposition</li>
--   <li>The normalisation process that brings CoreHW in a normal form that
--   can be converted to a netlist</li>
--   <li>Blackbox/Primitive Handling</li>
--   </ul>
--   
--   Front-ends (for: parsing, typecheck, etc.) are provided by separate
--   packages:
--   
--   <ul>
--   <li><a>GHC/Haskell Frontend</a></li>
--   <li><a>Idris Frontend</a></li>
--   </ul>
--   
--   Prelude library:
--   <a>http://hackage.haskell.org/package/clash-prelude</a>
@package clash-lib
@version 0.6.21


-- | Transform/format a Netlist Identifier so that it is acceptable as a
--   HDL identifier
module CLaSH.Netlist.Id
mkBasicId' :: Bool -> Text -> Text
stripDollarPrefixes :: Text -> Text


-- | Type and instance definitions for Primitive
module CLaSH.Primitives.Types

-- | Primitive Definitions
type PrimMap a = HashMap Text (Primitive a)

-- | Externally defined primitive
data Primitive a

-- | A primitive that has a template that can be filled out by the backend
--   render
BlackBox :: !Text -> !(Either a a) -> Primitive a

-- | Name of the primitive
[name] :: Primitive a -> !Text

-- | Either a <i>declaration</i> or an <i>expression</i> template.
[template] :: Primitive a -> !(Either a a)

-- | A primitive that carries additional information
Primitive :: !Text -> !Text -> Primitive a

-- | Name of the primitive
[name] :: Primitive a -> !Text

-- | Additional information
[primType] :: Primitive a -> !Text
instance GHC.Show.Show a => GHC.Show.Show (CLaSH.Primitives.Types.Primitive a)
instance Data.Aeson.Types.FromJSON.FromJSON (CLaSH.Primitives.Types.Primitive Data.Text.Internal.Lazy.Text)


-- | Assortment of utility function used in the CLaSH library
module CLaSH.Util

-- | A class that can generate unique numbers
class MonadUnique m

-- | Get a new unique
getUniqueM :: MonadUnique m => m Int

-- | Create a TH expression that returns the a formatted string containing
--   the name of the module <a>curLoc</a> is spliced into, and the line
--   where it was spliced.
curLoc :: Q Exp

-- | Cache the result of a monadic action
makeCached :: (MonadState s m, Hashable k, Eq k) => k -> Lens' s (HashMap k v) -> m v -> m v

-- | Cache the result of a monadic action in a State 3 transformer layers
--   down
makeCachedT3 :: (MonadTrans t2, MonadTrans t1, MonadTrans t, Eq k, Hashable k, MonadState s m, Monad (t2 m), Monad (t1 (t2 m)), Monad (t (t1 (t2 m)))) => k -> Lens' s (HashMap k v) -> (t (t1 (t2 m))) v -> (t (t1 (t2 m))) v

-- | Spine-strict cache variant of <tt>mkCachedT3</tt>
makeCachedT3S :: (MonadTrans t2, MonadTrans t1, MonadTrans t, Eq k, Hashable k, MonadState s m, Monad (t2 m), Monad (t1 (t2 m)), Monad (t (t1 (t2 m))), NFData v) => k -> Lens' s (HashMap k v) -> (t (t1 (t2 m))) v -> (t (t1 (t2 m))) v

-- | Run a State-action using the State that is stored in a higher-layer
--   Monad
liftState :: (MonadState s m) => Lens' s s' -> State s' a -> m a

-- | Functorial version of <a>first</a>
firstM :: Functor f => (a -> f c) -> (a, b) -> f (c, b)

-- | Functorial version of <a>second</a>
secondM :: Functor f => (b -> f c) -> (a, b) -> f (a, c)
combineM :: (Applicative f) => (a -> f b) -> (c -> f d) -> (a, c) -> f (b, d)

-- | Performs trace when first argument evaluates to <a>True</a>
traceIf :: Bool -> String -> a -> a

-- | Monadic version of <a>partition</a>
partitionM :: Monad m => (a -> m Bool) -> [a] -> m ([a], [a])

-- | Monadic version of <a>mapAccumL</a>
mapAccumLM :: (Monad m) => (acc -> x -> m (acc, y)) -> acc -> [x] -> m (acc, [y])

-- | Composition of a unary function with a binary function
dot :: (c -> d) -> (a -> b -> c) -> a -> b -> d

-- | if-then-else as a function on an argument
ifThenElse :: (a -> Bool) -> (a -> b) -> (a -> b) -> a -> b

-- | Applicative version of 'GHC.Types.(:)'
(<:>) :: Applicative f => f a -> f [a] -> f [a]
infixr 5 <:>

-- | Safe indexing, returns a <a>Nothing</a> if the index does not exist
indexMaybe :: [a] -> Int -> Maybe a

-- | Unsafe indexing, return a custom error message when indexing fails
indexNote :: String -> [a] -> Int -> a

-- | Split the second list at the length of the first list
splitAtList :: [b] -> [a] -> ([a], [a])
clashLibVersion :: Version

-- | x y -&gt; ceiling (logBase x y), x &gt; 1 &amp;&amp; y &gt; 0
clogBase :: Integer -> Integer -> Maybe Int

-- | Build lenses (and traversals) with a sensible default configuration.
--   
--   <i>e.g.</i>
--   
--   <pre>
--   data FooBar
--     = Foo { _x, _y :: <a>Int</a> }
--     | Bar { _x :: <a>Int</a> }
--   <a>makeLenses</a> ''FooBar
--   </pre>
--   
--   will create
--   
--   <pre>
--   x :: <a>Lens'</a> FooBar <a>Int</a>
--   x f (Foo a b) = (\a' -&gt; Foo a' b) &lt;$&gt; f a
--   x f (Bar a)   = Bar &lt;$&gt; f a
--   y :: <a>Traversal'</a> FooBar <a>Int</a>
--   y f (Foo a b) = (\b' -&gt; Foo a  b') &lt;$&gt; f b
--   y _ c@(Bar _) = pure c
--   </pre>
--   
--   <pre>
--   <a>makeLenses</a> = <a>makeLensesWith</a> <a>lensRules</a>
--   </pre>
makeLenses :: Name -> DecsQ
instance GHC.Base.Monad m => CLaSH.Util.MonadUnique (Control.Monad.Trans.State.Lazy.StateT GHC.Types.Int m)


-- | Utility functions to generate Primitives
module CLaSH.Primitives.Util

-- | Generate a set of primitives that are found in the primitive
--   definition files in the given directories.
generatePrimMap :: [FilePath] -> IO (PrimMap Text)


-- | Variables in CoreHW
module CLaSH.Core.Var

-- | Variables in CoreHW
data Var a

-- | Constructor for type variables
TyVar :: Name a -> Embed Kind -> Var a
[varName] :: Var a -> Name a
[varKind] :: Var a -> Embed Kind

-- | Constructor for term variables
Id :: Name a -> Embed Type -> Var a
[varName] :: Var a -> Name a
[varType] :: Var a -> Embed Type

-- | Term variable
type Id = Var Term

-- | Type variable
type TyVar = Var Type

-- | Change the name of a variable
modifyVarName :: (Name a -> Name a) -> Var a -> Var a
instance Control.DeepSeq.NFData (CLaSH.Core.Var.Var a)
instance GHC.Generics.Generic (CLaSH.Core.Var.Var a)
instance GHC.Show.Show (CLaSH.Core.Var.Var a)
instance GHC.Classes.Eq (CLaSH.Core.Var.Var a)
instance (Data.Typeable.Internal.Typeable a, Unbound.Generics.LocallyNameless.Alpha.Alpha a) => Unbound.Generics.LocallyNameless.Alpha.Alpha (CLaSH.Core.Var.Var a)
instance GHC.Generics.Generic b => Unbound.Generics.LocallyNameless.Subst.Subst CLaSH.Core.Term.Term (CLaSH.Core.Var.Var b)
instance GHC.Generics.Generic b => Unbound.Generics.LocallyNameless.Subst.Subst CLaSH.Core.Type.Type (CLaSH.Core.Var.Var b)


-- | Data Constructors in CoreHW
module CLaSH.Core.DataCon

-- | Data Constructor
data DataCon
MkData :: !DcName -> !ConTag -> !Type -> [TyName] -> [TyName] -> [Type] -> DataCon

-- | Name of the DataCon
[dcName] :: DataCon -> !DcName

-- | Syntactical position in the type definition
[dcTag] :: DataCon -> !ConTag

-- | Type of the 'DataCon
[dcType] :: DataCon -> !Type

-- | Universally quantified type-variables, these type variables are also
--   part of the result type of the DataCon
[dcUnivTyVars] :: DataCon -> [TyName]

-- | Existentially quantified type-variables, these type variables are not
--   part of the result of the DataCon, but only of the arguments.
[dcExtTyVars] :: DataCon -> [TyName]

-- | Argument types
[dcArgTys] :: DataCon -> [Type]

-- | DataCon reference
type DcName = Name DataCon

-- | Syntactical position of the DataCon in the type definition
type ConTag = Int

-- | Given a DataCon and a list of types, the type variables of the DataCon
--   type are substituted for the list of types. The argument types are
--   returned.
--   
--   The list of types should be equal to the number of type variables,
--   otherwise <tt>Nothing</tt> is returned.
dataConInstArgTys :: DataCon -> [Type] -> Maybe [Type]
instance Control.DeepSeq.NFData CLaSH.Core.DataCon.DataCon
instance GHC.Generics.Generic CLaSH.Core.DataCon.DataCon
instance GHC.Show.Show CLaSH.Core.DataCon.DataCon
instance GHC.Classes.Eq CLaSH.Core.DataCon.DataCon
instance GHC.Classes.Ord CLaSH.Core.DataCon.DataCon
instance Unbound.Generics.LocallyNameless.Alpha.Alpha CLaSH.Core.DataCon.DataCon
instance Unbound.Generics.LocallyNameless.Subst.Subst a CLaSH.Core.DataCon.DataCon


-- | Type Constructors in CoreHW
module CLaSH.Core.TyCon

-- | Type Constructor
data TyCon

-- | Algorithmic DataCons
AlgTyCon :: !TyConName -> !Kind -> !Int -> !AlgTyConRhs -> TyCon

-- | Name of the TyCon
[tyConName] :: TyCon -> !TyConName

-- | Kind of the TyCon
[tyConKind] :: TyCon -> !Kind

-- | Number of type arguments
[tyConArity] :: TyCon -> !Int

-- | DataCon definitions
[algTcRhs] :: TyCon -> !AlgTyConRhs

-- | Function TyCons (e.g. type families)
FunTyCon :: !TyConName -> !Kind -> !Int -> [([Type], Type)] -> TyCon

-- | Name of the TyCon
[tyConName] :: TyCon -> !TyConName

-- | Kind of the TyCon
[tyConKind] :: TyCon -> !Kind

-- | Number of type arguments
[tyConArity] :: TyCon -> !Int

-- | List of: ([LHS match types], RHS type)
[tyConSubst] :: TyCon -> [([Type], Type)]

-- | Primitive TyCons
PrimTyCon :: !TyConName -> !Kind -> !Int -> TyCon

-- | Name of the TyCon
[tyConName] :: TyCon -> !TyConName

-- | Kind of the TyCon
[tyConKind] :: TyCon -> !Kind

-- | Number of type arguments
[tyConArity] :: TyCon -> !Int

-- | To close the loop on the type hierarchy
SuperKindTyCon :: !TyConName -> TyCon

-- | Name of the TyCon
[tyConName] :: TyCon -> !TyConName

-- | TyCon reference
type TyConName = Name TyCon

-- | The RHS of an Algebraic Datatype
data AlgTyConRhs
DataTyCon :: [DataCon] -> AlgTyConRhs

-- | The DataCons of a TyCon
[dataCons] :: AlgTyConRhs -> [DataCon]
NewTyCon :: !DataCon -> ([TyName], Type) -> AlgTyConRhs

-- | The newtype DataCon
[dataCon] :: AlgTyConRhs -> !DataCon

-- | The argument type of the newtype DataCon in eta-reduced form, which is
--   just the representation of the TyCon. The TyName's are the
--   type-variables from the corresponding TyCon.
[ntEtadRhs] :: AlgTyConRhs -> ([TyName], Type)

-- | Create a Kind out of a TyConName
mkKindTyCon :: TyConName -> Kind -> TyCon

-- | Does the TyCon look like a tuple TyCon
isTupleTyConLike :: TyConName -> Bool

-- | Get the DataCons belonging to a TyCon
tyConDataCons :: TyCon -> [DataCon]
instance Control.DeepSeq.NFData CLaSH.Core.TyCon.TyCon
instance GHC.Generics.Generic CLaSH.Core.TyCon.TyCon
instance Unbound.Generics.LocallyNameless.Alpha.Alpha CLaSH.Core.TyCon.AlgTyConRhs
instance Control.DeepSeq.NFData CLaSH.Core.TyCon.AlgTyConRhs
instance GHC.Generics.Generic CLaSH.Core.TyCon.AlgTyConRhs
instance GHC.Show.Show CLaSH.Core.TyCon.AlgTyConRhs
instance GHC.Show.Show CLaSH.Core.TyCon.TyCon
instance GHC.Classes.Eq CLaSH.Core.TyCon.TyCon
instance GHC.Classes.Ord CLaSH.Core.TyCon.TyCon
instance Unbound.Generics.LocallyNameless.Alpha.Alpha CLaSH.Core.TyCon.TyCon


-- | Builtin Type and Kind definitions
module CLaSH.Core.TysPrim
liftedTypeKind :: Type
typeNatKind :: Type
typeSymbolKind :: Type
intPrimTy :: Type
integerPrimTy :: Type
charPrimTy :: Type
stringPrimTy :: Type
voidPrimTy :: Type
wordPrimTy :: Type
int64PrimTy :: Type
word64PrimTy :: Type
tysPrimMap :: HashMap TyConName TyCon


-- | Term Literal
module CLaSH.Core.Literal

-- | Term Literal
data Literal
IntegerLiteral :: !Integer -> Literal
IntLiteral :: !Integer -> Literal
WordLiteral :: !Integer -> Literal
Int64Literal :: !Integer -> Literal
Word64Literal :: !Integer -> Literal
StringLiteral :: !String -> Literal
RationalLiteral :: !Rational -> Literal
CharLiteral :: !Char -> Literal

-- | Determines the Type of a Literal
literalType :: Literal -> Type
instance Control.DeepSeq.NFData CLaSH.Core.Literal.Literal
instance GHC.Generics.Generic CLaSH.Core.Literal.Literal
instance GHC.Show.Show CLaSH.Core.Literal.Literal
instance GHC.Classes.Ord CLaSH.Core.Literal.Literal
instance GHC.Classes.Eq CLaSH.Core.Literal.Literal
instance Unbound.Generics.LocallyNameless.Alpha.Alpha CLaSH.Core.Literal.Literal
instance Unbound.Generics.LocallyNameless.Subst.Subst a CLaSH.Core.Literal.Literal


-- | Term representation in the CoreHW language: System F + LetRec + Case
module CLaSH.Core.Term

-- | Term representation in the CoreHW language: System F + LetRec + Case
data Term

-- | Variable reference
Var :: !Type -> !TmName -> Term

-- | Datatype constructor
Data :: !DataCon -> Term

-- | Literal
Literal :: !Literal -> Term

-- | Primitive
Prim :: !Text -> !Type -> Term

-- | Term-abstraction
Lam :: !(Bind Id Term) -> Term

-- | Type-abstraction
TyLam :: !(Bind TyVar Term) -> Term

-- | Application
App :: !Term -> !Term -> Term

-- | Type-application
TyApp :: !Term -> !Type -> Term

-- | Recursive let-binding
Letrec :: !(Bind (Rec [LetBinding]) Term) -> Term

-- | Case-expression: subject, type of alternatives, list of alternatives
Case :: !Term -> !Type -> [Bind Pat Term] -> Term

-- | Term reference
type TmName = Name Term

-- | Binding in a LetRec construct
type LetBinding = (Id, Embed Term)

-- | Patterns in the LHS of a case-decomposition
data Pat

-- | Datatype pattern, '[TyVar]' bind existentially-quantified
--   type-variables of a DataCon
DataPat :: !(Embed DataCon) -> !(Rebind [TyVar] [Id]) -> Pat

-- | Literal pattern
LitPat :: !(Embed Literal) -> Pat

-- | Default pattern
DefaultPat :: Pat
instance Control.DeepSeq.NFData CLaSH.Core.Term.Term
instance GHC.Generics.Generic CLaSH.Core.Term.Term
instance GHC.Show.Show CLaSH.Core.Term.Term
instance Unbound.Generics.LocallyNameless.Alpha.Alpha CLaSH.Core.Term.Pat
instance Control.DeepSeq.NFData CLaSH.Core.Term.Pat
instance GHC.Generics.Generic CLaSH.Core.Term.Pat
instance GHC.Show.Show CLaSH.Core.Term.Pat
instance GHC.Classes.Eq CLaSH.Core.Term.Pat
instance GHC.Classes.Eq CLaSH.Core.Term.Term
instance GHC.Classes.Ord CLaSH.Core.Term.Term
instance Unbound.Generics.LocallyNameless.Alpha.Alpha CLaSH.Core.Term.Term
instance Unbound.Generics.LocallyNameless.Subst.Subst CLaSH.Core.Type.Type CLaSH.Core.Term.Pat
instance Unbound.Generics.LocallyNameless.Subst.Subst CLaSH.Core.Term.Term CLaSH.Core.Term.Pat
instance Unbound.Generics.LocallyNameless.Subst.Subst CLaSH.Core.Term.Term CLaSH.Core.Term.Term
instance Unbound.Generics.LocallyNameless.Subst.Subst CLaSH.Core.Type.Type CLaSH.Core.Term.Term


-- | Capture-free substitution function for CoreHW
module CLaSH.Core.Subst

-- | Substitutes types in a type
substTys :: [(TyName, Type)] -> Type -> Type

-- | Substitutes a type in a type
substTy :: TyName -> Type -> Type -> Type

-- | Substitutes kinds in a kind
substKindWith :: [(KiName, Kind)] -> Kind -> Kind

-- | Substitutes a type in a term
substTyInTm :: TyName -> Type -> Term -> Term

-- | Substitutes types in a term
substTysinTm :: [(TyName, Type)] -> Term -> Term

-- | Substitutes a term in a term
substTm :: TmName -> Term -> Term -> Term

-- | Substitutes terms in a term
substTms :: [(TmName, Term)] -> Term -> Term


-- | Types in CoreHW
module CLaSH.Core.Type

-- | Types in CoreHW: function and polymorphic types
data Type

-- | Type variable
VarTy :: !Kind -> !TyName -> Type

-- | Type constant
ConstTy :: !ConstTy -> Type

-- | Polymorphic Type
ForAllTy :: !(Bind TyVar Type) -> Type

-- | Type Application
AppTy :: !Type -> !Type -> Type

-- | Type literal
LitTy :: !LitTy -> Type

-- | An easier view on types
data TypeView

-- | Function type
FunTy :: !Type -> !Type -> TypeView

-- | Applied TyCon
TyConApp :: !TyConName -> [Type] -> TypeView

-- | Neither of the above
OtherType :: !Type -> TypeView

-- | Type Constants
data ConstTy

-- | TyCon type
TyCon :: !TyConName -> ConstTy

-- | Function type
Arrow :: ConstTy

-- | Literal Types
data LitTy
NumTy :: !Integer -> LitTy
SymTy :: !String -> LitTy

-- | The level above types
type Kind = Type

-- | Either a Kind or a Type
type KindOrType = Type

-- | Reference to a Kind
type KiName = Name Kind

-- | Reference to a Type
type TyName = Name Type

-- | Type variable
type TyVar = Var Type

-- | An easier view on types
tyView :: Type -> TypeView

-- | A view on types in which newtypes are transparent, the Signal type is
--   transparent, and type functions are evaluated to WHNF (when possible).
--   
--   Only strips away one "layer".
coreView :: HashMap TyConName TyCon -> Type -> Maybe Type

-- | Determine the kind of a type
typeKind :: HashMap TyConName TyCon -> Type -> Kind

-- | Make a Type out of a TyCon
mkTyConTy :: TyConName -> Type

-- | Make a function type of an argument and result type
mkFunTy :: Type -> Type -> Type

-- | Make a TyCon Application out of a TyCon and a list of argument types
mkTyConApp :: TyConName -> [Type] -> Type

-- | Split a function type in an argument and result type
splitFunTy :: HashMap TyConName TyCon -> Type -> Maybe (Type, Type)
splitFunTys :: HashMap TyConName TyCon -> Type -> ([Type], Type)

-- | Split a poly-function type in a: list of type-binders and argument
--   types, and the result type
splitFunForallTy :: Type -> ([Either TyVar Type], Type)

-- | Split a poly-function type in a: list of type-binders and argument
--   types, and the result type. Looks through <tt>Signal</tt> and type
--   functions.
splitCoreFunForallTy :: HashMap TyConName TyCon -> Type -> ([Either TyVar Type], Type)

-- | Split a TyCon Application in a TyCon and its arguments
splitTyConAppM :: Type -> Maybe (TyConName, [Type])

-- | Is a type a polymorphic or function type?
isPolyFunTy :: Type -> Bool

-- | Is a type a polymorphic or function type under <a>coreView</a>?
isPolyFunCoreTy :: HashMap TyConName TyCon -> Type -> Bool

-- | Is a type polymorphic?
isPolyTy :: Type -> Bool

-- | Is a type a function type?
isFunTy :: HashMap TyConName TyCon -> Type -> Bool

-- | Apply a function type to an argument type and get the result type
applyFunTy :: HashMap TyConName TyCon -> Type -> Type -> Type

-- | Substitute the type variable of a type (<a>ForAllTy</a>) with another
--   type
applyTy :: Fresh m => HashMap TyConName TyCon -> Type -> KindOrType -> m Type
findFunSubst :: HashMap TyConName TyCon -> [([Type], Type)] -> [Type] -> Maybe Type
reduceTypeFamily :: HashMap TyConName TyCon -> Type -> Maybe Type

-- | The type of GHC.Err.undefined :: forall a . a
undefinedTy :: Type
instance GHC.Show.Show CLaSH.Core.Type.TypeView
instance Unbound.Generics.LocallyNameless.Alpha.Alpha CLaSH.Core.Type.ConstTy
instance Control.DeepSeq.NFData CLaSH.Core.Type.ConstTy
instance GHC.Generics.Generic CLaSH.Core.Type.ConstTy
instance GHC.Show.Show CLaSH.Core.Type.ConstTy
instance Control.DeepSeq.NFData CLaSH.Core.Type.Type
instance GHC.Generics.Generic CLaSH.Core.Type.Type
instance GHC.Show.Show CLaSH.Core.Type.Type
instance Unbound.Generics.LocallyNameless.Alpha.Alpha CLaSH.Core.Type.LitTy
instance Control.DeepSeq.NFData CLaSH.Core.Type.LitTy
instance GHC.Generics.Generic CLaSH.Core.Type.LitTy
instance GHC.Show.Show CLaSH.Core.Type.LitTy
instance Unbound.Generics.LocallyNameless.Alpha.Alpha CLaSH.Core.Type.Type
instance Unbound.Generics.LocallyNameless.Subst.Subst a CLaSH.Core.Type.LitTy
instance Unbound.Generics.LocallyNameless.Subst.Subst a CLaSH.Core.Type.ConstTy
instance Unbound.Generics.LocallyNameless.Subst.Subst CLaSH.Core.Term.Term CLaSH.Core.Type.Type
instance Unbound.Generics.LocallyNameless.Subst.Subst CLaSH.Core.Type.Type CLaSH.Core.Type.Type
instance GHC.Classes.Eq CLaSH.Core.Type.Type
instance GHC.Classes.Ord CLaSH.Core.Type.Type


-- | Free variable calculations
module CLaSH.Core.FreeVars

-- | Gives the free type-variables in a Type
typeFreeVars :: Fold Type TyName

-- | Gives the free term-variables of a Term
termFreeIds :: Fold Term TmName

-- | Gives the free type-variables of a Term
termFreeTyVars :: Fold Term TyName


-- | Pretty printing class and instances for CoreHW
module CLaSH.Core.Pretty

-- | Pretty printing Show-like typeclass
class Pretty p where ppr = pprPrec 0
ppr :: (Pretty p, Applicative m, LFresh m) => p -> m Doc
pprPrec :: (Pretty p, Applicative m, LFresh m) => Rational -> p -> m Doc

-- | Print a Pretty thing to a String
showDoc :: Pretty p => p -> String
instance GHC.Classes.Ord CLaSH.Core.Pretty.TypePrec
instance GHC.Classes.Eq CLaSH.Core.Pretty.TypePrec
instance CLaSH.Core.Pretty.Pretty (Unbound.Generics.LocallyNameless.Name.Name a)
instance CLaSH.Core.Pretty.Pretty a => CLaSH.Core.Pretty.Pretty [a]
instance CLaSH.Core.Pretty.Pretty (CLaSH.Core.Var.Id, CLaSH.Core.Term.Term)
instance CLaSH.Core.Pretty.Pretty CLaSH.Core.Type.Type
instance CLaSH.Core.Pretty.Pretty (CLaSH.Core.Var.Var CLaSH.Core.Type.Type)
instance CLaSH.Core.Pretty.Pretty CLaSH.Core.TyCon.TyCon
instance CLaSH.Core.Pretty.Pretty CLaSH.Core.Type.LitTy
instance CLaSH.Core.Pretty.Pretty CLaSH.Core.Term.Term
instance CLaSH.Core.Pretty.Pretty (CLaSH.Core.Var.Var CLaSH.Core.Term.Term)
instance CLaSH.Core.Pretty.Pretty CLaSH.Core.DataCon.DataCon
instance CLaSH.Core.Pretty.Pretty CLaSH.Core.Literal.Literal
instance CLaSH.Core.Pretty.Pretty CLaSH.Core.Term.Pat


-- | Smart constructor and destructor functions for CoreHW
module CLaSH.Core.Util

-- | Type environment/context
type Gamma = HashMap TmName Type

-- | Kind environment/context
type Delta = HashMap TyName Kind

-- | Determine the type of a term
termType :: (Functor m, Fresh m) => HashMap TyConName TyCon -> Term -> m Type

-- | Split a (Type)Application in the applied term and it arguments
collectArgs :: Term -> (Term, [Either Term Type])

-- | Split a (Type)Abstraction in the bound variables and the abstracted
--   term
collectBndrs :: Fresh m => Term -> m ([Either Id TyVar], Term)

-- | Get the result type of a polymorphic function given a list of
--   arguments
applyTypeToArgs :: Fresh m => HashMap TyConName TyCon -> Type -> [Either Term Type] -> m Type

-- | Get the list of term-binders out of a DataType pattern
patIds :: Pat -> [Id]

-- | Make a type variable
mkTyVar :: Kind -> TyName -> TyVar

-- | Make a term variable
mkId :: Type -> TmName -> Id

-- | Abstract a term over a list of term and type variables
mkAbstraction :: Term -> [Either Id TyVar] -> Term

-- | Abstract a term over a list of term variables
mkTyLams :: Term -> [TyVar] -> Term

-- | Abstract a term over a list of type variables
mkLams :: Term -> [Id] -> Term

-- | Apply a list of types and terms to a term
mkApps :: Term -> [Either Term Type] -> Term

-- | Apply a list of terms to a term
mkTmApps :: Term -> [Term] -> Term

-- | Apply a list of types to a term
mkTyApps :: Term -> [Type] -> Term

-- | Does a term have a function type?
isFun :: (Functor m, Fresh m) => HashMap TyConName TyCon -> Term -> m Bool

-- | Does a term have a function or polymorphic type?
isPolyFun :: (Functor m, Fresh m) => HashMap TyConName TyCon -> Term -> m Bool

-- | Is a term a term-abstraction?
isLam :: Term -> Bool

-- | Is a term a recursive let-binding?
isLet :: Term -> Bool

-- | Is a term a variable reference?
isVar :: Term -> Bool

-- | Is a term a datatype constructor?
isCon :: Term -> Bool

-- | Is a term a primitive?
isPrim :: Term -> Bool

-- | Make variable reference out of term variable
idToVar :: Id -> Term

-- | Make a term variable out of a variable reference
varToId :: Term -> Id
termSize :: Term -> Int

-- | Create a vector of supplied elements
mkVec :: DataCon -> DataCon -> Type -> Integer -> [Term] -> Term

-- | Append elements to the supplied vector
appendToVec :: DataCon -> Type -> Term -> Integer -> [Term] -> Term

-- | Create let-bindings with case-statements that select elements out of a
--   vector. Returns both the variables to which element-selections are
--   bound and the let-bindings
extractElems :: DataCon -> Type -> Char -> Integer -> Term -> [(Term, [LetBinding])]

-- | Determine whether a type is isomorphic to
--   <a>CLaSH.Signal.Internal.Signal'</a>
--   
--   It is i.e.:
--   
--   <ul>
--   <li>Signal' clk a</li>
--   <li>(Signal' clk a, Signal' clk b)</li>
--   <li>Vec n (Signal' clk a)</li>
--   <li>data Wrap = W (Signal clk' Int)</li>
--   <li>etc.</li>
--   </ul>
isSignalType :: HashMap TyConName TyCon -> Type -> Bool
tyNatSize :: HashMap TyConName TyCon -> Type -> Except String Integer


-- | Types used in BlackBox modules
module CLaSH.Netlist.BlackBox.Types

-- | A BlackBox Template is a List of Elements
type BlackBoxTemplate = [Element]

-- | Elements of a blackbox context
data Element

-- | Constant
C :: !Text -> Element

-- | Component instantiation hole
D :: !Decl -> Element

-- | Output hole
O :: Element

-- | Input hole
I :: !Int -> Element

-- | Literal hole
L :: !Int -> Element

-- | Symbol hole
Sym :: !Text -> !Int -> Element

-- | Clock hole (Maybe clk corresponding to input, clk corresponding to
--   output if Nothing)
Clk :: !(Maybe Int) -> Element

-- | Reset hole
Rst :: !(Maybe Int) -> Element

-- | Type declaration hole
Typ :: !(Maybe Int) -> Element

-- | Type root hole
TypM :: !(Maybe Int) -> Element

-- | Error value hole
Err :: !(Maybe Int) -> Element

-- | Select element type from a vector type
TypElem :: !Element -> Element

-- | Hole for the name of the component in which the blackbox is
--   instantiated
CompName :: Element

-- | Index data type hole, the field is the (exclusive) maximum index
IndexType :: !Element -> Element

-- | Size of a type hole
Size :: !Element -> Element

-- | Length of a vector hole
Length :: !Element -> Element

-- | Hole containing a filepath for a data file
FilePath :: !Element -> Element

-- | Hole marking beginning (True) or end (False) of a generative construct
Gen :: !Bool -> Element
IF :: !Element -> [Element] -> [Element] -> Element
And :: [Element] -> Element

-- | Hole indicating whether Int<i>Word</i>Integer are 64-Bit
IW64 :: Element

-- | Hole indicating which synthesis tool we're generating HDL for
HdlSyn :: HdlSyn -> Element

-- | Convert to (True)/from(False) a bit-vector
BV :: !Bool -> [Element] -> !Element -> Element
IsLit :: !Int -> Element
IsVar :: !Int -> Element
Vars :: !Int -> Element
GenSym :: [Element] -> !Int -> Element
SigD :: [Element] -> !(Maybe Int) -> Element

-- | Component instantiation hole. First argument indicates which function
--   argument to instantiate. Second argument corresponds to output and
--   input assignments, where the first element is the output assignment,
--   and the subsequent elements are the consecutive input assignments.
--   
--   The LHS of the tuple is the name of the signal, while the RHS of the
--   tuple is the type of the signal
data Decl
Decl :: !Int -> [(BlackBoxTemplate, BlackBoxTemplate)] -> Decl
data HdlSyn
Vivado :: HdlSyn
Other :: HdlSyn
instance GHC.Show.Show CLaSH.Netlist.BlackBox.Types.Decl
instance GHC.Show.Show CLaSH.Netlist.BlackBox.Types.Element
instance GHC.Read.Read CLaSH.Netlist.BlackBox.Types.HdlSyn
instance GHC.Show.Show CLaSH.Netlist.BlackBox.Types.HdlSyn
instance GHC.Classes.Eq CLaSH.Netlist.BlackBox.Types.HdlSyn


-- | Parser definitions for BlackBox templates
module CLaSH.Netlist.BlackBox.Parser

-- | Parse a text as a BlackBoxTemplate, returns a list of errors in case
--   parsing fails
runParse :: Text -> (BlackBoxTemplate, [Error LineColPos])


-- | Type and instance definitions for Netlist modules
module CLaSH.Netlist.Types

-- | Monad that caches generated components (StateT) and remembers hidden
--   inputs of components that are being generated (WriterT)
newtype NetlistMonad a
NetlistMonad :: WriterT (Set (Identifier, HWType)) (StateT NetlistState (FreshMT IO)) a -> NetlistMonad a
[runNetlist] :: NetlistMonad a -> WriterT (Set (Identifier, HWType)) (StateT NetlistState (FreshMT IO)) a

-- | State of the NetlistMonad
data NetlistState
NetlistState :: HashMap TmName (Type, SrcSpan, Term) -> Gamma -> !Int -> HashMap TmName (SrcSpan, Component) -> PrimMap BlackBoxTemplate -> (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)) -> HashMap TyConName TyCon -> !(Identifier, SrcSpan) -> [(String, FilePath)] -> Int -> (Identifier -> Identifier) -> [Identifier] -> [Identifier] -> HashMap TmName Identifier -> NetlistState

-- | Global binders
[_bindings] :: NetlistState -> HashMap TmName (Type, SrcSpan, Term)

-- | Type environment/context
[_varEnv] :: NetlistState -> Gamma

-- | Number of signal declarations
[_varCount] :: NetlistState -> !Int

-- | Cached components
[_components] :: NetlistState -> HashMap TmName (SrcSpan, Component)

-- | Primitive Definitions
[_primitives] :: NetlistState -> PrimMap BlackBoxTemplate

-- | Hardcoded Type -&gt; HWType translator
[_typeTranslator] :: NetlistState -> HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)

-- | TyCon cache
[_tcCache] :: NetlistState -> HashMap TyConName TyCon
[_curCompNm] :: NetlistState -> !(Identifier, SrcSpan)
[_dataFiles] :: NetlistState -> [(String, FilePath)]
[_intWidth] :: NetlistState -> Int
[_mkBasicIdFn] :: NetlistState -> Identifier -> Identifier
[_seenIds] :: NetlistState -> [Identifier]
[_seenComps] :: NetlistState -> [Identifier]
[_componentNames] :: NetlistState -> HashMap TmName Identifier

-- | Signal reference
type Identifier = Text

-- | Component: base unit of a Netlist
data Component
Component :: !Identifier -> [(Identifier, HWType)] -> [(Identifier, HWType)] -> [(Identifier, HWType)] -> [Declaration] -> Component

-- | Name of the component
[componentName] :: Component -> !Identifier

-- | Ports that have no correspondence the original function definition
[hiddenPorts] :: Component -> [(Identifier, HWType)]

-- | Input ports
[inputs] :: Component -> [(Identifier, HWType)]

-- | Output ports
[outputs] :: Component -> [(Identifier, HWType)]

-- | Internal declarations
[declarations] :: Component -> [Declaration]

-- | Size indication of a type (e.g. bit-size or number of elements)
type Size = Int

-- | Representable hardware types
data HWType

-- | Empty type
Void :: HWType

-- | String type
String :: HWType

-- | Boolean type
Bool :: HWType

-- | BitVector of a specified size
BitVector :: !Size -> HWType

-- | Unsigned integer with specified (exclusive) upper bounder
Index :: !Integer -> HWType

-- | Signed integer of a specified size
Signed :: !Size -> HWType

-- | Unsigned integer of a specified size
Unsigned :: !Size -> HWType

-- | Vector type
Vector :: !Size -> !HWType -> HWType

-- | Sum type: Name and Constructor names
Sum :: !Identifier -> [Identifier] -> HWType

-- | Product type: Name and field types
Product :: !Identifier -> [HWType] -> HWType

-- | Sum-of-Product type: Name and Constructor names + field types
SP :: !Identifier -> [(Identifier, [HWType])] -> HWType

-- | Clock type with specified name and period
Clock :: !Identifier -> !Integer -> HWType

-- | Reset type corresponding to clock with a specified name and period
Reset :: !Identifier -> !Integer -> HWType

-- | Internals of a Component
data Declaration

-- | Signal assignment:
--   
--   <ul>
--   <li>Signal to assign</li>
--   <li>Assigned expression</li>
--   </ul>
Assignment :: !Identifier -> !Expr -> Declaration

-- | Conditional signal assignment:
--   
--   <ul>
--   <li>Signal to assign</li>
--   <li>Type of the result/alternatives</li>
--   <li>Scrutinized expression</li>
--   <li>Type of the scrutinee</li>
--   <li>List of: (Maybe expression scrutinized expression is compared
--   with,RHS of alternative)</li>
--   </ul>
CondAssignment :: !Identifier -> !HWType -> !Expr -> !HWType -> [(Maybe Literal, Expr)] -> Declaration

-- | Instantiation of another component
InstDecl :: !Identifier -> !Identifier -> [(Identifier, PortDirection, HWType, Expr)] -> Declaration

-- | Instantiation of blackbox declaration
BlackBoxD :: !Text -> !BlackBoxTemplate -> BlackBoxContext -> Declaration

-- | Signal declaration
NetDecl :: !Identifier -> !HWType -> Declaration
data PortDirection
In :: PortDirection
Out :: PortDirection

-- | Expression Modifier
data Modifier

-- | Index the expression: (Type of expression,DataCon tag,Field Tag)
Indexed :: (HWType, Int, Int) -> Modifier

-- | See expression in a DataCon context: (Type of the expression, DataCon
--   tag)
DC :: (HWType, Int) -> Modifier

-- | See the expression in the context of a Vector append operation
VecAppend :: Modifier

-- | Expression used in RHS of a declaration
data Expr

-- | Literal expression
Literal :: !(Maybe (HWType, Size)) -> !Literal -> Expr

-- | DataCon application
DataCon :: !HWType -> !Modifier -> [Expr] -> Expr

-- | Signal reference
Identifier :: !Identifier -> !(Maybe Modifier) -> Expr

-- | <tt>Left e</tt>: tagToEnum
DataTag :: !HWType -> !(Either Identifier Identifier) -> Expr

-- | Instantiation of a BlackBox expression
BlackBoxE :: !Text -> !BlackBoxTemplate -> !BlackBoxContext -> !Bool -> Expr

-- | Literals used in an expression
data Literal

-- | Number literal
NumLit :: !Integer -> Literal

-- | Bit literal
BitLit :: !Bit -> Literal

-- | Boolean literal
BoolLit :: !Bool -> Literal

-- | Vector literal
VecLit :: [Literal] -> Literal

-- | String literal
StringLit :: !String -> Literal

-- | Bit literal
data Bit

-- | High
H :: Bit

-- | Low
L :: Bit

-- | Undefined
U :: Bit

-- | High-impedance
Z :: Bit

-- | Context used to fill in the holes of a BlackBox template
data BlackBoxContext
Context :: (SyncExpr, HWType) -> [(SyncExpr, HWType, Bool)] -> IntMap (Either BlackBoxTemplate Declaration, BlackBoxContext) -> BlackBoxContext

-- | Result name and type
[bbResult] :: BlackBoxContext -> (SyncExpr, HWType)

-- | Argument names, types, and whether it is a literal
[bbInputs] :: BlackBoxContext -> [(SyncExpr, HWType, Bool)]

-- | Function arguments (subset of inputs):
--   
--   <ul>
--   <li>(Blackbox Template,Partial Blackbox Concext)</li>
--   </ul>
[bbFunctions] :: BlackBoxContext -> IntMap (Either BlackBoxTemplate Declaration, BlackBoxContext)
emptyBBContext :: BlackBoxContext

-- | Either the name of the identifier, or a tuple of the identifier and
--   the corresponding clock
type SyncIdentifier = Either Identifier (Identifier, (Identifier, Int))
type SyncExpr = Either Expr (Expr, (Identifier, Integer))
varEnv :: Lens' NetlistState Gamma
varCount :: Lens' NetlistState Int
typeTranslator :: Lens' NetlistState (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType))
tcCache :: Lens' NetlistState (HashMap TyConName TyCon)
seenIds :: Lens' NetlistState [Identifier]
seenComps :: Lens' NetlistState [Identifier]
primitives :: Lens' NetlistState (PrimMap BlackBoxTemplate)
mkBasicIdFn :: Lens' NetlistState (Identifier -> Identifier)
intWidth :: Lens' NetlistState Int
dataFiles :: Lens' NetlistState [(String, FilePath)]
curCompNm :: Lens' NetlistState (Identifier, SrcSpan)
components :: Lens' NetlistState (HashMap TmName (SrcSpan, Component))
componentNames :: Lens' NetlistState (HashMap TmName Identifier)
bindings :: Lens' NetlistState (HashMap TmName (Type, SrcSpan, Term))
instance Control.Monad.IO.Class.MonadIO CLaSH.Netlist.Types.NetlistMonad
instance Unbound.Generics.LocallyNameless.Fresh.Fresh CLaSH.Netlist.Types.NetlistMonad
instance Control.Monad.State.Class.MonadState CLaSH.Netlist.Types.NetlistState CLaSH.Netlist.Types.NetlistMonad
instance Control.Monad.Writer.Class.MonadWriter (Data.Set.Base.Set (CLaSH.Netlist.Types.Identifier, CLaSH.Netlist.Types.HWType)) CLaSH.Netlist.Types.NetlistMonad
instance GHC.Base.Applicative CLaSH.Netlist.Types.NetlistMonad
instance GHC.Base.Monad CLaSH.Netlist.Types.NetlistMonad
instance GHC.Base.Functor CLaSH.Netlist.Types.NetlistMonad
instance GHC.Show.Show CLaSH.Netlist.Types.Component
instance GHC.Show.Show CLaSH.Netlist.Types.Declaration
instance GHC.Show.Show CLaSH.Netlist.Types.BlackBoxContext
instance GHC.Show.Show CLaSH.Netlist.Types.Expr
instance GHC.Show.Show CLaSH.Netlist.Types.Literal
instance GHC.Classes.Eq CLaSH.Netlist.Types.Literal
instance GHC.Show.Show CLaSH.Netlist.Types.Bit
instance GHC.Classes.Eq CLaSH.Netlist.Types.Bit
instance GHC.Show.Show CLaSH.Netlist.Types.Modifier
instance GHC.Show.Show CLaSH.Netlist.Types.PortDirection
instance GHC.Generics.Generic CLaSH.Netlist.Types.HWType
instance GHC.Show.Show CLaSH.Netlist.Types.HWType
instance GHC.Classes.Ord CLaSH.Netlist.Types.HWType
instance GHC.Classes.Eq CLaSH.Netlist.Types.HWType
instance Control.DeepSeq.NFData CLaSH.Netlist.Types.Component
instance Data.Hashable.Class.Hashable CLaSH.Netlist.Types.HWType
instance Control.DeepSeq.NFData CLaSH.Netlist.Types.HWType
instance Control.DeepSeq.NFData CLaSH.Netlist.Types.Declaration


-- | Type and instance definitions for Rewrite modules
module CLaSH.Rewrite.Types

-- | Context in which a term appears
data CoreContext

-- | Function position of an application
AppFun :: CoreContext

-- | Argument position of an application
AppArg :: CoreContext

-- | Function position of a type application
TyAppC :: CoreContext

-- | RHS of a Let-binder with the sibling LHS'
LetBinding :: Id -> [Id] -> CoreContext

-- | Body of a Let-binding with the bound LHS'
LetBody :: [Id] -> CoreContext

-- | Body of a lambda-term with the abstracted variable
LamBody :: Id -> CoreContext

-- | Body of a TyLambda-term with the abstracted type-variable
TyLamBody :: TyVar -> CoreContext

-- | RHS of a case-alternative with the variables bound by the pattern on
--   the LHS
CaseAlt :: [Id] -> CoreContext

-- | Subject of a case-decomposition
CaseScrut :: CoreContext

-- | State of a rewriting session
data RewriteState extra
RewriteState :: {-# UNPACK #-} !Int -> !(HashMap TmName (Type, SrcSpan, Term)) -> !Supply -> (TmName, SrcSpan) -> {-# UNPACK #-} !Int -> !extra -> RewriteState extra

-- | Number of applied transformations
[_transformCounter] :: RewriteState extra -> {-# UNPACK #-} !Int

-- | Global binders
[_bindings] :: RewriteState extra -> !(HashMap TmName (Type, SrcSpan, Term))

-- | Supply of unique numbers
[_uniqSupply] :: RewriteState extra -> !Supply

-- | Function which is currently normalized
[_curFun] :: RewriteState extra -> (TmName, SrcSpan)

-- | Used for <a>Fresh</a>
[_nameCounter] :: RewriteState extra -> {-# UNPACK #-} !Int

-- | Additional state
[_extra] :: RewriteState extra -> !extra
uniqSupply :: forall extra_a1K16. Lens' (RewriteState extra_a1K16) Supply
transformCounter :: forall extra_a1K16. Lens' (RewriteState extra_a1K16) Int
nameCounter :: forall extra_a1K16. Lens' (RewriteState extra_a1K16) Int
extra :: forall extra_a1K16 extra_a1K54. Lens (RewriteState extra_a1K16) (RewriteState extra_a1K54) extra_a1K16 extra_a1K54
curFun :: forall extra_a1K16. Lens' (RewriteState extra_a1K16) (TmName, SrcSpan)
bindings :: forall extra_a1K16. Lens' (RewriteState extra_a1K16) (HashMap TmName (Type, SrcSpan, Term))

-- | Debug Message Verbosity
data DebugLevel

-- | Don't show debug messages
DebugNone :: DebugLevel

-- | Show completely normalized expressions
DebugFinal :: DebugLevel

-- | Names of applied transformations
DebugName :: DebugLevel

-- | Show sub-expressions after a successful rewrite
DebugApplied :: DebugLevel

-- | Show all sub-expressions on which a rewrite is attempted
DebugAll :: DebugLevel

-- | Read-only environment of a rewriting session
data RewriteEnv
RewriteEnv :: DebugLevel -> (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)) -> HashMap TyConName TyCon -> IntMap TyConName -> (HashMap TyConName TyCon -> Bool -> Term -> Term) -> RewriteEnv

-- | Lvl at which we print debugging messages
[_dbgLevel] :: RewriteEnv -> DebugLevel

-- | Hardcode Type -&gt; HWType translator
[_typeTranslator] :: RewriteEnv -> HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)

-- | TyCon cache
[_tcCache] :: RewriteEnv -> HashMap TyConName TyCon

-- | Tuple TyCon cache
[_tupleTcCache] :: RewriteEnv -> IntMap TyConName

-- | Hardcoded evaluator (delta-reduction)}
[_evaluator] :: RewriteEnv -> HashMap TyConName TyCon -> Bool -> Term -> Term
typeTranslator :: Lens' RewriteEnv (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType))
tupleTcCache :: Lens' RewriteEnv (IntMap TyConName)
tcCache :: Lens' RewriteEnv (HashMap TyConName TyCon)
evaluator :: Lens' RewriteEnv (HashMap TyConName TyCon -> Bool -> Term -> Term)
dbgLevel :: Lens' RewriteEnv DebugLevel

-- | Monad that keeps track how many transformations have been applied and
--   can generate fresh variables and unique identifiers. In addition, it
--   keeps track if a transformation/rewrite has been successfully applied.
newtype RewriteMonad extra a
R :: (RewriteEnv -> RewriteState extra -> (a, RewriteState extra, Any)) -> RewriteMonad extra a
[runR] :: RewriteMonad extra a -> RewriteEnv -> RewriteState extra -> (a, RewriteState extra, Any)

-- | Monadic action that transforms a term given a certain context
type Transform m = [CoreContext] -> Term -> m Term

-- | A <a>Transform</a> action in the context of the <a>RewriteMonad</a>
type Rewrite extra = Transform (RewriteMonad extra)
instance GHC.Base.Functor (CLaSH.Rewrite.Types.RewriteMonad extra)
instance GHC.Base.Applicative (CLaSH.Rewrite.Types.RewriteMonad extra)
instance GHC.Base.Monad (CLaSH.Rewrite.Types.RewriteMonad extra)
instance Control.Monad.State.Class.MonadState (CLaSH.Rewrite.Types.RewriteState extra) (CLaSH.Rewrite.Types.RewriteMonad extra)
instance Unbound.Generics.LocallyNameless.Fresh.Fresh (CLaSH.Rewrite.Types.RewriteMonad extra)
instance CLaSH.Util.MonadUnique (CLaSH.Rewrite.Types.RewriteMonad extra)
instance Control.Monad.Writer.Class.MonadWriter Data.Monoid.Any (CLaSH.Rewrite.Types.RewriteMonad extra)
instance Control.Monad.Reader.Class.MonadReader CLaSH.Rewrite.Types.RewriteEnv (CLaSH.Rewrite.Types.RewriteMonad extra)
instance Control.Monad.Fix.MonadFix (CLaSH.Rewrite.Types.RewriteMonad extra)
instance GHC.Read.Read CLaSH.Rewrite.Types.DebugLevel
instance GHC.Classes.Ord CLaSH.Rewrite.Types.DebugLevel
instance GHC.Classes.Eq CLaSH.Rewrite.Types.DebugLevel
instance GHC.Show.Show CLaSH.Rewrite.Types.CoreContext
instance GHC.Classes.Eq CLaSH.Rewrite.Types.CoreContext


-- | Type definitions used by the Driver module
module CLaSH.Driver.Types

-- | Global function binders
type BindingMap = HashMap TmName (Type, SrcSpan, Term)
data CLaSHOpts
CLaSHOpts :: Int -> Int -> Int -> DebugLevel -> Bool -> Int -> Maybe String -> HdlSyn -> Bool -> CLaSHOpts
[opt_inlineLimit] :: CLaSHOpts -> Int
[opt_specLimit] :: CLaSHOpts -> Int
[opt_inlineBelow] :: CLaSHOpts -> Int
[opt_dbgLevel] :: CLaSHOpts -> DebugLevel
[opt_cleanhdl] :: CLaSHOpts -> Bool
[opt_intWidth] :: CLaSHOpts -> Int
[opt_hdlDir] :: CLaSHOpts -> Maybe String
[opt_hdlSyn] :: CLaSHOpts -> HdlSyn
[opt_errorExtra] :: CLaSHOpts -> Bool
data CLaSHException
CLaSHException :: SrcSpan -> String -> (Maybe String) -> CLaSHException

-- | A <a>SrcSpan</a> identifies either a specific portion of a text file
--   or a human-readable description of a location.
data SrcSpan :: *

-- | Built-in "bad" <a>SrcSpan</a>s for common sources of location
--   uncertainty
noSrcSpan :: SrcSpan
instance GHC.Show.Show CLaSH.Driver.Types.CLaSHException
instance GHC.Exception.Exception CLaSH.Driver.Types.CLaSHException


-- | Types used in Normalize modules
module CLaSH.Normalize.Types

-- | State of the <a>NormalizeMonad</a>
data NormalizeState
NormalizeState :: HashMap TmName (Type, SrcSpan, Term) -> Map (TmName, Int, Either Term Type) (TmName, Type) -> HashMap TmName Int -> !Int -> HashMap TmName (HashMap TmName Int) -> !Int -> !Int -> PrimMap BlackBoxTemplate -> HashMap TmName Bool -> NormalizeState

-- | Global binders
[_normalized] :: NormalizeState -> HashMap TmName (Type, SrcSpan, Term)

-- | Cache of previously specialised functions:
--   
--   <ul>
--   <li>Key: (name of the original function, argument position,
--   specialised term/type)</li>
--   <li>Elem: (name of specialised function,type of specialised
--   function)</li>
--   </ul>
[_specialisationCache] :: NormalizeState -> Map (TmName, Int, Either Term Type) (TmName, Type)

-- | Cache of how many times a function was specialized
[_specialisationHistory] :: NormalizeState -> HashMap TmName Int

-- | Number of time a function <tt>f</tt> can be specialized
[_specialisationLimit] :: NormalizeState -> !Int

-- | Cache of function where inlining took place:
--   
--   <ul>
--   <li>Key: function where inlining took place</li>
--   <li>Elem: (functions which were inlined, number of times inlined)</li>
--   </ul>
[_inlineHistory] :: NormalizeState -> HashMap TmName (HashMap TmName Int)

-- | Number of times a function <tt>f</tt> can be inlined in a function
--   <tt>g</tt>
[_inlineLimit] :: NormalizeState -> !Int

-- | Size of a function below which it is always inlined if it is not
--   recursive
[_inlineBelow] :: NormalizeState -> !Int

-- | Primitive Definitions
[_primitives] :: NormalizeState -> PrimMap BlackBoxTemplate

-- | Map telling whether a components is part of a recursive group
[_recursiveComponents] :: NormalizeState -> HashMap TmName Bool
specialisationLimit :: Lens' NormalizeState Int
specialisationHistory :: Lens' NormalizeState (HashMap TmName Int)
specialisationCache :: Lens' NormalizeState (Map (TmName, Int, Either Term Type) (TmName, Type))
recursiveComponents :: Lens' NormalizeState (HashMap TmName Bool)
primitives :: Lens' NormalizeState (PrimMap BlackBoxTemplate)
normalized :: Lens' NormalizeState (HashMap TmName (Type, SrcSpan, Term))
inlineLimit :: Lens' NormalizeState Int
inlineHistory :: Lens' NormalizeState (HashMap TmName (HashMap TmName Int))
inlineBelow :: Lens' NormalizeState Int

-- | State monad that stores specialisation and inlining information
type NormalizeMonad = State NormalizeState

-- | RewriteSession with extra Normalisation information
type NormalizeSession = RewriteMonad NormalizeState

-- | A <tt>Transform</tt> action in the context of the <a>RewriteMonad</a>
--   and <a>NormalizeMonad</a>
type NormRewrite = Rewrite NormalizeState


-- | Rewriting combinators and traversals
module CLaSH.Rewrite.Combinators

-- | Apply a transformation on the subtrees of an term
allR :: forall m. (Functor m, Monad m, Fresh m) => Bool -> Transform m -> Transform m

-- | Apply two transformations in succession
(>->) :: (Monad m) => Transform m -> Transform m -> Transform m
infixr 6 >->

-- | Apply two transformations in succession, and perform a deepseq in
--   between.
(>-!->) :: (Monad m) => Transform m -> Transform m -> Transform m
infixr 6 >-!->

-- | Apply a transformation in a topdown traversal
topdownR :: (Fresh m, Functor m, Monad m) => Transform m -> Transform m

-- | Apply a transformation in a topdown traversal. Doesn't freshen bound
--   variables
unsafeTopdownR :: (Fresh m, Functor m, Monad m) => Transform m -> Transform m

-- | Apply a transformation in a bottomup traversal
bottomupR :: (Fresh m, Functor m, Monad m) => Transform m -> Transform m

-- | Apply a transformation in a bottomup traversal. Doesn't freshen bound
--   variables
unsafeBottomupR :: (Fresh m, Functor m, Monad m) => Transform m -> Transform m

-- | Only apply the second transformation if the first one succeeds.
(!->) :: Rewrite m -> Rewrite m -> Rewrite m
infixr 5 !->

-- | Only apply the second transformation if the first one fails.
(>-!) :: Rewrite m -> Rewrite m -> Rewrite m
infixr 5 >-!

-- | Keep applying a transformation until it fails.
repeatR :: Rewrite m -> Rewrite m
whenR :: Monad m => ([CoreContext] -> Term -> m Bool) -> Transform m -> Transform m

-- | Only traverse downwards when the assertion evaluates to true
bottomupWhenR :: (Monad m, Fresh m, Functor m) => ([CoreContext] -> Term -> m Bool) -> Transform m -> Transform m


-- | Utilities for converting Core Type/Term to Netlist datatypes
module CLaSH.Netlist.Util
mkBasicId :: Identifier -> NetlistMonad Identifier

-- | Split a normalized term into: a list of arguments, a list of
--   let-bindings, and a variable reference that is the body of the
--   let-binding. Returns a String containing the error is the term was not
--   in a normalized form.
splitNormalized :: (Fresh m, Functor m) => HashMap TyConName TyCon -> Term -> m (Either String ([Id], [LetBinding], Id))

-- | Converts a Core type to a HWType given a function that translates
--   certain builtin types. Errors if the Core type is not translatable.
unsafeCoreTypeToHWType :: String -> (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)) -> HashMap TyConName TyCon -> Type -> HWType

-- | Converts a Core type to a HWType within the NetlistMonad; errors on
--   failure
unsafeCoreTypeToHWTypeM :: String -> Type -> NetlistMonad HWType

-- | Converts a Core type to a HWType within the NetlistMonad;
--   <a>Nothing</a> on failure
coreTypeToHWTypeM :: Type -> NetlistMonad (Maybe HWType)

-- | Returns the name and period of the clock corresponding to a type
synchronizedClk :: HashMap TyConName TyCon -> Type -> Maybe (Identifier, Integer)

-- | Converts a Core type to a HWType given a function that translates
--   certain builtin types. Returns a string containing the error message
--   when the Core type is not translatable.
coreTypeToHWType :: (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)) -> HashMap TyConName TyCon -> Type -> Either String HWType

-- | Converts an algebraic Core type (split into a TyCon and its argument)
--   to a HWType.
mkADT :: (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)) -> HashMap TyConName TyCon -> String -> TyConName -> [Type] -> Either String HWType

-- | Simple check if a TyCon is recursively defined.
isRecursiveTy :: HashMap TyConName TyCon -> TyConName -> Bool

-- | Determines if a Core type is translatable to a HWType given a function
--   that translates certain builtin types.
representableType :: (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)) -> HashMap TyConName TyCon -> Type -> Bool

-- | Determines the bitsize of a type
typeSize :: HWType -> Int

-- | Determines the bitsize of the constructor of a type
conSize :: HWType -> Int

-- | Gives the length of length-indexed types
typeLength :: HWType -> Int

-- | Gives the HWType corresponding to a term. Returns an error if the term
--   has a Core type that is not translatable to a HWType.
termHWType :: String -> Term -> NetlistMonad HWType

-- | Gives the HWType corresponding to a term. Returns <a>Nothing</a> if
--   the term has a Core type that is not translatable to a HWType.
termHWTypeM :: Term -> NetlistMonad (Maybe HWType)

-- | Uniquely rename all the variables and their references in a normalized
--   term
mkUniqueNormalized :: ([Id], [LetBinding], Id) -> NetlistMonad ([Id], [LetBinding], TmName)

-- | Make a set of IDs unique; also returns a substitution from old ID to
--   new updated unique ID.
mkUnique :: [(Id, Id)] -> [Id] -> NetlistMonad ([Id], [(Id, Id)])
mkUniqueIdentifier :: Identifier -> NetlistMonad Identifier

-- | Append a string to a name
appendToName :: TmName -> String -> TmName

-- | Preserve the Netlist <a>_varEnv</a> and <a>_varCount</a> when
--   executing a monadic action
preserveVarEnv :: NetlistMonad a -> NetlistMonad a
dcToLiteral :: HWType -> Int -> Literal


-- | Utilities for rewriting: e.g. inlining, specialisation, etc.
module CLaSH.Rewrite.Util

-- | Lift an action working in the <a>_extra</a> state to the
--   <a>RewriteMonad</a>
zoomExtra :: State extra a -> RewriteMonad extra a

-- | Record if a transformation is succesfully applied
apply :: String -> Rewrite extra -> Rewrite extra

-- | Perform a transformation on a Term
runRewrite :: String -> Rewrite extra -> Term -> RewriteMonad extra Term

-- | Evaluate a RewriteSession to its inner monad
runRewriteSession :: RewriteEnv -> RewriteState extra -> RewriteMonad extra a -> a

-- | Notify that a transformation has changed the expression
setChanged :: RewriteMonad extra ()

-- | Identity function that additionally notifies that a transformation has
--   changed the expression
changed :: a -> RewriteMonad extra a

-- | Create a type and kind context out of a transformation context
contextEnv :: [CoreContext] -> (Gamma, Delta)
closestLetBinder :: [CoreContext] -> Maybe Id
mkDerivedName :: [CoreContext] -> String -> String

-- | Create a complete type and kind context out of the global binders and
--   the transformation context
mkEnv :: [CoreContext] -> RewriteMonad extra (Gamma, Delta)

-- | Make a new binder and variable reference for a term
mkTmBinderFor :: (Functor m, Fresh m, MonadUnique m) => HashMap TyConName TyCon -> String -> Term -> m (Id, Term)

-- | Make a new binder and variable reference for either a term or a type
mkBinderFor :: (Functor m, Monad m, MonadUnique m, Fresh m) => HashMap TyConName TyCon -> String -> Either Term Type -> m (Either (Id, Term) (TyVar, Type))

-- | Make a new, unique, identifier and corresponding variable reference
mkInternalVar :: (Functor m, Monad m, MonadUnique m) => String -> KindOrType -> m (Id, Term)

-- | Inline the binders in a let-binding that have a certain property
inlineBinders :: (Term -> LetBinding -> RewriteMonad extra Bool) -> Rewrite extra

-- | Determine whether a binder is a join-point created for a complex case
--   expression.
--   
--   A join-point is when a local function only occurs in tail-call
--   positions, and when it does, more than once.
isJoinPointIn :: Id -> Term -> Bool

-- | Count the number of (only) tail calls of a function in an expression.
--   <a>Nothing</a> indicates that the function was used in a non-tail call
--   position.
tailCalls :: Id -> Term -> Maybe Int

-- | Substitute the RHS of the first set of Let-binders for references to
--   the first set of Let-binders in: the second set of Let-binders and the
--   additional term
substituteBinders :: [LetBinding] -> [LetBinding] -> Term -> ([LetBinding], Term)

-- | Calculate the <i>local</i> free variable of an expression: the free
--   variables that are not bound in the global environment.
localFreeIds :: (Applicative f, Contravariant f) => RewriteMonad extra ((TmName -> f TmName) -> Term -> f Term)
inlineOrLiftBinders :: (LetBinding -> RewriteMonad extra Bool) -> (Term -> LetBinding -> RewriteMonad extra Bool) -> Rewrite extra

-- | Create a global function for a Let-binding and return a Let-binding
--   where the RHS is a reference to the new global function applied to the
--   free variables of the original RHS
liftBinding :: Gamma -> Delta -> LetBinding -> RewriteMonad extra LetBinding

-- | Make a global function for a name-term tuple
mkFunction :: TmName -> SrcSpan -> Term -> RewriteMonad extra (TmName, Type)

-- | Add a function to the set of global binders
addGlobalBind :: TmName -> Type -> SrcSpan -> Term -> RewriteMonad extra ()

-- | Create a new name out of the given name, but with another unique
cloneVar :: TmName -> RewriteMonad extra TmName

-- | Test whether a term is a variable reference to a local binder
isLocalVar :: Term -> RewriteMonad extra Bool

-- | Determine if a term cannot be represented in hardware
isUntranslatable :: Term -> RewriteMonad extra Bool

-- | Determine if a type cannot be represented in hardware
isUntranslatableType :: Type -> RewriteMonad extra Bool

-- | Is the Context a Lambda/Term-abstraction context?
isLambdaBodyCtx :: CoreContext -> Bool

-- | Make a binder that should not be referenced
mkWildValBinder :: (Functor m, Monad m, MonadUnique m) => Type -> m Id

-- | Make a case-decomposition that extracts a field out of a
--   (Sum-of-)Product type
mkSelectorCase :: (Functor m, Monad m, MonadUnique m, Fresh m) => String -> HashMap TyConName TyCon -> Term -> Int -> Int -> m Term

-- | Specialise an application on its argument
specialise :: Lens' extra (Map (TmName, Int, Either Term Type) (TmName, Type)) -> Lens' extra (HashMap TmName Int) -> Lens' extra Int -> Rewrite extra

-- | Specialise an application on its argument
specialise' :: Lens' extra (Map (TmName, Int, Either Term Type) (TmName, Type)) -> Lens' extra (HashMap TmName Int) -> Lens' extra Int -> [CoreContext] -> Term -> (Term, [Either Term Type]) -> Either Term Type -> RewriteMonad extra Term

-- | Create binders and variable references for free variables in
--   <tt>specArg</tt>
specArgBndrsAndVars :: [CoreContext] -> Either Term Type -> RewriteMonad extra ([Either Id TyVar], [Either Term Type])


-- | Utility functions used by the normalisation transformations
module CLaSH.Normalize.Util

-- | Determine if a function is already inlined in the context of the
--   <tt>NetlistMonad</tt>
alreadyInlined :: TmName -> TmName -> NormalizeMonad (Maybe Int)
addNewInline :: TmName -> TmName -> NormalizeMonad ()

-- | Specialize under the Normalization Monad
specializeNorm :: NormRewrite

-- | Determine if a term is closed
isClosed :: (Functor m, Fresh m) => HashMap TyConName TyCon -> Term -> m Bool

-- | Determine if a term represents a constant
isConstant :: Term -> Bool
isRecursiveBndr :: TmName -> NormalizeSession Bool

-- | Create a call graph for a set of global binders, given a root
callGraph :: [TmName] -> HashMap TmName (Type, SrcSpan, Term) -> TmName -> [(TmName, [TmName])]

-- | Determine the sets of recursive components given the edges of a
--   callgraph
mkRecursiveComponents :: [(TmName, [TmName])] -> [[TmName]]
lambdaDropPrep :: HashMap TmName (Type, SrcSpan, Term) -> TmName -> HashMap TmName (Type, SrcSpan, Term)
lambdaDrop :: HashMap TmName (Type, SrcSpan, Term) -> HashMap TmName [TmName] -> [TmName] -> (TmName, (Type, SrcSpan, Term))
dominator :: HashMap TmName [TmName] -> [TmName] -> Gr TmName TmName
blockSink :: HashMap TmName (Type, SrcSpan, Term) -> Gr TmName TmName -> LNode TmName -> (TmName, (Type, SrcSpan, Term))


-- | Helper functions for the <tt>disjointExpressionConsolidation</tt>
--   transformation
--   
--   The <tt>disjointExpressionConsolidation</tt> transformation lifts
--   applications of global binders out of alternatives of case-statements.
--   
--   e.g. It converts:
--   
--   <pre>
--   case x of
--     A -&gt; f 3 y
--     B -&gt; f x x
--     C -&gt; h x
--   </pre>
--   
--   into:
--   
--   <pre>
--   let f_arg0 = case x of {A -&gt; 3; B -&gt; x}
--       f_arg1 = case x of {A -&gt; y; B -&gt; x}
--       f_out  = f f_arg0 f_arg1
--   in  case x of
--         A -&gt; f_out
--         B -&gt; f_out
--         C -&gt; h x
--   </pre>
module CLaSH.Normalize.DEC

-- | Collect <a>CaseTree</a>s for (potentially) disjoint applications of
--   globals out of an expression. Also substitute truly disjoint
--   applications of globals by a reference to a lifted out application.
collectGlobals :: Set TmName -> [(Term, Term)] -> [Term] -> Term -> RewriteMonad NormalizeState (Term, [(Term, ([Term], CaseTree [(Either Term Type)]))])

-- | Test if a <a>CaseTree</a> collected from an expression indicates that
--   application of a global binder is disjoint: occur in separate branches
--   of a case-expression.
isDisjoint :: CaseTree ([Either Term Type]) -> Bool

-- | Given a case-tree corresponding to a disjoint interesting "term-in-a-
--   function-position", return a let-expression: where the let-binding
--   holds a case-expression selecting between the uncommon arguments of
--   the case-tree, and the body is an application of the term applied to
--   the common arguments of the case tree, and projections of let-binding
--   corresponding to the uncommon argument positions.
mkDisjointGroup :: Set TmName -> (Term, ([Term], CaseTree [(Either Term Type)])) -> RewriteMonad NormalizeState (Term, [Term])
instance Data.Foldable.Foldable CLaSH.Normalize.DEC.CaseTree
instance GHC.Base.Functor CLaSH.Normalize.DEC.CaseTree
instance GHC.Show.Show a => GHC.Show.Show (CLaSH.Normalize.DEC.CaseTree a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (CLaSH.Normalize.DEC.CaseTree a)


-- | Reductions of primitives
--   
--   Currently, it contains reductions for:
--   
--   <ul>
--   <li>CLaSH.Sized.Vector.map</li>
--   <li>CLaSH.Sized.Vector.zipWith</li>
--   <li>CLaSH.Sized.Vector.traverse#</li>
--   <li>CLaSH.Sized.Vector.foldr</li>
--   <li>CLaSH.Sized.Vector.fold</li>
--   <li>CLaSH.Sized.Vector.dfold</li>
--   <li>CLaSH.Sized.Vector.(++)</li>
--   <li>CLaSH.Sized.Vector.head</li>
--   <li>CLaSH.Sized.Vector.tail</li>
--   <li>CLaSH.Sized.Vector.unconcatBitVector#</li>
--   <li>CLaSH.Sized.Vector.replicate</li>
--   <li>CLaSH.Sized.Vector.imap</li>
--   </ul>
--   
--   Partially handles:
--   
--   <ul>
--   <li>CLaSH.Sized.Vector.unconcat</li>
--   <li>CLaSH.Sized.Vector.transpose</li>
--   </ul>
module CLaSH.Normalize.PrimitiveReductions

-- | Replace an application of the <tt>CLaSH.Sized.Vector.zipWith</tt>
--   primitive on vectors of a known length <tt>n</tt>, by the fully
--   unrolled recursive "definition" of <tt>CLaSH.Sized.Vector.zipWith</tt>
reduceZipWith :: Integer -> Type -> Type -> Type -> Term -> Term -> Term -> NormalizeSession Term

-- | Replace an application of the <tt>CLaSH.Sized.Vector.map</tt>
--   primitive on vectors of a known length <tt>n</tt>, by the fully
--   unrolled recursive "definition" of <tt>CLaSH.Sized.Vector.map</tt>
reduceMap :: Integer -> Type -> Type -> Term -> Term -> NormalizeSession Term

-- | Replace an application of the <tt>CLaSH.Sized.Vector.imap</tt>
--   primitive on vectors of a known length <tt>n</tt>, by the fully
--   unrolled recursive "definition" of <tt>CLaSH.Sized.Vector.imap</tt>
reduceImap :: Integer -> Type -> Type -> Term -> Term -> NormalizeSession Term

-- | Replace an application of the <tt>CLaSH.Sized.Vector.traverse#</tt>
--   primitive on vectors of a known length <tt>n</tt>, by the fully
--   unrolled recursive "definition" of
--   <tt>CLaSH.Sized.Vector.traverse#</tt>
reduceTraverse :: Integer -> Type -> Type -> Type -> Term -> Term -> Term -> NormalizeSession Term

-- | Create the traversable vector
--   
--   e.g. for a length '2' input vector, we get
--   
--   <pre>
--   (:&gt;) &lt;$&gt; x0 &lt;*&gt; ((:&gt;) &lt;$&gt; x1 &lt;*&gt; pure Nil)
--   </pre>
mkTravVec :: TyConName -> DataCon -> DataCon -> Term -> Term -> Term -> Type -> Integer -> [Term] -> Term

-- | Replace an application of the <tt>CLaSH.Sized.Vector.foldr</tt>
--   primitive on vectors of a known length <tt>n</tt>, by the fully
--   unrolled recursive "definition" of <tt>CLaSH.Sized.Vector.foldr</tt>
reduceFoldr :: Integer -> Type -> Term -> Term -> Term -> NormalizeSession Term

-- | Replace an application of the <tt>CLaSH.Sized.Vector.fold</tt>
--   primitive on vectors of a known length <tt>n</tt>, by the fully
--   unrolled recursive "definition" of <tt>CLaSH.Sized.Vector.fold</tt>
reduceFold :: Integer -> Type -> Term -> Term -> NormalizeSession Term

-- | Replace an application of the <tt>CLaSH.Sized.Vector.dfold</tt>
--   primitive on vectors of a known length <tt>n</tt>, by the fully
--   unrolled recursive "definition" of <tt>CLaSH.Sized.Vector.dfold</tt>
reduceDFold :: Integer -> Type -> Term -> Term -> Term -> NormalizeSession Term

-- | Replace an application of the <tt>CLaSH.Sized.Vector.head</tt>
--   primitive on vectors of a known length <tt>n</tt>, by a projection of
--   the first element of a vector.
reduceHead :: Integer -> Type -> Term -> NormalizeSession Term

-- | Replace an application of the <tt>CLaSH.Sized.Vector.tail</tt>
--   primitive on vectors of a known length <tt>n</tt>, by a projection of
--   the tail of a vector.
reduceTail :: Integer -> Type -> Term -> NormalizeSession Term

-- | Replace an application of the <tt>CLaSH.Sized.Vector.(++)</tt>
--   primitive on vectors of a known length <tt>n</tt>, by the fully
--   unrolled recursive "definition" of <tt>CLaSH.Sized.Vector.(++)</tt>
reduceAppend :: Integer -> Integer -> Type -> Term -> Term -> NormalizeSession Term

-- | Replace an application of the <tt>CLaSH.Sized.Vector.unconcat</tt>
--   primitive on vectors of a known length <tt>n</tt>, by the fully
--   unrolled recursive "definition" of
--   <tt>CLaSH.Sized.Vector.unconcat</tt>
reduceUnconcat :: Integer -> Integer -> Type -> Term -> NormalizeSession Term

-- | Replace an application of the <tt>CLaSH.Sized.Vector.transpose</tt>
--   primitive on vectors of a known length <tt>n</tt>, by the fully
--   unrolled recursive "definition" of
--   <tt>CLaSH.Sized.Vector.transpose</tt>
reduceTranspose :: Integer -> Integer -> Type -> Term -> NormalizeSession Term
reduceReplicate :: Integer -> Type -> Type -> Term -> NormalizeSession Term


module CLaSH.Backend
type ModName = String
class Backend state

-- | Initial state for state monad
initBackend :: Backend state => Int -> HdlSyn -> state

-- | Location for the primitive definitions
primDir :: Backend state => state -> IO FilePath

-- | Name of backend, used for directory to put output files in. Should be
--   | constant function / ignore argument.
name :: Backend state => state -> String

-- | File extension for target langauge
extension :: Backend state => state -> String

-- | Get the set of types out of state
extractTypes :: Backend state => state -> HashSet HWType

-- | Generate HDL for a Netlist component
genHDL :: Backend state => String -> SrcSpan -> Component -> State state (String, Doc)

-- | Generate a HDL package containing type definitions for the given
--   HWTypes
mkTyPackage :: Backend state => String -> [HWType] -> State state [(String, Doc)]

-- | Convert a Netlist HWType to a target HDL type
hdlType :: Backend state => HWType -> State state Doc

-- | Convert a Netlist HWType to an HDL error value for that type
hdlTypeErrValue :: Backend state => HWType -> State state Doc

-- | Convert a Netlist HWType to the root of a target HDL type
hdlTypeMark :: Backend state => HWType -> State state Doc

-- | Create a signal declaration from an identifier (Text) and Netlist
--   HWType
hdlSig :: Backend state => Text -> HWType -> State state Doc

-- | Create a generative block statement marker
genStmt :: Backend state => Bool -> State state Doc

-- | Turn a Netlist Declaration to a HDL concurrent block
inst :: Backend state => Declaration -> State state (Maybe Doc)

-- | Turn a Netlist expression into a HDL expression
expr :: Backend state => Bool -> Expr -> State state Doc

-- | Bit-width of Int<i>Word</i>Integer
iwWidth :: Backend state => State state Int

-- | Convert to a bit-vector
toBV :: Backend state => HWType -> Text -> State state Doc

-- | Convert from a bit-vector
fromBV :: Backend state => HWType -> Text -> State state Doc

-- | Synthesis tool we're generating HDL for
hdlSyn :: Backend state => State state HdlSyn

-- | mkBasicId
mkBasicId :: Backend state => State state (Identifier -> Identifier)

-- | setModName
setModName :: Backend state => ModName -> state -> state

-- | setSrcSpan
setSrcSpan :: Backend state => SrcSpan -> State state ()

-- | getSrcSpan
getSrcSpan :: Backend state => State state SrcSpan


-- | Utilties to verify blackbox contexts against templates and rendering
--   filled in templates
module CLaSH.Netlist.BlackBox.Util

-- | Determine if the number of normal<i>literal</i>function inputs of a
--   blackbox context at least matches the number of argument that is
--   expected by the template.
verifyBlackBoxContext :: BlackBoxContext -> BlackBoxTemplate -> Bool
extractLiterals :: BlackBoxContext -> [Expr]

-- | Update all the symbol references in a template, and increment the
--   symbol counter for every newly encountered symbol.
setSym :: BlackBoxTemplate -> NetlistMonad BlackBoxTemplate
setCompName :: Identifier -> BlackBoxTemplate -> BlackBoxTemplate
setClocks :: (MonadWriter (Set (Identifier, HWType)) m, Applicative m) => BlackBoxContext -> BlackBoxTemplate -> m BlackBoxTemplate
findAndSetDataFiles :: BlackBoxContext -> [(String, FilePath)] -> BlackBoxTemplate -> ([(String, FilePath)], BlackBoxTemplate)
renderFilePath :: [(String, FilePath)] -> String -> ([(String, FilePath)], Element)

-- | Get the name of the clock of an identifier
clkSyncId :: SyncExpr -> (Identifier, Integer)

-- | Render a blackbox given a certain context. Returns a filled out
--   template and a list of <tt>hidden</tt> inputs that must be added to
--   the encompassing component.
renderBlackBox :: Backend backend => BlackBoxTemplate -> BlackBoxContext -> State backend Text

-- | Render a single template element
renderElem :: Backend backend => BlackBoxContext -> Element -> State backend Text
parseFail :: Text -> BlackBoxTemplate
syncIdToSyncExpr :: (Text, HWType) -> (SyncExpr, HWType, Bool)

-- | Fill out the template corresponding to an output/input assignment of a
--   component instantiation, and turn it into a single identifier so it
--   can be used for a new blackbox context.
lineToIdentifier :: Backend backend => BlackBoxContext -> BlackBoxTemplate -> State backend Text
lineToType :: BlackBoxContext -> BlackBoxTemplate -> HWType

-- | Give a context and a tagged hole (of a template), returns part of the
--   context that matches the tag of the hole.
renderTag :: Backend backend => BlackBoxContext -> Element -> State backend Text
prettyBlackBox :: Monad m => BlackBoxTemplate -> m Text
prettyElem :: Monad m => Element -> m Text
usedArguments :: BlackBoxTemplate -> [Int]


-- | Functions to create BlackBox Contexts and fill in BlackBox templates
module CLaSH.Netlist.BlackBox

-- | Generate the context for a BlackBox instantiation.
mkBlackBoxContext :: Id -> [Term] -> NetlistMonad (BlackBoxContext, [Declaration])
prepareBlackBox :: Text -> BlackBoxTemplate -> BlackBoxContext -> NetlistMonad BlackBoxTemplate
mkArgument :: Identifier -> Term -> NetlistMonad ((SyncExpr, HWType, Bool), [Declaration])
mkPrimitive :: Bool -> Bool -> (Either Identifier Id) -> Text -> [Either Term Type] -> Type -> NetlistMonad (Expr, [Declaration])

-- | Create an template instantiation text and a partial blackbox content
--   for an argument term, given that the term is a function. Errors if the
--   term is not a function
mkFunInput :: Id -> Term -> NetlistMonad ((Either BlackBoxTemplate Declaration, BlackBoxContext), [Declaration])

-- | Instantiate symbols references with a new symbol and increment symbol
--   counter instantiateSym :: BlackBoxTemplate -&gt; NetlistMonad
--   BlackBoxTemplate instantiateSym l = do i &lt;- Lens.use varCount ids
--   &lt;- Lens.use seenIds let (l',(ids',i')) = setSym ids i l varCount .=
--   i' seenIds .= ids' return l'
instantiateCompName :: BlackBoxTemplate -> NetlistMonad BlackBoxTemplate
collectFilePaths :: BlackBoxContext -> BlackBoxTemplate -> NetlistMonad BlackBoxTemplate


-- | Create Netlists out of normalized CoreHW Terms
module CLaSH.Netlist

-- | Generate a hierarchical netlist out of a set of global binders with
--   <tt>topEntity</tt> at the top.
genNetlist :: HashMap TmName (Type, SrcSpan, Term) -> PrimMap BlackBoxTemplate -> HashMap TyConName TyCon -> (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)) -> Maybe Int -> String -> [(String, FilePath)] -> Int -> (Identifier -> Identifier) -> [Identifier] -> TmName -> IO ([(SrcSpan, Component)], [(String, FilePath)], [Identifier])

-- | Run a NetlistMonad action in a given environment
runNetlistMonad :: HashMap TmName (Type, SrcSpan, Term) -> PrimMap BlackBoxTemplate -> HashMap TyConName TyCon -> (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)) -> String -> [(String, FilePath)] -> Int -> (Identifier -> Identifier) -> [Identifier] -> NetlistMonad a -> IO (a, NetlistState)
genNames :: (Identifier -> Identifier) -> String -> [Identifier] -> HashMap TmName Identifier -> [TmName] -> ([Identifier], HashMap TmName Identifier)

-- | Generate a component for a given function (caching)
genComponent :: TmName -> Maybe Int -> NetlistMonad (SrcSpan, Component)

-- | Generate a component for a given function
genComponentT :: TmName -> Term -> Maybe Int -> NetlistMonad (SrcSpan, Component)
genComponentName :: [Identifier] -> (Identifier -> Identifier) -> String -> TmName -> Identifier

-- | Generate a list of Declarations for a let-binder
mkDeclarations :: Id -> Term -> NetlistMonad [Declaration]

-- | Generate a list of Declarations for a let-binder where the RHS is a
--   function application
mkFunApp :: Id -> TmName -> [Term] -> NetlistMonad [Declaration]
toSimpleVar :: Id -> (Expr, Type) -> NetlistMonad (Expr, [Declaration])

-- | Generate an expression for a term occurring on the RHS of a let-binder
mkExpr :: Bool -> (Either Identifier Id) -> Type -> Term -> NetlistMonad (Expr, [Declaration])

-- | Generate an expression for a DataCon application occurring on the RHS
--   of a let-binder
mkDcApplication :: HWType -> (Either Identifier Id) -> DataCon -> [Term] -> NetlistMonad (Expr, [Declaration])


module CLaSH.Driver.TopWrapper

-- | Create a wrapper around a component, potentially initiating clock
--   sources
mkTopWrapper :: PrimMap BlackBoxTemplate -> (Identifier -> Identifier) -> Maybe TopEntity -> String -> Int -> Component -> Component

-- | Create extra input ports for the wrapper
extraIn :: Maybe TopEntity -> [(Identifier, HWType)]

-- | Create extra output ports for the wrapper
extraOut :: Maybe TopEntity -> [(Identifier, HWType)]

-- | Generate input port mappings
mkInput :: [Identifier] -> (Identifier, HWType) -> Int -> ([Identifier], ([(Identifier, HWType)], ([Declaration], Identifier)))

-- | Create a Vector chain for a list of <a>Identifier</a>s
mkVectorChain :: Int -> HWType -> [Identifier] -> Expr

-- | Generate output port mappings
mkOutput :: [Identifier] -> (Identifier, HWType) -> Int -> ([Identifier], ([(Identifier, HWType)], ([Declaration], Identifier)))

-- | Create clock generators
mkClocks :: PrimMap BlackBoxTemplate -> [(Identifier, HWType)] -> Int -> Maybe TopEntity -> [Declaration]
stringToVar :: String -> Expr

-- | Create a single clock generator
mkClock :: ClockSource -> ([Declaration], (Identifier, [String], Bool))
mkClockDecl :: String -> Declaration

-- | Create a single clock path
clockPorts :: [(String, String)] -> [(String, String)] -> ([(Identifier, PortDirection, HWType, Expr)], [String])

-- | Generate resets
mkResets :: PrimMap BlackBoxTemplate -> [(Identifier, HWType)] -> Int -> [(Identifier, [String], Bool)] -> [Declaration]

-- | Generate a reset synchroniser that synchronously de-asserts an
--   asynchronous reset signal
genSyncReset :: PrimMap BlackBoxTemplate -> Identifier -> Identifier -> Text -> Integer -> NetlistMonad [Declaration]

-- | The <tt>NetListMonad</tt> is a transformer stack with <a>IO</a> at the
--   bottom. So we must use <a>unsafePerformIO</a>.
unsafeRunNetlist :: Int -> NetlistMonad a -> a


-- | Transformations of the Normalization process
module CLaSH.Normalize.Transformations

-- | Propagate arguments of application inwards; except for <a>Lam</a>
--   where the argument becomes let-bound.
appProp :: NormRewrite

-- | Lift the let-bindings out of the subject of a Case-decomposition
caseLet :: NormRewrite

-- | Specialize a Case-decomposition (replace by the RHS of an alternative)
--   if the subject is (an application of) a DataCon; or if there is only a
--   single alternative that doesn't reference variables bound by the
--   pattern.
caseCon :: NormRewrite

-- | Move a Case-decomposition from the subject of a Case-decomposition to
--   the alternatives
caseCase :: NormRewrite

-- | Inline function with a non-representable result if it's the subject of
--   a Case-decomposition
inlineNonRep :: NormRewrite
inlineOrLiftNonRep :: NormRewrite

-- | Specialize functions on their type
typeSpec :: NormRewrite

-- | Specialize functions on their non-representable argument
nonRepSpec :: NormRewrite

-- | Eta-expand top-level lambda's (DON'T use in a traversal!)
etaExpansionTL :: NormRewrite

-- | Bring an application of a DataCon or Primitive in ANF, when the
--   argument is is considered non-representable
nonRepANF :: NormRewrite

-- | Inline let-bindings when the RHS is either a local variable reference
--   or is constant
bindConstantVar :: NormRewrite

-- | Specialise functions on arguments which are constant
constantSpec :: NormRewrite

-- | Turn an expression into a modified ANF-form. As opposed to standard
--   ANF, constants do not become let-bound.
makeANF :: NormRewrite

-- | Remove unused let-bindings
deadCode :: NormRewrite

-- | Ensure that top-level lambda's eventually bind a let-expression of
--   which the body is a variable-reference.
topLet :: NormRewrite

-- | Turn a normalized recursive function, where the recursive calls only
--   pass along the unchanged original arguments, into let-recursive
--   function. This means that all recursive calls are replaced by the same
--   variable reference as found in the body of the top-level
--   let-expression.
recToLetRec :: NormRewrite

-- | Inline nullary/closed functions
inlineClosed :: NormRewrite

-- | Inline a function with functional arguments
inlineHO :: NormRewrite

-- | Inline small functions
inlineSmall :: NormRewrite

-- | Simplified CSE, only works on let-bindings, works from top to bottom
simpleCSE :: NormRewrite
reduceConst :: NormRewrite

-- | Replace primitives by their "definition" if they would lead to
--   let-bindings with a non-representable type when a function is in ANF.
--   This happens for example when CLaSH.Size.Vector.map consumes or
--   produces a vector of non-representable elements.
--   
--   Basically what this transformation does is replace a primitive the
--   completely unrolled recursive definition that it represents. e.g.
--   
--   <pre>
--   zipWith ($) (xs :: Vec 2 (Int -&gt; Int)) (ys :: Vec 2 Int)
--   </pre>
--   
--   is replaced by:
--   
--   <pre>
--   let (x0  :: (Int -&gt; Int))       = case xs  of (:&gt;) _ x xr -&gt; x
--       (xr0 :: Vec 1 (Int -&gt; Int)) = case xs  of (:&gt;) _ x xr -&gt; xr
--       (x1  :: (Int -&gt; Int)(       = case xr0 of (:&gt;) _ x xr -&gt; x
--       (y0  :: Int)                = case ys  of (:&gt;) _ y yr -&gt; y
--       (yr0 :: Vec 1 Int)          = case ys  of (:&gt;) _ y yr -&gt; xr
--       (y1  :: Int                 = case yr0 of (:&gt;) _ y yr -&gt; y
--   in  (($) x0 y0 :&gt; ($) x1 y1 :&gt; Nil)
--   </pre>
--   
--   Currently, it only handles the following functions:
--   
--   <ul>
--   <li>CLaSH.Sized.Vector.map</li>
--   <li>CLaSH.Sized.Vector.zipWith</li>
--   <li>CLaSH.Sized.Vector.traverse#</li>
--   <li>CLaSH.Sized.Vector.foldr</li>
--   <li>CLaSH.Sized.Vector.fold</li>
--   <li>CLaSH.Sized.Vector.dfold</li>
--   <li>CLaSH.Sized.Vector.(++)</li>
--   <li>CLaSH.Sized.Vector.head</li>
--   <li>CLaSH.Sized.Vector.tail</li>
--   <li>CLaSH.Sized.Vector.unconcat</li>
--   <li>CLaSH.Sized.Vector.transpose</li>
--   <li>CLaSH.Sized.Vector.replicate</li>
--   </ul>
reduceNonRepPrim :: NormRewrite

-- | Flatten ridiculous case-statements generated by GHC
--   
--   For case-statements in haskell of the form:
--   
--   <pre>
--   f :: Unsigned 4 -&gt; Unsigned 4
--   f x = case x of
--     0 -&gt; 3
--     1 -&gt; 2
--     2 -&gt; 1
--     3 -&gt; 0
--   </pre>
--   
--   GHC generates Core that looks like:
--   
--   <pre>
--   f = (x :: Unsigned 4) -&gt; case x == fromInteger 3 of
--                               False -&gt; case x == fromInteger 2 of
--                                 False -&gt; case x == fromInteger 1 of
--                                   False -&gt; case x == fromInteger 0 of
--                                     False -&gt; error "incomplete case"
--                                     True  -&gt; fromInteger 3
--                                   True -&gt; fromInteger 2
--                                 True -&gt; fromInteger 1
--                               True -&gt; fromInteger 0
--   </pre>
--   
--   Which would result in a priority decoder circuit where a normal
--   decoder circuit was desired.
--   
--   This transformation transforms the above Core to the saner:
--   
--   <pre>
--   f = (x :: Unsigned 4) -&gt; case x of
--          _ -&gt; error "incomplete case"
--          0 -&gt; fromInteger 3
--          1 -&gt; fromInteger 2
--          2 -&gt; fromInteger 1
--          3 -&gt; fromInteger 0
--   </pre>
caseFlat :: NormRewrite

-- | This transformation lifts applications of global binders out of
--   alternatives of case-statements.
--   
--   e.g. It converts:
--   
--   <pre>
--   case x of
--     A -&gt; f 3 y
--     B -&gt; f x x
--     C -&gt; h x
--   </pre>
--   
--   into:
--   
--   <pre>
--   let f_arg0 = case x of {A -&gt; 3; B -&gt; x}
--       f_arg1 = case x of {A -&gt; y; B -&gt; x}
--       f_out  = f f_arg0 f_arg1
--   in  case x of
--         A -&gt; f_out
--         B -&gt; f_out
--         C -&gt; h x
--   </pre>
disjointExpressionConsolidation :: NormRewrite
removeUnusedExpr :: NormRewrite


-- | Transformation process for normalization
module CLaSH.Normalize.Strategy

-- | Normalisation transformation
normalization :: NormRewrite
constantPropgation :: NormRewrite

-- | Topdown traversal, stops upon first success
topdownSucR :: Rewrite extra -> Rewrite extra
innerMost :: Rewrite extra -> Rewrite extra
applyMany :: [(String, Rewrite extra)] -> Rewrite extra


-- | Turn CoreHW terms into normalized CoreHW Terms
module CLaSH.Normalize

-- | Run a NormalizeSession in a given environment
runNormalization :: CLaSHOpts -> Supply -> HashMap TmName (Type, SrcSpan, Term) -> (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)) -> HashMap TyConName TyCon -> IntMap TyConName -> (HashMap TyConName TyCon -> Bool -> Term -> Term) -> PrimMap BlackBoxTemplate -> HashMap TmName Bool -> NormalizeSession a -> a
normalize :: [TmName] -> NormalizeSession (HashMap TmName (Type, SrcSpan, Term))
normalize' :: TmName -> NormalizeSession ([TmName], (TmName, (Type, SrcSpan, Term)))

-- | Rewrite a term according to the provided transformation
rewriteExpr :: (String, NormRewrite) -> (String, Term) -> NormalizeSession Term

-- | Check if the call graph (second argument), starting at the
--   <tt>topEnity</tt> (first argument) is non-recursive. Returns the list
--   of normalized terms if call graph is indeed non-recursive, errors
--   otherwise.
checkNonRecursive :: TmName -> HashMap TmName (Type, SrcSpan, Term) -> HashMap TmName (Type, SrcSpan, Term)

-- | Perform general "clean up" of the normalized (non-recursive) function
--   hierarchy. This includes:
--   
--   <ul>
--   <li>Inlining functions that simply "wrap" another function</li>
--   </ul>
cleanupGraph :: TmName -> (HashMap TmName (Type, SrcSpan, Term)) -> NormalizeSession (HashMap TmName (Type, SrcSpan, Term))
data CallTree
CLeaf :: (TmName, (Type, SrcSpan, Term)) -> CallTree
CBranch :: (TmName, (Type, SrcSpan, Term)) -> [CallTree] -> CallTree
mkCallTree :: [TmName] -> HashMap TmName (Type, SrcSpan, Term) -> TmName -> CallTree
stripArgs :: [TmName] -> [Id] -> [Either Term Type] -> Maybe [Either Term Type]
flattenNode :: CallTree -> NormalizeSession (Either CallTree ((TmName, Term), [CallTree]))
flattenCallTree :: CallTree -> NormalizeSession CallTree
callTreeToList :: [TmName] -> CallTree -> ([TmName], [(TmName, (Type, SrcSpan, Term))])


-- | Generate a HDL testbench for a component given a set of stimuli and a
--   set of matching expected outputs
module CLaSH.Driver.TestbenchGen

-- | Generate a HDL testbench for a component given a set of stimuli and a
--   set of matching expected outputs
genTestBench :: CLaSHOpts -> Supply -> PrimMap BlackBoxTemplate -> (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)) -> HashMap TyConName TyCon -> IntMap TyConName -> (HashMap TyConName TyCon -> Bool -> Term -> Term) -> (Identifier -> Identifier) -> [Identifier] -> HashMap TmName (Type, SrcSpan, Term) -> Maybe TmName -> Maybe TmName -> String -> [(String, FilePath)] -> Component -> IO ([(SrcSpan, Component)], [(String, FilePath)])


-- | Module that connects all the parts of the CLaSH compiler library
module CLaSH.Driver

-- | Create a set of target HDL files for a set of functions
generateHDL :: forall backend. Backend backend => BindingMap -> Maybe backend -> PrimMap (Text) -> HashMap TyConName TyCon -> IntMap TyConName -> (HashMap TyConName TyCon -> Type -> Maybe (Either String HWType)) -> (HashMap TyConName TyCon -> Bool -> Term -> Term) -> (TmName, Maybe TopEntity) -> Maybe TmName -> Maybe TmName -> CLaSHOpts -> (UTCTime, UTCTime) -> IO ()
parsePrimitive :: Primitive Text -> Primitive BlackBoxTemplate

-- | Pretty print Components to HDL Documents
createHDL :: Backend backend => backend -> String -> [(SrcSpan, Component)] -> [(String, Doc)]

-- | Prepares the directory for writing HDL files. This means creating the
--   dir if it does not exist and removing all existing .hdl files from it.
prepareDir :: Bool -> String -> String -> IO ()

-- | Writes a HDL file to the given directory
writeHDL :: Backend backend => backend -> FilePath -> (String, Doc) -> IO ()
copyDataFiles :: FilePath -> [(String, FilePath)] -> IO ()