Safe Haskell	None
Language	Haskell2010

Text.Docvim.AST

Synopsis

Documentation

Constructors

Project [Node]
Unit [Node]
Empty
FunctionDeclaration
Fields functionBang :: Bool functionName :: String functionArguments :: ArgumentList functionAttributes :: [String] functionBody :: [Node]
LetStatement
Fields letLexpr :: String letValue :: String
LexprStatement
Fields lexprBang :: Bool lexprExpr :: String
LwindowStatement
Fields lwindowHeight :: Maybe Int
UnletStatement
Fields unletBang :: Bool unletBody :: String
GenericStatement String	For the stuff we only crudely parse for now.
DocBlock [Node]
Paragraph [Node]
LinkTargets [String]
List [Node]
ListItem [Node]
Blockquote [Node]
Fenced [String]
Separator
Plaintext String
BreakTag
Link String
Code String
Whitespace
PluginAnnotation Name Description
FunctionsAnnotation
FunctionAnnotation Name
IndentAnnotation
DedentAnnotation
CommandsAnnotation
CommandAnnotation Name (Maybe Parameters)
FooterAnnotation
MappingsAnnotation
MappingAnnotation Name
OptionsAnnotation
OptionAnnotation Name Type (Maybe Default)
HeadingAnnotation String
SubheadingAnnotation String
TOC [String]

Instances

Eq Node Source #
Methods (==) :: Node -> Node -> Bool # (/=) :: Node -> Node -> Bool #
Data Node Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Node -> c Node # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Node # toConstr :: Node -> Constr # dataTypeOf :: Node -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Node) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Node) # gmapT :: (forall b. Data b => b -> b) -> Node -> Node # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Node -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Node -> r # gmapQ :: (forall d. Data d => d -> u) -> Node -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Node -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Node -> m Node # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Node -> m Node # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Node -> m Node #
Show Node Source #
Methods showsPrec :: Int -> Node -> ShowS # show :: Node -> String # showList :: [Node] -> ShowS #
Plated Node Source #
Methods plate :: Traversal' Node Node #

Constructors

Instances

Eq ArgumentList Source #
Methods (==) :: ArgumentList -> ArgumentList -> Bool # (/=) :: ArgumentList -> ArgumentList -> Bool #
Data ArgumentList Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ArgumentList -> c ArgumentList # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ArgumentList # toConstr :: ArgumentList -> Constr # dataTypeOf :: ArgumentList -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c ArgumentList) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArgumentList) # gmapT :: (forall b. Data b => b -> b) -> ArgumentList -> ArgumentList # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArgumentList -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArgumentList -> r # gmapQ :: (forall d. Data d => d -> u) -> ArgumentList -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ArgumentList -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArgumentList -> m ArgumentList # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgumentList -> m ArgumentList # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgumentList -> m ArgumentList #
Show ArgumentList Source #
Methods showsPrec :: Int -> ArgumentList -> ShowS # show :: ArgumentList -> String # showList :: [ArgumentList] -> ShowS #

Constructors

Instances

Eq Argument Source #
Methods (==) :: Argument -> Argument -> Bool # (/=) :: Argument -> Argument -> Bool #
Data Argument Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Argument -> c Argument # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Argument # toConstr :: Argument -> Constr # dataTypeOf :: Argument -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Argument) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Argument) # gmapT :: (forall b. Data b => b -> b) -> Argument -> Argument # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Argument -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Argument -> r # gmapQ :: (forall d. Data d => d -> u) -> Argument -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Argument -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Argument -> m Argument # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Argument -> m Argument # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Argument -> m Argument #
Show Argument Source #
Methods showsPrec :: Int -> Argument -> ShowS # show :: Argument -> String # showList :: [Argument] -> ShowS #

walk :: Monoid a => (Node -> a) -> a -> Node -> a Source #

Walks an AST node calling the supplied visitor function.

This is an in-order traversal.

For example, to implement a visitor which counts all nodes:

 import Data.Monoid
 count = getSum $ walk (\_ -> 1) (Sum 0) tree

For comparison, here is a (probably inefficient) alternative way using Plated instead of walk:

import Control.Lens.Operators
import Control.Lens.Plated
import Data.Data.Lens
count = length $ tree ^.. cosmosOf uniplate

Another example; accumulating SubheadingAnnotation nodes into a list:

 accumulator node@(SubheadingAnnotation _) = [node]
 accumulator _ = [] -- skip everything else
 nodes = walk accumulator [] tree

Again, for comparison, the same without walk, this time using a list comprehension:

import Control.Lens.Operators
import Control.Lens.Plated
import Data.Data.Lens
[n | n@(SubheadingAnnotation _) <- tree ^.. cosmosOf uniplate]

Sanitizes a link target similar to the way that GitHub does:

We use this both for generating GitHub friendly link targets, and for auto-generating new link targets for use inside Vim help files.