ATerm.Utilities

Functions for working with the ATerms that ROSE produces.

Utility functions

app :: (ATermTable -> a) -> ATermTable -> Int -> a

Turns a normal function of ATermTable into a function that works on the hash value instead.

foldr :: (ATermTable -> a -> a) -> a -> ATermTable -> a

Standard foldr, but for ATermTables

foldl :: (a -> ATermTable -> a) -> a -> ATermTable -> a

Standard foldl, but for ATermTables

foldl' :: (a -> ATermTable -> a) -> a -> ATermTable -> a

Standard foldl', but for ATermTables

foldM :: Monad m => (a -> ATermTable -> m a) -> a -> ATermTable -> m a

Standard foldM, but for ATermTables

mapM :: Monad m => (ATermTable -> m b) -> ATermTable -> m [b]

Standard mapM, but for ATermTables

mapM_ :: Monad m => (ATermTable -> m b) -> ATermTable -> m ()

Standard mapM_, but for ATermTables

map :: (ATermTable -> a) -> ATermTable -> [a]

Standard map, but for ATermTables

concatMap :: (ATermTable -> [a]) -> ATermTable -> [a]

Standard concatMap, but for ATermTables

Check Monad

type CheckM log state m a = RWST ATermTable log state m a

The checker monad. For now the environment is the current ATerm, in the future we may also store the path from the root to the current ATerm, so use currentTerm instead of ask to get the current ATerm

appM :: (Monoid log, Monad m) => (ATermTable -> a) -> Int -> CheckM log state m a

Like app but lifts the result into the CheckM monad

currentTerm :: (Monoid log, Monad m) => CheckM log state m ATermTable

Use this instead of ask so that we can refactor the environment later without impacting existing code.

withCurrentTerm :: (Monoid log, Monad m) => ATermTable -> CheckM log state m a -> CheckM log state m a

Use this instead of local so that we can refactor the environment later without impacting existing code.

childrenM :: (Monad m, Monoid log) => CheckM log state m [Int]

Return the hashes of the current term's children into the monad

satisfy :: (Monad m, Monoid log) => (ATermTable -> Bool) -> CheckM log st m a -> CheckM log st m (Maybe a)

Use this when the current node must satisfy a specific property. Note: Using Maybe here is a bit of a hack. Refactor to support MonadPlus style guards?

inSubtree :: (Monad m, Monoid log) => CheckM log state m a -> CheckM log state m [[a]]

Applies a traversal in a subtree of the current ATerm. Differs from everywhere in that it does not apply the traversal to the current term (only its children and their children).

inSubtree_ :: (Monad m, Monoid log) => CheckM log state m a -> CheckM log state m ()

everywhere :: (Monad m, Monoid log) => CheckM log state m a -> CheckM log state m [a]

Applies a traversal over the tree defined by the current node (including root node).

everywhere_ :: (Monad m, Monoid log) => CheckM log state m a -> CheckM log state m ()

Like everywhere but throws away the result.

Extractions

extractString :: ATermTable -> Maybe String

Extracts the label of Application nodes

extractInteger :: ATermTable -> Maybe Integer

Extract the integer of Int nodes

extractFileInfo :: ATermTable -> Maybe (String, Integer, Integer)

Extracts the filename, line number, and colunm number from file_info nodes.

isNamed :: String -> ATermTable -> Bool

Equality test on the label of an Application node

showATerm :: ATermTable -> String

It's not acually pretty, but that's not our fault.

children :: ATermTable -> [Int]

This pattern comes up in most traversals. Simply return the stable names so we don't break sharing.

Read and write

readATerm :: String -> ATermTable

create an ATerm table from an input string. Shared or unshared ATerms can be read. A string for shared ATerms usually starts with an exclamation mark and contains many hash marks indicating references. Unshared ATerms are plain constructor terms.

writeSharedATerm :: ATermTable -> String

Misc

getATermFromTable :: ATermTable -> Int -> ATermTable