FastTags

Documentation

isHsFile :: FilePath -> Bool

Crude predicate for Haskell files

isLiterateFile :: FilePath -> Bool

merge :: Ord a => [a] -> [a] -> [a]

data TagVal

Constructors

TagVal !Text !Type

Instances

Eq TagVal

Methods

(==) :: TagVal -> TagVal -> Bool

(/=) :: TagVal -> TagVal -> Bool

Ord TagVal

Methods

compare :: TagVal -> TagVal -> Ordering

(<) :: TagVal -> TagVal -> Bool

(<=) :: TagVal -> TagVal -> Bool

(>) :: TagVal -> TagVal -> Bool

(>=) :: TagVal -> TagVal -> Bool

max :: TagVal -> TagVal -> TagVal

min :: TagVal -> TagVal -> TagVal

Show TagVal

Methods

showsPrec :: Int -> TagVal -> ShowS

show :: TagVal -> String

showList :: [TagVal] -> ShowS

NFData TagVal

Methods

rnf :: TagVal -> ()

data Type

Constructors

Function

Type

Constructor

Class

Module

Operator

Pattern

Instances

Eq Type

Methods

(==) :: Type -> Type -> Bool

(/=) :: Type -> Type -> Bool

Ord Type

Methods

compare :: Type -> Type -> Ordering

(<) :: Type -> Type -> Bool

(<=) :: Type -> Type -> Bool

(>) :: Type -> Type -> Bool

(>=) :: Type -> Type -> Bool

max :: Type -> Type -> Type

min :: Type -> Type -> Type

Show Type

Methods

showsPrec :: Int -> Type -> ShowS

show :: Type -> String

showList :: [Type] -> ShowS

NFData Type

Methods

rnf :: Type -> ()

data Tag

Constructors

Tag !(Pos TagVal)

RepeatableTag !(Pos TagVal)

Warning !(Pos String)

Instances

Eq Tag

Methods

(==) :: Tag -> Tag -> Bool

(/=) :: Tag -> Tag -> Bool

Ord Tag

Methods

compare :: Tag -> Tag -> Ordering

(<) :: Tag -> Tag -> Bool

(<=) :: Tag -> Tag -> Bool

(>) :: Tag -> Tag -> Bool

(>=) :: Tag -> Tag -> Bool

max :: Tag -> Tag -> Tag

min :: Tag -> Tag -> Tag

Show Tag

Methods

showsPrec :: Int -> Tag -> ShowS

show :: Tag -> String

showList :: [Tag] -> ShowS

data Pos a

Constructors

Pos

Fields

• posOf :: !SrcPos
• valOf :: !a

Instances

Eq a => Eq (Pos a)

Methods

(==) :: Pos a -> Pos a -> Bool

(/=) :: Pos a -> Pos a -> Bool

Ord a => Ord (Pos a)

Methods

compare :: Pos a -> Pos a -> Ordering

(<) :: Pos a -> Pos a -> Bool

(<=) :: Pos a -> Pos a -> Bool

(>) :: Pos a -> Pos a -> Bool

(>=) :: Pos a -> Pos a -> Bool

max :: Pos a -> Pos a -> Pos a

min :: Pos a -> Pos a -> Pos a

Show a => Show (Pos a)

Methods

showsPrec :: Int -> Pos a -> ShowS

show :: Pos a -> String

showList :: [Pos a] -> ShowS

NFData a => NFData (Pos a)

Methods

rnf :: Pos a -> ()

data SrcPos

Constructors

SrcPos

Fields

• posFile :: !FilePath
• posLine :: !Line
• posPrefix :: Text

  No need to keep prefix strict since most of the prefixes will not be used.

Instances

Eq SrcPos

Methods

(==) :: SrcPos -> SrcPos -> Bool

(/=) :: SrcPos -> SrcPos -> Bool

Ord SrcPos

Methods

compare :: SrcPos -> SrcPos -> Ordering

(<) :: SrcPos -> SrcPos -> Bool

(<=) :: SrcPos -> SrcPos -> Bool

(>) :: SrcPos -> SrcPos -> Bool

(>=) :: SrcPos -> SrcPos -> Bool

max :: SrcPos -> SrcPos -> SrcPos

min :: SrcPos -> SrcPos -> SrcPos

Show SrcPos

Methods

showsPrec :: Int -> SrcPos -> ShowS

show :: SrcPos -> String

showList :: [SrcPos] -> ShowS

NFData SrcPos

Methods

rnf :: SrcPos -> ()

newtype UnstrippedTokens

Newlines have to remain in the tokens because breakBlocks relies on them. But they make pattern matching on the tokens unreliable because newlines might be anywhere. A newtype makes sure that the tokens only get stripped once and that I don't do any pattern matching on unstripped tokens.

Constructors

UnstrippedTokens [Token]

Instances

Show UnstrippedTokens

Methods

showsPrec :: Int -> UnstrippedTokens -> ShowS

show :: UnstrippedTokens -> String

showList :: [UnstrippedTokens] -> ShowS

Monoid UnstrippedTokens

Methods

mempty :: UnstrippedTokens

mappend :: UnstrippedTokens -> UnstrippedTokens -> UnstrippedTokens

mconcat :: [UnstrippedTokens] -> UnstrippedTokens

processFile :: FilePath -> Bool -> IO ([Pos TagVal], [String])

Read tags from one file.

processAll :: [[Pos TagVal]] -> [Pos TagVal]

Global processing for when all tags are together.

process :: FilePath -> Bool -> Text -> ([Pos TagVal], [String])

Process one file's worth of tags.

stripCpp :: Text -> Text

Strip cpp lines starting with #. Also strips out hsc detritus.

stripNewlines :: UnstrippedTokens -> [Token]

It's easier to scan for tokens without pesky newlines popping up everywhere. But I need to keep the newlines in in case I hit a where and need to call breakBlocks again.

breakBlocks :: UnstrippedTokens -> [UnstrippedTokens]

Break the input up into blocks based on indentation.

unstrippedTokensOf :: UnstrippedTokens -> [Token]

split :: Eq a => a -> [a] -> [[a]]

Split list into chunks delimited by specified element.