-- 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 matches<i>paren matches</i>other 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 <a>UIStyle</a>. Typically, style
--   names will be <a>Style</a>-valued field names of <a>UIStyle</a>.
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.Show.Show Yi.Style.Color
instance GHC.Classes.Ord Yi.Style.Color
instance GHC.Classes.Eq Yi.Style.Color
instance GHC.Show.Show Yi.Style.Attributes
instance GHC.Classes.Ord Yi.Style.Attributes
instance GHC.Classes.Eq Yi.Style.Attributes

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 <a>nub</a>, 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 <a>fromList</a> to arbitrary foldables.
mapFromFoldable :: (Foldable t, Ord k) => t (k, a) -> Map k a

-- | Alternative to groupBy.
--   
--   <pre>
--   groupBy' (\a b -&gt; abs (a - b) &lt;= 1) [1,2,3] = [[1,2,3]]
--   </pre>
--   
--   whereas
--   
--   <pre>
--   groupBy (\a b -&gt; abs (a - b) &lt;= 1) [1,2,3] = [[1,2],[3]]
--   </pre>
--   
--   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.
--   
--   <pre>
--   P(xs) === all (isPrefixOf (commonPrefix xs)) xs
--   length s &gt; length (commonPrefix xs) --&gt; not (all (isPrefixOf s) xs)
--   </pre>
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]

-- | <tt>direction</tt> is in the same style of <a>maybe</a> or
--   <a>either</a> 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 GHC.Generics.Generic Yi.Buffer.Basic.Direction
instance GHC.Enum.Enum Yi.Buffer.Basic.Direction
instance GHC.Enum.Bounded Yi.Buffer.Basic.Direction
instance GHC.Show.Show Yi.Buffer.Basic.Direction
instance GHC.Classes.Ord Yi.Buffer.Basic.Direction
instance GHC.Classes.Eq Yi.Buffer.Basic.Direction
instance Data.Binary.Class.Binary Yi.Buffer.Basic.Mark
instance GHC.Show.Show Yi.Buffer.Basic.Mark
instance GHC.Classes.Ord Yi.Buffer.Basic.Mark
instance GHC.Classes.Eq Yi.Buffer.Basic.Mark
instance GHC.Num.Num Yi.Buffer.Basic.BufferRef
instance Data.Binary.Class.Binary Yi.Buffer.Basic.BufferRef
instance GHC.Classes.Ord Yi.Buffer.Basic.BufferRef
instance GHC.Classes.Eq Yi.Buffer.Basic.BufferRef
instance GHC.Real.Integral Yi.Buffer.Basic.Point
instance GHC.Real.Real Yi.Buffer.Basic.Point
instance GHC.Num.Num Yi.Buffer.Basic.Point
instance GHC.Ix.Ix Yi.Buffer.Basic.Point
instance Data.Binary.Class.Binary Yi.Buffer.Basic.Point
instance GHC.Enum.Bounded Yi.Buffer.Basic.Point
instance GHC.Enum.Enum Yi.Buffer.Basic.Point
instance GHC.Classes.Ord Yi.Buffer.Basic.Point
instance GHC.Classes.Eq Yi.Buffer.Basic.Point
instance Data.Binary.Class.Binary Yi.Buffer.Basic.Size
instance GHC.Real.Integral Yi.Buffer.Basic.Size
instance GHC.Real.Real Yi.Buffer.Basic.Size
instance GHC.Enum.Enum Yi.Buffer.Basic.Size
instance GHC.Num.Num Yi.Buffer.Basic.Size
instance GHC.Classes.Ord Yi.Buffer.Basic.Size
instance GHC.Classes.Eq Yi.Buffer.Basic.Size
instance GHC.Show.Show Yi.Buffer.Basic.Size
instance Data.Binary.Class.Binary Yi.Buffer.Basic.WindowRef
instance GHC.Show.Show Yi.Buffer.Basic.WindowRef
instance GHC.Enum.Enum Yi.Buffer.Basic.WindowRef
instance GHC.Classes.Ord Yi.Buffer.Basic.WindowRef
instance GHC.Classes.Eq Yi.Buffer.Basic.WindowRef
instance Data.Default.Internal.Default Yi.Buffer.Basic.WindowRef
instance Yi.Utils.SemiNum Yi.Buffer.Basic.Point Yi.Buffer.Basic.Size
instance GHC.Show.Show Yi.Buffer.Basic.Point
instance GHC.Show.Show Yi.Buffer.Basic.BufferRef
instance Data.Binary.Class.Binary Yi.Buffer.Basic.Direction


-- | 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 &lt;= 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 GHC.Generics.Generic Yi.Region.Region
instance Data.Binary.Class.Binary Yi.Region.Region
instance GHC.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 <i>before</i> 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 :: forall state result. 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 Data.Traversable.Traversable Yi.Syntax.Span
instance Data.Foldable.Foldable Yi.Syntax.Span
instance GHC.Base.Functor Yi.Syntax.Span
instance GHC.Show.Show a => GHC.Show.Show (Yi.Syntax.Span a)
instance GHC.Base.Functor (Yi.Syntax.Scanner st)


-- | Utilities to turn a lexer generated by Alex into a <a>Scanner</a> 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
--   <tt>Yi<i>Lexers</i>common.hsinc</tt>.
module Yi.Lexer.Alex
type Action hlState token = IndexedStr -> hlState -> (hlState, token)
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
type ASI s = (AlexState s, AlexInput)

-- | Function to (possibly) lex a single token and give us the remaining
--   input.
type TokenLexer l 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
--   <tt>common.hsinc</tt>.
data Lexer l 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 s t i
[_step] :: Lexer l s t i -> TokenLexer l s t i
[_starting] :: Lexer l s t i -> s -> Point -> Posn -> l s
[_withChars] :: Lexer l s t i -> Char -> [(Point, Char)] -> i
[_looked] :: Lexer l s t i -> l s -> Point
[_statePosn] :: Lexer l s t i -> l s -> Posn
[_lexEmpty] :: Lexer l s t i -> t
[_startingState] :: Lexer l s t i -> s

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

-- | <a>StyleLexer</a> over <a>ASI</a>.
type StyleLexerASI s t = StyleLexer AlexState s t AlexInput
step :: forall l_anOL s_anOM t_anON i_anOO. Lens' (Lexer l_anOL s_anOM t_anON i_anOO) (TokenLexer l_anOL s_anOM t_anON i_anOO)

-- | Encode a Haskell String to a list of Word8 values, in UTF8 format.
utf8Encode :: Char -> [Word8]
tokenToStyle :: forall l_anOH s_anOI t_anOJ i_anOK. Lens' (StyleLexer l_anOH s_anOI t_anOJ i_anOK) (t_anOJ -> StyleName)
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

-- | Defines a <a>Lexer</a> for <a>ASI</a>. This exists to make using the
--   new <a>lexScanner</a> easier if you're using <a>ASI</a> 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 <tt>mkHighlighter</tt> to produce a
--   <a>Highlighter</a>, or with <tt>linearSyntaxMode</tt> to produce a
--   <tt>Mode</tt>.
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_anOU. Lens' (Tok t_anOU) Size
tokPosnA :: forall t_anOU. Lens' (Tok t_anOU) Posn
tokTA :: forall t_anOU t_aohM. Lens (Tok t_anOU) (Tok t_aohM) t_anOU t_aohM
lexEmpty :: forall l_anOL s_anOM t_anON i_anOO. Lens' (Lexer l_anOL s_anOM t_anON i_anOO) t_anON
looked :: forall l_anOL s_anOM t_anON i_anOO. Lens' (Lexer l_anOL s_anOM t_anON i_anOO) (l_anOL s_anOM -> Point)
starting :: forall l_anOL s_anOM t_anON i_anOO. Lens' (Lexer l_anOL s_anOM t_anON i_anOO) (s_anOM -> Point -> Posn -> l_anOL s_anOM)
startingState :: forall l_anOL s_anOM t_anON i_anOO. Lens' (Lexer l_anOL s_anOM t_anON i_anOO) s_anOM
statePosn :: forall l_anOL s_anOM t_anON i_anOO. Lens' (Lexer l_anOL s_anOM t_anON i_anOO) (l_anOL s_anOM -> Posn)
withChars :: forall l_anOL s_anOM t_anON i_anOO. Lens' (Lexer l_anOL s_anOM t_anON i_anOO) (Char -> [(Point, Char)] -> i_anOO)
styleLexer :: forall l_anOH s_anOI t_anOJ i_anOK l_aorI s_aorJ i_aorK. Lens (StyleLexer l_anOH s_anOI t_anOJ i_anOK) (StyleLexer l_aorI s_aorJ t_anOJ i_aorK) (Lexer l_anOH s_anOI (Tok t_anOJ) i_anOK) (Lexer l_aorI s_aorJ (Tok t_anOJ) i_aorK)
(+~) :: 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.Ix.Ix Yi.Lexer.Alex.Posn
instance GHC.Classes.Eq Yi.Lexer.Alex.Posn
instance GHC.Base.Functor Yi.Lexer.Alex.Tok
instance GHC.Show.Show lexerState => GHC.Show.Show (Yi.Lexer.Alex.AlexState lexerState)
instance GHC.Classes.Eq (Yi.Lexer.Alex.Tok a)
instance GHC.Show.Show t => GHC.Show.Show (Yi.Lexer.Alex.Tok t)
instance GHC.Classes.Ord Yi.Lexer.Alex.Posn
instance GHC.Show.Show Yi.Lexer.Alex.Posn

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))

-- | Used in results of <a>RegexContext</a> 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: <a>matchTest</a> and
--   <a>matchOnceText</a> use <a>matchOnce</a>; <a>matchCount</a> and
--   <a>matchAllText</a> use <a>matchAll</a>. Conversely, <a>matchOnce</a>
--   uses <a>matchOnceText</a> and <a>matchAll</a> uses
--   <a>matchAllText</a>. So a minimal complete instance need to provide at
--   least (<a>matchOnce</a> or <a>matchOnceText</a>) and (<a>matchAll</a>
--   or <a>matchAllText</a>). Additional definitions are often provided
--   where they will increase efficiency.
--   
--   <pre>
--   [ c | let notVowel = makeRegex "[^aeiou]" :: Regex, c &lt;- ['a'..'z'], matchTest notVowel [c]  ]
--   
--   "bcdfghjklmnpqrstvwxyz"
--   </pre>
--   
--   The strictness of these functions is instance dependent.
class Extract source => RegexLike regex source

-- | <tt>matchAll</tt> 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)

-- | The TDFA backend specific <a>Regex</a> type, used by this module's
--   <a>RegexOptions</a> and <tt>RegexMaker</tt>.
data () => Regex

-- | 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 <a>blankCompOpt</a> and <a>defaultCompOpt</a>.
[caseSensitive] :: CompOption -> Bool

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

-- | False in <a>blankCompOpt</a>, True in <a>defaultCompOpt</a>. Enables
--   the extended non-POSIX syntax described in <a>Text.Regex.TDFA</a>
--   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 <a>captureGroups</a> <a>ExecOption</a> to
--   False.
[lastStarGreedy] :: CompOption -> Bool

-- | Use the <a>defaultCompOpt</a> and <a>defaultExecOpt</a>.
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

-- | 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 <a>error</a> will be called.
(=~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext Regex source1 target) => source1 -> source -> target
instance GHC.Generics.Generic Yi.Regex.SearchOption
instance GHC.Classes.Eq Yi.Regex.SearchOption
instance Data.Binary.Class.Binary Yi.Regex.SearchExp
instance Data.Binary.Class.Binary Yi.Regex.SearchOption

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