LogicGrowsOnTrees.Location

This module contains infrastructure for working with Locations, which indicate a location within a tree but, unlike Path, without the cached values.

Type-classes

class MonadPlus m => MonadLocatable m where

The class MonadLocatable allows you to get your current location within a tree.

Methods

getLocation :: m Location

Instances

Monad m => MonadLocatable (LocatableTreeT m)

MonadPlus m => MonadLocatable (LocatableT m)

Types

data Location

A Location identifies a location in a tree; unlike Path it only contains information about the list of branches that have been taken, and not information about the cached values encounted along the way.

Instances

Eq Location

Ord Location

The Ord instance performs the comparison using the list of branches in the path defined by the location, which is obtained using the function branchingFromLocation.

Show Location

Monoid Location

The Monoid instance constructs a location that is the result of appending the path in the second argument to the path in the first argument.

data Solution α

A Solution is a result tagged with the location of the leaf at which it was found.

Constructors

Solution

Fields

solutionLocation :: Location

solutionResult :: α

Instances

Eq α => Eq (Solution α)

Ord α => Ord (Solution α)

Show α => Show (Solution α)

newtype LocatableT m α

LocatableT is a monad transformer that allows you to take any MonadPlus and add to it the ability to tell where you are in the tree created by the mpluss.

Constructors

LocatableT

Fields

unwrapLocatableT :: ReaderT Location m α

Instances

MonadTrans LocatableT

Monad m => Monad (LocatableT m)

Functor m => Functor (LocatableT m)

MonadPlus m => MonadPlus (LocatableT m)

Applicative m => Applicative (LocatableT m)

(Alternative m, Monad m) => Alternative (LocatableT m)

MonadIO m => MonadIO (LocatableT m)

MonadExplorableTrans m => MonadExplorableTrans (LocatableT m)

MonadPlus m => MonadLocatable (LocatableT m)

MonadPlus m => Monoid (LocatableT m α)

type LocatableTree = LocatableTreeT Identity

A Tree augmented with the ability to get the current location

type LocatableTreeIO = LocatableTreeT IO

Like LocatableTree, but running in the IO monad.

newtype LocatableTreeT m α

Like LocatableTree, but running in an arbitrary monad.

Constructors

LocatableTreeT

Fields

unwrapLocatableTreeT :: LocatableT (TreeT m) α

Instances

MonadTrans LocatableTreeT

Monad m => Monad (LocatableTreeT m)

Monad m => Functor (LocatableTreeT m)

Monad m => MonadPlus (LocatableTreeT m)

Monad m => Applicative (LocatableTreeT m)

Monad m => Alternative (LocatableTreeT m)

MonadIO m => MonadIO (LocatableTreeT m)

Monad m => MonadExplorableTrans (LocatableTreeT m)

Monad m => MonadLocatable (LocatableTreeT m)

Monad m => Monoid (LocatableTreeT m α)

Utility functions

applyCheckpointCursorToLocation

Arguments

:: CheckpointCursor

a path within the subtree

-> Location

the location of the subtree

-> Location

the location within the full tree obtained by following the path to the subtree and then the path indicated by the checkpoint cursor

Append the path indicated by a checkpoint cursor to the given location's path.

applyContextToLocation

Arguments

:: Context m α

the path within the subtree

-> Location

the location of the subtree

-> Location

the location within the full tree obtained by following the path to the subtree and then the path indicated by the context

Append the path indicated by a context to the given location's path.

applyPathToLocation

Arguments

:: Path

a path within the subtree

-> Location

the location of the subtree

-> Location

the location within the full tree obtained by following the path to the subtree and then the given path

Append a path to a location's path.

branchingFromLocation :: Location -> [BranchChoice]

Converts a location to a list of branch choices.

labelFromBranching :: Foldable t => t BranchChoice -> Location

Converts a list (or other Foldable) of branch choices to a location.

labelFromContext :: Context m α -> Location

Contructs a Location representing the location within the tree indicated by the Context.

labelFromPath :: Path -> Location

Contructs a Location representing the location within the tree indicated by the Path.

leftBranchOf :: Location -> Location

Returns the Location at the left branch of the given location.

locationTransformerForBranchChoice :: BranchChoice -> Location -> Location

Convenience function takes a branch choice and returns a location transformer that appends the branch choice to the given location.

normalizeLocatableTree :: LocatableTree α -> Tree α

Converts a LocatableTree to a Tree.

normalizeLocatableTreeT :: LocatableTreeT m α -> TreeT m α

Converts a LocatableTreeT to a TreeT.

rightBranchOf :: Location -> Location

Returns the Location at the right branch of the given location.

rootLocation :: Location

The location at the root of the tree.

runLocatableT :: LocatableT m α -> m α

Runs a LocatableT to obtain the nested monad.

sendTreeDownLocation :: Location -> Tree α -> Tree α

Walks down a Tree to the subtree at the given Location. This function is analogous to sendTreeDownPath, and shares the same caveats.

sendTreeTDownLocation :: Monad m => Location -> TreeT m α -> m (TreeT m α)

Like sendTreeDownLocation, but for impure trees.

solutionsToMap :: Foldable t => t (Solution α) -> Map Location α

Converts a list (or other Foldable) of solutions to a Map from Locations to results.

Exploration functions

exploreLocatableTree :: Monoid α => LocatableTree α -> α

Explore all the nodes in a LocatableTree and sum over all the results in the leaves.

exploreLocatableTreeT :: (Monoid α, Monad m) => LocatableTreeT m α -> m α

Same as exploreLocatableTree, but for an impure tree.

exploreLocatableTreeTAndIgnoreResults :: Monad m => LocatableTreeT m α -> m ()

Same as exploreLocatableTree, but the results are discarded so the tree is only explored for its side-effects.

exploreTreeWithLocations :: Tree α -> [Solution α]

Explores all of the nodes of a tree, returning a list of solutions each tagged with the location at which it was found.

exploreTreeTWithLocations :: Monad m => TreeT m α -> m [Solution α]

Like exploreTreeWithLocations but for an impure tree.

exploreTreeWithLocationsStartingAt :: Location -> Tree α -> [Solution α]

Like exploreTreeWithLocations, but for a subtree whose location is given by the first argument; the solutions are labeled by the absolute location within the full tree (as opposed to their relative location within the subtree).

exploreTreeTWithLocationsStartingAt :: Monad m => Location -> TreeT m α -> m [Solution α]

Like exploreTreeWithLocationsStartingAt but for an impure trees.

exploreLocatableTreeUntilFirst :: LocatableTree α -> Maybe α

Explores all the nodes in a LocatableTree until a result (i.e., a leaf) has been found; if a result has been found then it is returned wrapped in Just, otherwise Nothing is returned.

exploreLocatableTreeUntilFirstT :: Monad m => LocatableTreeT m α -> m (Maybe α)

Like exploreLocatableTreeUntilFirst but for an impure tree.

exploreTreeUntilFirstWithLocation :: Tree α -> Maybe (Solution α)

Explores all the nodes in a tree until a result (i.e., a leaf) has been found; if a result has been found then it is returned tagged with the location at which it was found and wrapped in Just, otherwise Nothing is returned.

exploreTreeTUntilFirstWithLocation :: Monad m => TreeT m α -> m (Maybe (Solution α))

Like exploreTreeUntilFirstWithLocation but for an impure tree.

exploreTreeUntilFirstWithLocationStartingAt :: Location -> Tree α -> Maybe (Solution α)

Like exploreTreeUntilFirstWithLocation, but for a subtree whose location is given by the first argument; the solution (if present) is labeled by the absolute location within the full tree (as opposed to its relative location within the subtree).

exploreTreeTUntilFirstWithLocationStartingAt :: Monad m => Location -> TreeT m α -> m (Maybe (Solution α))

Like exploreTreeUntilFirstWithLocationStartingAt but for an impure tree.