-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Collection of language-related Yi libraries.
--   
--   Collection of language-related Yi libraries.
@package yi-language
@version 0.19.2

-- | Colors and friends.
module Yi.Style

-- | Visual text attributes to be applied during layout.
data Attributes
Attributes :: !Color -> !Color -> !Bool -> !Bool -> !Bool -> !Bool -> Attributes
[foreground] :: Attributes -> !Color
[background] :: Attributes -> !Color

-- | The text should be show as "active" or "selected". This can be
--   implemented by reverse video on the terminal.
[reverseAttr] :: Attributes -> !Bool
[bold] :: Attributes -> !Bool
[italic] :: Attributes -> !Bool
[underline] :: Attributes -> !Bool
emptyAttributes :: Attributes

-- | The style is used to transform attributes by modifying one or more of
--   the visual text attributes.
type Style = Endo Attributes

-- | The UI type
data UIStyle
UIStyle :: Attributes -> Style -> Attributes -> Style -> Style -> Attributes -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> Style -> UIStyle

-- | ground attributes for the modeline
[modelineAttributes] :: UIStyle -> Attributes

-- | transformation of modeline in focus
[modelineFocusStyle] :: UIStyle -> Style

-- | ground attributes for the tabbar
[tabBarAttributes] :: UIStyle -> Attributes

-- | a tab that currently holds the focus
[tabInFocusStyle] :: UIStyle -> Style

-- | a tab that does not have the current focus
[tabNotFocusedStyle] :: UIStyle -> Style

-- | ground attributes for the main text views
[baseAttributes] :: UIStyle -> Attributes

-- | the selected portion
[selectedStyle] :: UIStyle -> Style

-- | empty file marker colours
[eofStyle] :: UIStyle -> Style

-- | indicates errors in text
[errorStyle] :: UIStyle -> Style

-- | search matchesparen matchesother hints
[hintStyle] :: UIStyle -> Style

-- | current search match
[strongHintStyle] :: UIStyle -> Style

-- | all comments
[commentStyle] :: UIStyle -> Style

-- | additional only for block comments
[blockCommentStyle] :: UIStyle -> Style

-- | applied to language keywords
[keywordStyle] :: UIStyle -> Style

-- | numbers
[numberStyle] :: UIStyle -> Style

-- | preprocessor directive (often in Haskell or C)
[preprocessorStyle] :: UIStyle -> Style

-- | constant strings
[stringStyle] :: UIStyle -> Style

-- | additional style for long strings
[longStringStyle] :: UIStyle -> Style

-- | type name (such as class in an OO language)
[typeStyle] :: UIStyle -> Style

-- | data constructor
[dataConstructorStyle] :: UIStyle -> Style

-- | style of import names
[importStyle] :: UIStyle -> Style

-- | builtin things, e.g. Array in JavaScript
[builtinStyle] :: UIStyle -> Style

-- | regular expressions
[regexStyle] :: UIStyle -> Style

-- | any standard variable (identifier)
[variableStyle] :: UIStyle -> Style

-- | infix operators
[operatorStyle] :: UIStyle -> Style

-- | Style of a quotation (e.g. in template haskell)
[quoteStyle] :: UIStyle -> Style

-- | stuff that's passed to the shell in a Makefile
[makeFileAction] :: UIStyle -> Style

-- | makefile rule headers
[makeFileRuleHead] :: UIStyle -> Style

-- | A StyleName determines what style to use, taking into account the set
--   of rendering preferences given by a UIStyle. Typically, style
--   names will be Style-valued field names of UIStyle.
type StyleName = UIStyle -> Style

-- | A style that sets the foreground.
withFg :: Color -> Style

-- | A style that sets the background.
withBg :: Color -> Style

-- | A style that sets the font to bold
withBd :: Bool -> Style

-- | A style that sets the style to italics
withItlc :: Bool -> Style

-- | A style that sets the style to underlined
withUnderline :: Bool -> Style

-- | A style that sets the style to underlined
withReverse :: Bool -> Style

-- | The identity transform.
defaultStyle :: StyleName
data Color
RGB :: {-# UNPACK #-} !Word8 -> {-# UNPACK #-} !Word8 -> {-# UNPACK #-} !Word8 -> Color

-- | The system-default color of the engine used. e.g. in Gtk this should
--   pick whatever the user has chosen as default color (background or
--   foreground depending on usage) for the text.
Default :: Color

-- | Convert a color to its text specification, as to be accepted by
--   XParseColor
colorToText :: Color -> String
black :: Color
grey :: Color
lightGrey :: Color
darkred :: Color
red :: Color
darkgreen :: Color
green :: Color
brown :: Color
yellow :: Color
darkblue :: Color
blue :: Color
purple :: Color
magenta :: Color
darkcyan :: Color
cyan :: Color
white :: Color
brightwhite :: Color
instance GHC.Classes.Eq Yi.Style.Attributes
instance GHC.Classes.Eq Yi.Style.Color
instance GHC.Classes.Ord Yi.Style.Attributes
instance GHC.Classes.Ord Yi.Style.Color
instance GHC.Internal.Show.Show Yi.Style.Attributes
instance GHC.Internal.Show.Show Yi.Style.Color

module Yi.Style.Library
type Theme = Proto UIStyle

-- | Abstract theme that provides useful defaults.
defaultTheme :: Theme

-- | A Theme inspired by the darkblue colorscheme of Vim.
darkBlueTheme :: Theme

-- | Various utility functions and instances used throughout Yi. Some of
--   the functions from the now-removed Yi.Prelude found a new home here.
module Yi.Utils
io :: MonadBase IO m => IO a -> m a
fst3 :: (a, b, c) -> a
snd3 :: (a, b, c) -> b
trd3 :: (a, b, c) -> c
class SemiNum absolute relative | absolute -> relative
(+~) :: SemiNum absolute relative => absolute -> relative -> absolute
(-~) :: SemiNum absolute relative => absolute -> relative -> absolute
(~-) :: SemiNum absolute relative => absolute -> absolute -> relative

-- | As nub, but with O(n*log(n)) behaviour.
nubSet :: Ord a => [a] -> [a]

-- | As Map.adjust, but the combining function is applied strictly.
mapAdjust' :: Ord k => (a -> a) -> k -> Map k a -> Map k a

-- | Generalisation of fromList to arbitrary foldables.
mapFromFoldable :: (Foldable t, Ord k) => t (k, a) -> Map k a

-- | Alternative to groupBy.
--   
--   
--   groupBy' (\a b -> abs (a - b) <= 1) [1,2,3] = [[1,2,3]]
--   
--   
--   whereas
--   
--   
--   groupBy (\a b -> abs (a - b) <= 1) [1,2,3] = [[1,2],[3]]
--   
--   
--   TODO: Check in ghc 6.12 release if groupBy == groupBy'.
groupBy' :: (a -> a -> Bool) -> [a] -> [[a]]
chain :: (a -> a -> Bool) -> [a] -> ([a], [a])

-- | Return the longest common prefix of a set of lists.
--   
--   
--   P(xs) === all (isPrefixOf (commonPrefix xs)) xs
--   length s > length (commonPrefix xs) --> not (all (isPrefixOf s) xs)
--   
commonPrefix :: Eq a => [[a]] -> [a]

-- | Finds the first element satisfying the predicate, and returns a zipper
--   pointing at it.
findPL :: (a -> Bool) -> [a] -> Maybe (PointedList a)

-- | Given a function which moves the focus from index A to index B, return
--   a function which swaps the elements at indexes A and B and then moves
--   the focus. See Yi.Editor.swapWinWithFirstE for an example.
swapFocus :: (PointedList a -> PointedList a) -> PointedList a -> PointedList a
makeClassyWithSuffix :: String -> Name -> Q [Dec]
addSuffix :: Name -> String -> [DefName]
makeLensesWithSuffix :: String -> Name -> Q [Dec]
instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k, Data.Binary.Class.Binary k, Data.Binary.Class.Binary v) => Data.Binary.Class.Binary (Data.HashMap.Internal.HashMap k v)

-- | Basic types useful everywhere we play with buffers.
module Yi.Buffer.Basic

-- | Direction of movement inside a buffer
data Direction
Backward :: Direction
Forward :: Direction
reverseDir :: Direction -> Direction

-- | reverse if Backward
mayReverse :: Direction -> [a] -> [a]

-- | direction is in the same style of maybe or
--   either functions, It takes one argument per direction
--   (backward, then forward) and a direction to select the output.
directionElim :: Direction -> a -> a -> a

-- | A mark in a buffer
newtype Mark
Mark :: Int -> Mark
[markId] :: Mark -> Int

-- | Reference to a buffer.
newtype BufferRef
BufferRef :: Int -> BufferRef

-- | A point in a buffer
newtype Point
Point :: Int -> Point
[fromPoint] :: Point -> Int

-- | Size of a buffer region
newtype Size
Size :: Int -> Size
[fromSize] :: Size -> Int

-- | Window references
newtype WindowRef
WindowRef :: Int -> WindowRef
[unWindowRef] :: WindowRef -> Int
instance Data.Binary.Class.Binary Yi.Buffer.Basic.BufferRef
instance Data.Binary.Class.Binary Yi.Buffer.Basic.Direction
instance Data.Binary.Class.Binary Yi.Buffer.Basic.Mark
instance Data.Binary.Class.Binary Yi.Buffer.Basic.Point
instance Data.Binary.Class.Binary Yi.Buffer.Basic.Size
instance Data.Binary.Class.Binary Yi.Buffer.Basic.WindowRef
instance GHC.Internal.Enum.Bounded Yi.Buffer.Basic.Direction
instance GHC.Internal.Enum.Bounded Yi.Buffer.Basic.Point
instance Data.Default.Internal.Default Yi.Buffer.Basic.WindowRef
instance GHC.Internal.Enum.Enum Yi.Buffer.Basic.Direction
instance GHC.Internal.Enum.Enum Yi.Buffer.Basic.Point
instance GHC.Internal.Enum.Enum Yi.Buffer.Basic.Size
instance GHC.Internal.Enum.Enum Yi.Buffer.Basic.WindowRef
instance GHC.Classes.Eq Yi.Buffer.Basic.BufferRef
instance GHC.Classes.Eq Yi.Buffer.Basic.Direction
instance GHC.Classes.Eq Yi.Buffer.Basic.Mark
instance GHC.Classes.Eq Yi.Buffer.Basic.Point
instance GHC.Classes.Eq Yi.Buffer.Basic.Size
instance GHC.Classes.Eq Yi.Buffer.Basic.WindowRef
instance GHC.Internal.Generics.Generic Yi.Buffer.Basic.Direction
instance GHC.Internal.Real.Integral Yi.Buffer.Basic.Point
instance GHC.Internal.Real.Integral Yi.Buffer.Basic.Size
instance GHC.Internal.Ix.Ix Yi.Buffer.Basic.Point
instance GHC.Internal.Num.Num Yi.Buffer.Basic.BufferRef
instance GHC.Internal.Num.Num Yi.Buffer.Basic.Point
instance GHC.Internal.Num.Num Yi.Buffer.Basic.Size
instance GHC.Classes.Ord Yi.Buffer.Basic.BufferRef
instance GHC.Classes.Ord Yi.Buffer.Basic.Direction
instance GHC.Classes.Ord Yi.Buffer.Basic.Mark
instance GHC.Classes.Ord Yi.Buffer.Basic.Point
instance GHC.Classes.Ord Yi.Buffer.Basic.Size
instance GHC.Classes.Ord Yi.Buffer.Basic.WindowRef
instance GHC.Internal.Real.Real Yi.Buffer.Basic.Point
instance GHC.Internal.Real.Real Yi.Buffer.Basic.Size
instance Yi.Utils.SemiNum Yi.Buffer.Basic.Point Yi.Buffer.Basic.Size
instance GHC.Internal.Show.Show Yi.Buffer.Basic.BufferRef
instance GHC.Internal.Show.Show Yi.Buffer.Basic.Direction
instance GHC.Internal.Show.Show Yi.Buffer.Basic.Mark
instance GHC.Internal.Show.Show Yi.Buffer.Basic.Point
instance GHC.Internal.Show.Show Yi.Buffer.Basic.Size
instance GHC.Internal.Show.Show Yi.Buffer.Basic.WindowRef

-- | This module defines the Region ADT
module Yi.Region

-- | The region data type. The region is semi open: it includes the start
--   but not the end bound. This allows simpler region-manipulation
--   algorithms. Invariant : regionStart r <= regionEnd r
data Region

-- | The empty region
emptyRegion :: Region
regionIsEmpty :: Region -> Bool

-- | Construct a region from its bounds, emacs style: the right bound is
--   excluded
mkRegion :: Point -> Point -> Region
mkRegion' :: Direction -> Point -> Point -> Region
mkSizeRegion :: Point -> Size -> Region
regionStart :: Region -> Point
regionEnd :: Region -> Point
regionSize :: Region -> Size
regionDirection :: Region -> Direction

-- | True if the given point is inside the given region.
inRegion :: Point -> Region -> Bool

-- | True if the given point is inside the given region or at the end of
--   it.
nearRegion :: Point -> Region -> Bool

-- | Returns if a region (1st arg) is included in another (2nd arg)
includedRegion :: Region -> Region -> Bool
fmapRegion :: (Point -> Point) -> Region -> Region

-- | Take the intersection of two regions
intersectRegion :: Region -> Region -> Region

-- | Take the union of two regions (including what is between them)
unionRegion :: Region -> Region -> Region
regionFirst :: Region -> Point
regionLast :: Region -> Point
regionsOverlap :: Bool -> Region -> Region -> Bool
instance Data.Binary.Class.Binary Yi.Region.Region
instance GHC.Internal.Generics.Generic Yi.Region.Region
instance GHC.Internal.Show.Show Yi.Region.Region

-- | This module defines a common interface for syntax-awareness.
--   
--   There have been many tens of wasted hours in this and lexer modules.
--   This note is to commemorate those who have fallen in battle.
module Yi.Syntax

-- | The main type of syntax highlighters. This record type combines all
--   the required functions, and is parametrized on the type of the
--   internal state.
data Highlighter cache syntax
SynHL :: cache -> (Scanner Point Char -> Point -> cache -> cache) -> (cache -> WindowRef -> syntax) -> (Map WindowRef Region -> cache -> cache) -> Highlighter cache syntax

-- | The start state for the highlighter.
[hlStartState] :: Highlighter cache syntax -> cache
[hlRun] :: Highlighter cache syntax -> Scanner Point Char -> Point -> cache -> cache
[hlGetTree] :: Highlighter cache syntax -> cache -> WindowRef -> syntax

-- | focus at a given point, and return the corresponding node. (hint --
--   the root can always be returned, at the cost of performance.)
[hlFocus] :: Highlighter cache syntax -> Map WindowRef Region -> cache -> cache
data Cache state result
data Scanner st a
Scanner :: st -> (st -> Point) -> a -> (st -> [(st, a)]) -> Scanner st a

-- | Initial state
[scanInit] :: Scanner st a -> st

-- | How far did the scanner look to produce this intermediate state? The
--   state can be reused as long as nothing changes before that point.
[scanLooked] :: Scanner st a -> st -> Point
[scanEmpty] :: Scanner st a -> a

-- | Running function returns a list of results and intermediate states.
--   Note: the state is the state before producing the result in the
--   second component.
[scanRun] :: Scanner st a -> st -> [(st, a)]
data ExtHL syntax
ExtHL :: Highlighter cache syntax -> ExtHL syntax
noHighlighter :: Highlighter () syntax

-- | This takes as input a scanner that returns the "full" result at each
--   element in the list; perhaps in a different form for the purpose of
--   incremental-lazy eval.
mkHighlighter :: Show state => (Scanner Point Char -> Scanner state result) -> Highlighter (Cache state result) result
skipScanner :: Int -> Scanner st a -> Scanner st a
emptyFileScan :: Scanner Point Char

-- | A point in a buffer
newtype Point
Point :: Int -> Point
[fromPoint] :: Point -> Int

-- | Size of a buffer region
newtype Size
Size :: Int -> Size
[fromSize] :: Size -> Int
type Length = Int
type Stroke = Span StyleName
data Span a
Span :: !Point -> !a -> !Point -> Span a
[spanBegin] :: Span a -> !Point
[spanContents] :: Span a -> !a
[spanEnd] :: Span a -> !Point
instance GHC.Internal.Data.Foldable.Foldable Yi.Syntax.Span
instance GHC.Internal.Base.Functor (Yi.Syntax.Scanner st)
instance GHC.Internal.Base.Functor Yi.Syntax.Span
instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Yi.Syntax.Span a)
instance GHC.Internal.Data.Traversable.Traversable Yi.Syntax.Span

-- | Utilities to turn a lexer generated by Alex into a Scanner that
--   can be used by Yi. Most lexers will use the types defined here. Some
--   things are exported for use by lexers themselves through the use of
--   YiLexerscommon.hsinc.
module Yi.Lexer.Alex
step :: forall l s t i f. Functor f => (TokenLexer l s t i -> f (TokenLexer l s t i)) -> Lexer l s t i -> f (Lexer l s t i)
type Action hlState token = IndexedStr -> hlState -> (hlState, token)

-- | Encode a Haskell String to a list of Word8 values, in UTF8 format.
utf8Encode :: Char -> [Word8]
tokenToStyle :: forall (l :: Type -> Type) s t i f. Functor f => ((t -> StyleName) -> f (t -> StyleName)) -> StyleLexer l s t i -> f (StyleLexer l s t i)
type Byte = Word8
type IndexedStr = [(Point, Char)]
type AlexInput = (Char, [Byte], IndexedStr)

-- | Lexer state
data AlexState lexerState
AlexState :: lexerState -> !Point -> !Posn -> AlexState lexerState
[stLexer] :: AlexState lexerState -> lexerState
[lookedOffset] :: AlexState lexerState -> !Point
[stPosn] :: AlexState lexerState -> !Posn
data Posn
Posn :: !Point -> !Int -> !Int -> Posn
[posnOfs] :: Posn -> !Point
[posnLine] :: Posn -> !Int
[posnCol] :: Posn -> !Int
data Tok t
Tok :: t -> Size -> Posn -> Tok t
[tokT] :: Tok t -> t
[tokLen] :: Tok t -> Size
[tokPosn] :: Tok t -> Posn
tokToSpan :: Tok t -> Span t
tokFromT :: t -> Tok t
startPosn :: Posn
tokBegin :: Tok t -> Point
tokEnd :: Tok t -> Point
moveStr :: Posn -> IndexedStr -> Posn
moveCh :: Posn -> Char -> Posn
alexGetChar :: AlexInput -> Maybe (Char, AlexInput)
alexGetByte :: AlexInput -> Maybe (Word8, AlexInput)
alexCollectChar :: AlexInput -> [Char]
alexInputPrevChar :: AlexInput -> Char

-- | Return a constant token
actionConst :: token -> Action lexState token

-- | Return a constant token, and modify the lexer state
actionAndModify :: (lexState -> lexState) -> token -> Action lexState token

-- | Convert the parsed string into a token, and also modify the lexer
--   state
actionStringAndModify :: (s -> s) -> (String -> token) -> Action s token

-- | Convert the parsed string into a token
actionStringConst :: (String -> token) -> Action lexState token
type ASI s = (AlexState s, AlexInput)

-- | Function to (possibly) lex a single token and give us the remaining
--   input.
type TokenLexer (l :: Type -> Type) s t i = (l s, i) -> Maybe (t, (l s, i))

-- | Handy alias
type CharScanner = Scanner Point Char

-- | Generalises lexers. This allows us to easily use lexers which don't
--   want to be cornered into the types we have predefined here and use in
--   common.hsinc.
data Lexer (l :: Type -> Type) s t i
Lexer :: TokenLexer l s t i -> (s -> Point -> Posn -> l s) -> (Char -> [(Point, Char)] -> i) -> (l s -> Point) -> (l s -> Posn) -> t -> s -> Lexer (l :: Type -> Type) s t i
[_step] :: Lexer (l :: Type -> Type) s t i -> TokenLexer l s t i
[_starting] :: Lexer (l :: Type -> Type) s t i -> s -> Point -> Posn -> l s
[_withChars] :: Lexer (l :: Type -> Type) s t i -> Char -> [(Point, Char)] -> i
[_looked] :: Lexer (l :: Type -> Type) s t i -> l s -> Point
[_statePosn] :: Lexer (l :: Type -> Type) s t i -> l s -> Posn
[_lexEmpty] :: Lexer (l :: Type -> Type) s t i -> t
[_startingState] :: Lexer (l :: Type -> Type) s t i -> s

-- | Just like Lexer but also knows how to turn its tokens into
--   StyleNames.
data StyleLexer (l :: Type -> Type) s t i
StyleLexer :: (t -> StyleName) -> Lexer l s (Tok t) i -> StyleLexer (l :: Type -> Type) s t i
[_tokenToStyle] :: StyleLexer (l :: Type -> Type) s t i -> t -> StyleName
[_styleLexer] :: StyleLexer (l :: Type -> Type) s t i -> Lexer l s (Tok t) i

-- | StyleLexer over ASI.
type StyleLexerASI s t = StyleLexer AlexState s t AlexInput

-- | Defines a Lexer for ASI. This exists to make using the
--   new lexScanner easier if you're using ASI as all our
--   lexers do today, 23-08-2014.
commonLexer :: (ASI s -> Maybe (Tok t, ASI s)) -> s -> Lexer AlexState s (Tok t) AlexInput

-- | Combine a character scanner with a lexer to produce a token scanner.
--   May be used together with mkHighlighter to produce a
--   Highlighter, or with linearSyntaxMode to produce a
--   Mode.
lexScanner :: Lexer l s t i -> CharScanner -> Scanner (l s) t

-- | unfold lexer into a function that returns a stream of (state, token)
unfoldLexer :: ((state, input) -> Maybe (token, (state, input))) -> (state, input) -> [(state, token)]
posnColA :: Lens' Posn Int
posnLineA :: Lens' Posn Int
posnOfsA :: Lens' Posn Point
tokLenA :: forall t f. Functor f => (Size -> f Size) -> Tok t -> f (Tok t)
tokPosnA :: forall t f. Functor f => (Posn -> f Posn) -> Tok t -> f (Tok t)
tokTA :: forall t1 t2 f. Functor f => (t1 -> f t2) -> Tok t1 -> f (Tok t2)
lexEmpty :: forall (l :: Type -> Type) s t i f. Functor f => (t -> f t) -> Lexer l s t i -> f (Lexer l s t i)
looked :: forall l s t i f. Functor f => ((l s -> Point) -> f (l s -> Point)) -> Lexer l s t i -> f (Lexer l s t i)
starting :: forall l s t i f. Functor f => ((s -> Point -> Posn -> l s) -> f (s -> Point -> Posn -> l s)) -> Lexer l s t i -> f (Lexer l s t i)
startingState :: forall (l :: Type -> Type) s t i f. Functor f => (s -> f s) -> Lexer l s t i -> f (Lexer l s t i)
statePosn :: forall l s t i f. Functor f => ((l s -> Posn) -> f (l s -> Posn)) -> Lexer l s t i -> f (Lexer l s t i)
withChars :: forall (l :: Type -> Type) s t i f. Functor f => ((Char -> [(Point, Char)] -> i) -> f (Char -> [(Point, Char)] -> i)) -> Lexer l s t i -> f (Lexer l s t i)
styleLexer :: forall (l1 :: Type -> Type) s1 t i1 (l2 :: Type -> Type) s2 i2 f. Functor f => (Lexer l1 s1 (Tok t) i1 -> f (Lexer l2 s2 (Tok t) i2)) -> StyleLexer l1 s1 t i1 -> f (StyleLexer l2 s2 t i2)
(+~) :: SemiNum absolute relative => absolute -> relative -> absolute
(~-) :: SemiNum absolute relative => absolute -> absolute -> relative

-- | Size of a buffer region
newtype Size
Size :: Int -> Size
[fromSize] :: Size -> Int
type Stroke = Span StyleName
instance GHC.Classes.Eq Yi.Lexer.Alex.Posn
instance GHC.Classes.Eq (Yi.Lexer.Alex.Tok a)
instance GHC.Internal.Base.Functor Yi.Lexer.Alex.Tok
instance GHC.Internal.Ix.Ix Yi.Lexer.Alex.Posn
instance GHC.Classes.Ord Yi.Lexer.Alex.Posn
instance GHC.Internal.Show.Show lexerState => GHC.Internal.Show.Show (Yi.Lexer.Alex.AlexState lexerState)
instance GHC.Internal.Show.Show Yi.Lexer.Alex.Posn
instance GHC.Internal.Show.Show t => GHC.Internal.Show.Show (Yi.Lexer.Alex.Tok t)

module Yi.Regex
data SearchOption

-- | Compile for matching that ignores char case
IgnoreCase :: SearchOption

-- | Compile for newline-insensitive matching
NoNewLine :: SearchOption

-- | Treat the input not as a regex but as a literal string to search for.
QuoteRegex :: SearchOption
makeSearchOptsM :: [SearchOption] -> String -> Either String SearchExp
data SearchExp
SearchExp :: String -> Regex -> Regex -> [SearchOption] -> SearchExp
[seInput] :: SearchExp -> String
[seCompiled] :: SearchExp -> Regex
[seBackCompiled] :: SearchExp -> Regex
[seOptions] :: SearchExp -> [SearchOption]
searchString :: SearchExp -> String
searchRegex :: Direction -> SearchExp -> Regex
emptySearch :: SearchExp

-- | The regular expression that matches nothing.
emptyRegex :: Regex

-- | Return an escaped (for parseRegex use) version of the string.
regexEscapeString :: String -> String

-- | Reverse a pattern. Note that the submatches will be reversed as well.
reversePattern :: (Pattern, (t, DoPa)) -> (Pattern, (t, DoPa))

-- | Control whether the pattern is multiline or case-sensitive like
--   Text.Regex and whether to capture the subgroups (\1, \2, etc).
--   Controls enabling extra anchor syntax.
data CompOption
CompOption :: Bool -> Bool -> Bool -> Bool -> Bool -> CompOption

-- | True in blankCompOpt and defaultCompOpt.
[caseSensitive] :: CompOption -> Bool

-- | False in blankCompOpt, True in defaultCompOpt. Compile
--   for newline-sensitive matching.
--   
--   From regexp man page: "By default, newline is a completely
--   ordinary character with no special meaning in either REs or strings.
--   With this flag, inverted bracket expressions [^ and
--   . never match newline, a ^ anchor matches the null
--   string after any newline in the string in addition to its normal
--   function, and the $ anchor matches the null string before any
--   newline in the string in addition to its normal function."
[multiline] :: CompOption -> Bool

-- | True (and therefore right associative) in blankCompOpt and
--   defaultCompOpt.
[rightAssoc] :: CompOption -> Bool

-- | False in blankCompOpt, True in defaultCompOpt. Enables
--   the extended non-POSIX syntax described in Text.Regex.TDFA
--   haddock documentation.
[newSyntax] :: CompOption -> Bool

-- | False by default. This is POSIX correct but it takes space and is
--   slower. Setting this to True will improve performance, and should be
--   done if you plan to set the captureGroups ExecOption to
--   False.
[lastStarGreedy] :: CompOption -> Bool

-- | Used in results of RegexContext instances.
newtype AllTextSubmatches (f :: Type -> Type) b
AllTextSubmatches :: f b -> AllTextSubmatches (f :: Type -> Type) b
[getAllTextSubmatches] :: AllTextSubmatches (f :: Type -> Type) b -> f b

-- | RegexLike is parametrized on a regular expression type and a source
--   type to run the matching on.
--   
--   There are default implementations: matchTest and
--   matchOnceText use matchOnce; matchCount and
--   matchAllText use matchAll. Conversely, matchOnce
--   uses matchOnceText and matchAll uses
--   matchAllText. So a minimal complete instance need to provide at
--   least (matchOnce or matchOnceText) and (matchAll
--   or matchAllText). Additional definitions are often provided
--   where they will increase efficiency.
--   
--   
--   [ c | let notVowel = makeRegex "[^aeiou]" :: Regex, c <- ['a'..'z'], matchTest notVowel [c]  ]
--   
--   "bcdfghjklmnpqrstvwxyz"
--   
--   
--   The strictness of these functions is instance dependent.
class Extract source => RegexLike regex source

-- | matchAll returns a list of matches. The matches are in order
--   and do not overlap. If any match succeeds but has 0 length then this
--   will be the last match in the list.
matchAll :: RegexLike regex source => regex -> source -> [MatchArray]

-- | This can return a tuple of three items: the source before the match,
--   an array of the match and captured substrings (with their indices),
--   and the source after the match.
matchOnceText :: RegexLike regex source => regex -> source -> Maybe (source, MatchText source, source)

-- | Use the defaultCompOpt and defaultExecOpt.
makeRegex :: RegexMaker regex compOpt execOpt source => source -> regex

-- | Specify your own options, reporting errors with fail
makeRegexOptsM :: (RegexMaker regex compOpt execOpt source, MonadFail m) => compOpt -> execOpt -> source -> m regex

-- | Reasonable options (extended, caseSensitive, multiline regex).
defaultCompOpt :: RegexOptions regex compOpt execOpt => compOpt

-- | Reasonable options (extended, caseSensitive, multiline regex).
defaultExecOpt :: RegexOptions regex compOpt execOpt => execOpt

-- | The TDFA backend specific Regex type, used by this module's
--   RegexOptions and RegexMaker.
data Regex

-- | This is the pure functional matching operator. If the target cannot be
--   produced then some empty result will be returned. If there is an error
--   in processing, then error will be called.
(=~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext Regex source1 target) => source1 -> source -> target
instance Data.Binary.Class.Binary Yi.Regex.SearchExp
instance Data.Binary.Class.Binary Yi.Regex.SearchOption
instance GHC.Classes.Eq Yi.Regex.SearchOption
instance GHC.Internal.Generics.Generic Yi.Regex.SearchOption

module Yi.Lexer.Compilation
lexer :: StyleLexerASI HlState Token
data Token
Report :: String -> Int -> Int -> String -> Token
Text :: String -> Token
instance GHC.Internal.Show.Show Yi.Lexer.Compilation.Token
