Stability | experimental |
---|---|
Maintainer | developer@flocc.net |
Safe Haskell | None |
For more information please see http://www.flocc.net/
- trace' :: String -> a -> a
- data Tree a
- treeIndexBase :: Int
- isFunTree :: Tree a -> Bool
- showTree :: Show a => Tree a -> String
- flattenTree :: Tree v -> [v]
- treeLeaf :: Show a => String -> Tree a -> a
- alignTrees :: Show a => Show b => String -> Tree a -> Tree b -> [(a, Tree b)]
- zipTrees :: (Show a, Show b) => String -> Tree a -> Tree b -> Tree (a, Tree b)
- zipSubTrees :: (Show a, Show b) => Tree a -> Tree b -> [(Tree a, Tree b)]
- visitTreeM :: Monad m => (a -> m (Tree b)) -> Tree a -> m (Tree b)
- visitTree :: (a -> Tree b) -> Tree a -> Tree b
- mapTree :: (a -> b) -> Tree a -> Tree b
- treeToList :: Tree a -> [a]
- type TreePath = [Int]
- visitTreeWithPath :: Monad m => (TreePath -> a -> m (Tree b)) -> TreePath -> Tree a -> m (Tree b)
- growTree :: (Show a, Show b) => String -> (TreePath -> a -> b -> c) -> Tree a -> Tree b -> Tree c
- lookupTreeNodeMaybe :: Show a => Tree a -> TreePath -> Maybe (Tree a)
- lookupTreeNode :: Show a => String -> Tree a -> TreePath -> Tree a
- lookupTreeNodeOrLeaf :: Show a => String -> Tree a -> TreePath -> Tree a
- replaceTreeNode :: Show a => TreePath -> Tree a -> Tree a -> Tree a
- subPaths :: [(TreePath, a)] -> TreePath -> [(TreePath, a)]
- createTreeFromPaths :: Show v => [(TreePath, v)] -> TreePath -> Tree v
- searchTree :: (a -> [b]) -> Tree a -> [b]
- filterTree :: (a -> Bool) -> Tree a -> [a]
- treeContains :: (a -> Bool) -> Tree a -> Bool
- tidyTree :: Tree a -> Tree a
- data LabelledTree l v
- = LLf l v
- | LFun l (LabelledTree l v) (LabelledTree l v)
- | LTup l [LabelledTree l v]
- flattenLTree :: LabelledTree l v -> [(l, v)]
- treeLabel :: Show l => Show v => LabelledTree l v -> l
- labelledTreePath :: (Show a, Show b) => LabelledTree a b -> TreePath -> LabelledTree a b
- zipLabelledTrees :: (Show l1, Show l2, Show v1, Show v2) => LabelledTree l1 v1 -> LabelledTree l2 v2 -> LabelledTree l1 (v1, LabelledTree l2 v2)
- toLabelledTree :: Tree a -> LabelledTree () a
- fromLabelledTree :: LabelledTree a b -> Tree b
- visitLabelledTreeM :: Monad m => (l -> a -> m (LabelledTree l b)) -> LabelledTree l a -> m (LabelledTree l b)
- mapLabels :: (l1 -> a -> b) -> (l1 -> l2) -> LabelledTree l1 a -> LabelledTree l2 b
- createTreePathTree :: TreePath -> LabelledTree a b -> LabelledTree TreePath ()
- data LfTy
- type Ty = Tree LfTy
- type TyScheme = Scheme Ty
- funTy :: Graph -> Ty
- lfTy :: String -> [Ty] -> Tree LfTy
- listTy :: Ty -> Tree LfTy
- iterTy :: Ty -> Tree LfTy
- idxIterTy :: Ty -> Tree LfTy
- intTy :: Tree LfTy
- uintTy :: Tree LfTy
- floatTy :: Tree LfTy
- boolTy :: Tree LfTy
- strTy :: Tree LfTy
- nullTy :: Tree LfTy
- mpiTyTy :: Tree LfTy
- isStreamTy :: Ty -> Bool
- isScalTy :: Ty -> Bool
- getVarsInTy :: Ty -> Set String
- getVarsInLfTy :: LfTy -> Set String
- mapGraphsInTyM :: Monad m => (Graph -> m Graph) -> Ty -> m Ty
- mapGraphsInTy :: (Graph -> Graph) -> Ty -> Ty
- getGraphsInTy :: Ty -> [Graph]
- data IgnoreFunsTy
- ignoreFunsTy :: Ty -> IgnoreFunsTy
- data ScalVal
- scalValType :: ScalVal -> Ty
- type NodeId = Int
- data NodeTy
- isFunNd :: NodeTy -> Bool
- isVarNd :: NodeTy -> Bool
- isTupAcc :: NodeTy -> Bool
- getFunNdGraph :: Node -> Graph
- getTupAccIdx :: Node -> Int
- getVarNodeName :: Node -> String
- data Node = Node {}
- type NodeEnv a = IntMap a
- emptyNodeEnv :: IntMap a
- lookupNode :: Show a => String -> NodeId -> NodeEnv a -> a
- lookupNodeMaybe :: Key -> IntMap a -> Maybe a
- duplicateNodeEnvIds :: Show a => NodeEnv NodeId -> NodeEnv a -> NodeEnv a
- type NodeTree = LabelledTree NodeId ()
- buildNodeTree :: [Graph] -> NodeId -> Ty -> NodeTreeEx
- buildInputNodeTree :: [Graph] -> Node -> NodeTree
- getInputNodeBeforeTuple :: [Graph] -> Node -> Node
- buildOutputNodeTree :: [Graph] -> Node -> NodeTree
- getGraphsInTys :: NodeEnv Ty -> [Graph]
- type NodeTreeEx = LabelledTree (NodeId, TreePath) ()
- emptyNodeTreeEx :: LabelledTree (Int, [a]) ()
- extendTyTree :: v1 -> LabelledTree v2 v3 -> LabelledTree (v1, TreePath) ()
- extendNodeTreeWithType :: NodeTree -> Ty -> NodeTreeEx
- data Graph = Graph {}
- graphName :: Graph -> String
- showSubgraphs :: Graph -> String
- newGraph :: [Node] -> NodeId -> NodeId -> Map String NodeId -> Graph
- seqComposeGraphs :: Graph -> Graph -> Graph
- graphsContain :: [Graph] -> NodeId -> Bool
- findInGraph :: (Node -> Bool) -> Graph -> [Node]
- lookupGraphNodeMaybe :: String -> NodeId -> [Graph] -> Maybe Node
- lookupGraphVarNode :: String -> Node -> [Graph] -> [Graph] -> Node
- lookupGraphNode :: String -> NodeId -> [Graph] -> Node
- lookupNodeLeafGraph :: String -> NodeId -> [Graph] -> Maybe Node
- maxNodeId :: Graph -> NodeId
- replaceNodeIds :: IntMap NodeId -> Graph -> Graph
- removeParentNodes :: IntMap Node -> Graph -> Graph
- getNodes :: String -> [Graph] -> [NodeId] -> [Node]
- getNodeCons :: Graph -> NodeId -> NodeId -> Set [Int] -> (Set NodeId, Set NodeId)
- getNodeConsumers :: Graph -> NodeId -> (Set NodeId, Set NodeId)
- visitNodeM :: Monad m => ([Graph] -> Node -> m ()) -> [Graph] -> NodeId -> StateT (NodeEnv ()) m ()
- visitGraphM :: Monad m => ([Graph] -> Node -> m ()) -> [Graph] -> m ()
- maxDepthVisitor :: Monad m => [Graph] -> Node -> StateT (NodeEnv Int) m ()
- type PartNodeFun m = [NodeId] -> m [[NodeId]]
- visitDeepestNodeM :: Monad m => PartNodeFun m -> ([Graph] -> Node -> m ()) -> [Graph] -> NodeEnv Int -> NodeId -> StateT (NodeEnv ()) m ()
- cycleVisitor :: Monad m => [Graph] -> Node -> StateT (Set Int, [Int]) m ()
- visitDeepestGraphM :: Monad m => PartNodeFun m -> ([Graph] -> Node -> m ()) -> [Graph] -> m ()
Documentation
data Tree a
treeIndexBase :: Int
treeIndexBase. Index of first element of |a tree tuple.
flattenTree :: Tree v -> [v]
flattenTree tree. Flattens tree using a depth first traversal, |returning the list of its leaves.
treeLeaf :: Show a => String -> Tree a -> a
treeLeaf takes a tree and if it is a leaf, returns it, or otherwise |throws the error message given.
alignTrees :: Show a => Show b => String -> Tree a -> Tree b -> [(a, Tree b)]
alignTrees treeA treeB aligns treeA and treeB to produce |a mapping from treeA leaves to treeB nodes. If the trees |don't fit/have the same shape, then an error is thrown.
zipTrees :: (Show a, Show b) => String -> Tree a -> Tree b -> Tree (a, Tree b)
zipTrees treeA treeB. Assuming treeA is a subset of treeB |returns a new tree with all children in b dangling from those |in a. Throws error otherwise.
zipSubTrees :: (Show a, Show b) => Tree a -> Tree b -> [(Tree a, Tree b)]
zipSubTrees treeA treeB. Returns a list of associated subtrees, for e.g. | zipSubTrees (Tup [Tup [Lf a, Lf b], Lf c]) (Tup [Lf x, Tup [Lf y, Lf z]]) = | [(Tup [Lf a, Lf b], Lf x), (Lf c, Tup [Lf y, Lf z])]. This will fail if two |tuples at the same level have different numbers of children, or if a tuple is |at the same level as a lambda etc.
visitTreeM :: Monad m => (a -> m (Tree b)) -> Tree a -> m (Tree b)
visitTreeM visits the tree using a depth first traversal |and creates a new tree using the monadic function to transform |its leaf values.
visitTree :: (a -> Tree b) -> Tree a -> Tree b
mapTree f tree. Returns a tree where all leaf values have been transformed |using f.
mapTree :: (a -> b) -> Tree a -> Tree b
mapTree f tree. Returns a tree where all leaf values have been transformed |using f.
treeToList :: Tree a -> [a]
treeToList takes a tree and returns a list of its elements |created using a depth first traversal
growTree :: (Show a, Show b) => String -> (TreePath -> a -> b -> c) -> Tree a -> Tree b -> Tree c
growTree smallTree largeTree newLeaf. Grows smallTree |to be the same size and shape of largeTree, by creating |new nodes with newLeaf.
lookupTreeNodeMaybe :: Show a => Tree a -> TreePath -> Maybe (Tree a)
lookupTreeNodeMaybe tree path. Looks up the node at path |in tree, or returns Nothing if doesn't exist.
lookupTreeNode :: Show a => String -> Tree a -> TreePath -> Tree a
lookupTreeNode errMsg tree path. Looks up the node at path |in tree, or throws an error if it does not exist.
lookupTreeNodeOrLeaf :: Show a => String -> Tree a -> TreePath -> Tree a
lookupTreeNodeOrLeaf errMsg tree path. Follows the tree path, |to return either the node at the path, or a leaf, |whatever comes first.
replaceTreeNode :: Show a => TreePath -> Tree a -> Tree a -> Tree a
replaceTreeNode path newNode oldTree. Returns oldTree where the node |at path has been replaced with newNode, or throws error if no such path |exists in oldTree.
subPaths :: [(TreePath, a)] -> TreePath -> [(TreePath, a)]
subPaths pathList pathPrefix. Filters pathList returning only |those for which pathPrefix is a prefix. Note: Here first element |is root of tree.
createTreeFromPaths :: Show v => [(TreePath, v)] -> TreePath -> Tree v
createTreeFromPaths paths currentPathPrefix. Takes a list of tree paths, with labels and leaves |and builds them into a labelled tree.Note: head element of paths is root node in tree.
searchTree :: (a -> [b]) -> Tree a -> [b]
searchTree searchFun tree. Visits all leaves |returning a list of values generated by the searchFun.
filterTree :: (a -> Bool) -> Tree a -> [a]
filterTree pred tree. Accumulates all leaf values for which the |predicate pred holds.
treeContains :: (a -> Bool) -> Tree a -> Bool
treeContains pred tree. Returns true if tree contains |a leaf for which the predicate pred holds.
data LabelledTree l v
LabelledTree l v - a tree where every node has a label
LLf l v | |
LFun l (LabelledTree l v) (LabelledTree l v) | |
LTup l [LabelledTree l v] |
(Eq l, Eq v) => Eq (LabelledTree l v) | |
(Show a, Show l) => Show (LabelledTree l a) | Show instance for labelled trees |
flattenLTree :: LabelledTree l v -> [(l, v)]
flattenLTree tree. Flattens tree using a depth first |traversal, returning a list of its leaves and their labels.
treeLabel :: Show l => Show v => LabelledTree l v -> l
treeLabel tree. Returns the label of a labelled tree.
labelledTreePath :: (Show a, Show b) => LabelledTree a b -> TreePath -> LabelledTree a b
labelledTreePath tree path. Looks up the node at path |in tree, or throws an error if it does not exist.
zipLabelledTrees :: (Show l1, Show l2, Show v1, Show v2) => LabelledTree l1 v1 -> LabelledTree l2 v2 -> LabelledTree l1 (v1, LabelledTree l2 v2)
zipLabelledTrees treeA treeB. Assuming treeA is a subset of treeB |returns a new tree with all children in b dangling from those |in a. Throws error otherwise. Keeps labels from treeA.
toLabelledTree :: Tree a -> LabelledTree () a
toLabelledTree tree. Converts a tree to a labelled tree.
fromLabelledTree :: LabelledTree a b -> Tree b
Converts from a labelled tree back to a normal |tree, disgarding the labels.
visitLabelledTreeM :: Monad m => (l -> a -> m (LabelledTree l b)) -> LabelledTree l a -> m (LabelledTree l b)
visitLabelledTreeM visits the tree using a depth first traversal |and creates a new tree using the monadic function to transform |its leaf values.
mapLabels :: (l1 -> a -> b) -> (l1 -> l2) -> LabelledTree l1 a -> LabelledTree l2 b
mapLabels f tree. Natural transformation of labelled tree labels.
createTreePathTree :: TreePath -> LabelledTree a b -> LabelledTree TreePath ()
createTreePathTree rootPath tree. Returns a tree with labels that are |tree paths for each node.
data LfTy
Contains vars instance for Tree
Data types
isStreamTy :: Ty -> Bool
getVarsInTy :: Ty -> Set String
getVarsInLfTy :: LfTy -> Set String
getVarTys lfTy. Returns the set of var ids in a leaf type.
mapGraphsInTyM :: Monad m => (Graph -> m Graph) -> Ty -> m Ty
mapGraphsInTy f ty. Applies f to all graphs in ty.
mapGraphsInTy :: (Graph -> Graph) -> Ty -> Ty
mapGraphsInTy f ty. Applies f to all graphs in ty.
getGraphsInTy :: Ty -> [Graph]
returns list of all graphs in this type.
ignoreFunsTy :: Ty -> IgnoreFunsTy
data ScalVal
Scalar literals
scalValType :: ScalVal -> Ty
scalValType val. Returns the type of this literal value.
data NodeTy
Node types
getFunNdGraph :: Node -> Graph
getTupAccIdx :: Node -> Int
getVarNodeName :: Node -> String
data Node
DFG nodes
emptyNodeEnv :: IntMap a
lookupNode :: Show a => String -> NodeId -> NodeEnv a -> a
looks up a member from a node environment or throws an |error with the given message
lookupNodeMaybe :: Key -> IntMap a -> Maybe a
lookupNodeMaybe nodeId nodeEnv. Looks up the node, or |returns Nothing if it could not be found.
duplicateNodeEnvIds :: Show a => NodeEnv NodeId -> NodeEnv a -> NodeEnv a
duplicateNodeEnvIds newIds oldEnv. Duplicates all entries in oldEnv |that exist in newIds, giving them the new ids defined in newIds, and then |returns all the original entries, and these new duplicated ones.
type NodeTree = LabelledTree NodeId ()
buildNodeTree :: [Graph] -> NodeId -> Ty -> NodeTreeEx
buildNodeTree graph nodeId type. Takes a graph and a node, and returns a |node tree of all its neighbours node ids. However this tree now also contains |leaves that access tuple values within a given node, which are identified |by treepaths.
buildInputNodeTree :: [Graph] -> Node -> NodeTree
buildInputNodeTree graph node. Builds a node tree from the input nodes |of a node.
getInputNodeBeforeTuple :: [Graph] -> Node -> Node
If node is a TupAccNode and it's input is a TupNd, shortcuts them |to immediately get the original node.
buildOutputNodeTree :: [Graph] -> Node -> NodeTree
buildOutputNodeTree takes a node, and looks through all its outputs |for tuple accessors, creating a labelled tree of output nodes.
getGraphsInTys :: NodeEnv Ty -> [Graph]
Returns all graphs in a type env.
type NodeTreeEx = LabelledTree (NodeId, TreePath) ()
emptyNodeTreeEx :: LabelledTree (Int, [a]) ()
extendTyTree :: v1 -> LabelledTree v2 v3 -> LabelledTree (v1, TreePath) ()
extendTyTree nodeId typeTree. Converts type tree into a tree of labels |for paths into it.
extendNodeTreeWithType :: NodeTree -> Ty -> NodeTreeEx
extendNodeTreeWithType tree type. Align tree with the |type and expand any leaves of tree that have tuple type |to provide leaves to access each of the tuple parts.
showSubgraphs :: Graph -> String
showSubgraphs g. Shows g and all the subgraphs nested in FunNds.
newGraph :: [Node] -> NodeId -> NodeId -> Map String NodeId -> Graph
newGraph creates a new graph from a list of nodes
seqComposeGraphs :: Graph -> Graph -> Graph
Sequentially compose graphs so g2 is applied after g1.
graphsContain :: [Graph] -> NodeId -> Bool
graphsContain graph nodeId. Returns true if one of the graphs |contains a node with id nodeId.
findInGraph :: (Node -> Bool) -> Graph -> [Node]
findInGraph nodeTy graph. Searches graph for |nodes with nodeTy and returns a list of all the nodes |that do.
lookupGraphNodeMaybe :: String -> NodeId -> [Graph] -> Maybe Node
lookupGraphNodeMaybe nid graph. Searches up graphs, |checking the current graph, and if it doesn't contain it |checking it's parent.
lookupGraphVarNode :: String -> Node -> [Graph] -> [Graph] -> Node
lookupGraphVarNode msg node allGraphs graphs. If node is a varNode called |something other than in or out, then this function searches up the |graph stack for a node bound to that name. If one exists, it then searches |from the leaf graph up to the root again (using allGraphs) to find this node, |returning it if it is found, or throwing an error otherwise.
lookupGraphNode :: String -> NodeId -> [Graph] -> Node
lookupNodeLeafGraph :: String -> NodeId -> [Graph] -> Maybe Node
lookupNodeLeafGraph errMsg nid graph. If in leaf graph, returns it. |If in parent graphs, returns Nothing. If in none of them, throws error.
maxNodeId graph. Finds the maximum node id |in the graph, grahp's parents, and all fun nodes of that graph.
replaceNodeIds :: IntMap NodeId -> Graph -> Graph
replaceNodeIds newNidMap graph. Returns a copy of the graph, |with the node ids replaced with the new ones in newNidMap.
removeParentNodes :: IntMap Node -> Graph -> Graph
removeParentNodes parNodes graph. Removes all nodes with |id's that exist in parNodes from graph. Also removes all |nodes with ids in parNodes or graph, from all graphs nested |in FunNd in graph.
getNodeCons :: Graph -> NodeId -> NodeId -> Set [Int] -> (Set NodeId, Set NodeId)
getNodeCons graph prevNodeId curNodeId tupPaths. Recursively looks at node |outputs to find all consumers of the value identified by the |current node and tuple paths (which identify the relevant |subvalues of the current node's value). Returns a set of |all tup and tup acc that proceed the consumers, and the set of |consumers themselves.
getNodeConsumers :: Graph -> NodeId -> (Set NodeId, Set NodeId)
getConsumers graph nodeId. Searches through all outputs, |and tuple, and tuple accessor nodes, finding consumers of the |value produced by this node. Returns a set of the nodes that |proceed these consumer nodes (and so may receive |values from the consumers), and the node ids of the consumer |nodes themselves.
visitNodeM :: Monad m => ([Graph] -> Node -> m ()) -> [Graph] -> NodeId -> StateT (NodeEnv ()) m ()
visitNodeM f graph nodeId. if the node specified by nodeId has not already been visited |visits all its inputs, and then applies f to itself.
visitGraphM :: Monad m => ([Graph] -> Node -> m ()) -> [Graph] -> m ()
visitGraphM visitF graph. Depth first traversal of a graph, applying |visitF to each node, never visiting the same node twice.
maxDepthVisitor :: Monad m => [Graph] -> Node -> StateT (NodeEnv Int) m ()
maxDepthVisitor graph node. Records the maximum depth of this node in |the state. I.e. the number of nodes above it's deepest input.
type PartNodeFun m = [NodeId] -> m [[NodeId]]
visitDeepestNodeM :: Monad m => PartNodeFun m -> ([Graph] -> Node -> m ()) -> [Graph] -> NodeEnv Int -> NodeId -> StateT (NodeEnv ()) m ()
visitDeepestNodeM pf f graph depths nodeId. if the node specified by nodeId has not already been visited |visits all its inputs, in order of descending depth, and then applies f to itself. |Uses pf to partition node lists into different groups, where the groups should be visited |in the order they appear in the list, but where members of groups can appear in any order.
cycleVisitor :: Monad m => [Graph] -> Node -> StateT (Set Int, [Int]) m ()
cycleVisitor checks there are no cycles in our graph.
visitDeepestGraphM :: Monad m => PartNodeFun m -> ([Graph] -> Node -> m ()) -> [Graph] -> m ()
visitDeepestGraphM visitF graph. Visits the nodes in the graph in deepest |first depth first traversal. I.e. it visits the deepest leaves, before shallower |ones.