clash-lib-0.2.0.1: CAES Language for Synchronous Hardware - As a Library

Safe HaskellNone

CLaSH.Rewrite.Types

Description

Type and instance definitions for Rewrite modules

Synopsis

Documentation

data CoreContext Source

Context in which a term appears

Constructors

AppFun

Function position of an application

AppArg

Argument position of an application

TyAppC

Function position of a type application

LetBinding [Id]

RHS of a Let-binder with the sibling LHS'

LetBody [Id]

Body of a Let-binding with the bound LHS'

LamBody Id

Body of a lambda-term with the abstracted variable

TyLamBody TyVar

Body of a TyLambda-term with the abstracted type-variable

CaseAlt [Id]

RHS of a case-alternative with the variables bound by the pattern on the LHS

CaseScrut

Subject of a case-decomposition

Instances

data RewriteState Source

State of a rewriting session

Constructors

RewriteState 

Fields

_transformCounter :: Int

Number of applied transformations

_bindings :: HashMap TmName (Type, Term)

Global binders

_uniqSupply :: Supply

Supply of unique numbers

_typeTranslator :: Type -> Maybe (Either String HWType)

Hardcode Type -> HWType translator

Instances

Monad m => MonadState RewriteState (R m) 
Monad m => MonadUnique (RewriteMonad m) 

data DebugLevel Source

Debug Message Verbosity

Constructors

DebugNone

Don't show debug messages

DebugFinal

Show completely normalized expressions

DebugApplied

Show sub-expressions after a successful rewrite

DebugAll

Show all sub-expressions on which a rewrite is attempted

newtype RewriteEnv Source

Read-only environment of a rewriting session

Constructors

RE 

Instances

Monad m => MonadReader RewriteEnv (R m) 
Monad m => MonadUnique (RewriteMonad m) 

type RewriteSession m = ReaderT RewriteEnv (StateT RewriteState (FreshMT m))Source

Monad that keeps track how many transformations have been applied and can generate fresh variables and unique identifiers

type RewriteMonad m = WriterT Any (RewriteSession m)Source

Monad that can do the same as RewriteSession and in addition keeps track if a transformation/rewrite has been successfully applied.

newtype R m a Source

MTL convenience wrapper around RewriteMonad

Constructors

R 

Fields

runR :: RewriteMonad m a
 

Instances

Monad m => MonadReader RewriteEnv (R m) 
Monad m => MonadWriter Any (R m) 
Monad m => MonadState RewriteState (R m) 
Monad m => Monad (R m) 
Functor m => Functor (R m) 
(Monad m, Functor m) => Applicative (R m) 
Monad m => Fresh (R m) 
Monad m => MonadUnique (R m) 

type Transform m = [CoreContext] -> Term -> m TermSource

Monadic action that transforms a term given a certain context

type Rewrite m = Transform (R m)Source

A Transform action in the context of the RewriteMonad