-- 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.13.2


-- | 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.Base.HashMap k v)


-- | 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
--   forground 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.Attributes
instance GHC.Classes.Ord Yi.Style.Attributes
instance GHC.Classes.Eq Yi.Style.Attributes
instance GHC.Show.Show Yi.Style.Color
instance GHC.Classes.Ord Yi.Style.Color
instance GHC.Classes.Eq 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


-- | 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 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.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 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.Arr.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 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 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.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.Direction
instance GHC.Show.Show Yi.Buffer.Basic.BufferRef
instance GHC.Show.Show Yi.Buffer.Basic.Point
instance Yi.Utils.SemiNum Yi.Buffer.Basic.Point Yi.Buffer.Basic.Size
instance Data.Default.Class.Default Yi.Buffer.Basic.WindowRef

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))
instance GHC.Generics.Generic Yi.Regex.SearchOption
instance GHC.Classes.Eq Yi.Regex.SearchOption
instance Data.Binary.Class.Binary Yi.Regex.SearchOption
instance Data.Binary.Class.Binary Yi.Regex.SearchExp


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

-- | Encode a Haskell String to a list of Word8 values, in UTF8 format.
utf8Encode :: Char -> [Word8]
type Byte = Word8
type IndexedStr = [(Point, Char)]
type AlexInput = (Char, [Byte], IndexedStr)
type Action hlState token = IndexedStr -> hlState -> (hlState, token)

-- | Lexer state
data AlexState lexerState
AlexState :: lexerState -> !Point -> !Posn -> AlexState lexerState
[stLexer] :: AlexState lexerState -> lexerState
[lookedOffset] :: AlexState lexerState -> !Point
[stPosn] :: AlexState lexerState -> !Posn
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
tokBegin :: Tok t -> Point
tokEnd :: Tok t -> Point
data Posn
Posn :: !Point -> !Int -> !Int -> Posn
[posnOfs] :: Posn -> !Point
[posnLine] :: Posn -> !Int
[posnCol] :: Posn -> !Int
startPosn :: Posn
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 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

-- | 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)]
posnOfsA :: Lens' Posn Point
posnLineA :: Lens' Posn Int
posnColA :: Lens' Posn Int
tokTA :: forall t_axbv t_axyh. Lens (Tok t_axbv) (Tok t_axyh) t_axbv t_axyh
tokPosnA :: forall t_axbv. Lens' (Tok t_axbv) Posn
tokLenA :: forall t_axbv. Lens' (Tok t_axbv) Size
withChars :: forall l_axbm s_axbn t_axbo i_axbp. Lens' (Lexer l_axbm s_axbn t_axbo i_axbp) (Char -> [(Point, Char)] -> i_axbp)
step :: forall l_axbm s_axbn t_axbo i_axbp. Lens' (Lexer l_axbm s_axbn t_axbo i_axbp) (TokenLexer l_axbm s_axbn t_axbo i_axbp)
statePosn :: forall l_axbm s_axbn t_axbo i_axbp. Lens' (Lexer l_axbm s_axbn t_axbo i_axbp) (l_axbm s_axbn -> Posn)
startingState :: forall l_axbm s_axbn t_axbo i_axbp. Lens' (Lexer l_axbm s_axbn t_axbo i_axbp) s_axbn
starting :: forall l_axbm s_axbn t_axbo i_axbp. Lens' (Lexer l_axbm s_axbn t_axbo i_axbp) (s_axbn -> Point -> Posn -> l_axbm s_axbn)
looked :: forall l_axbm s_axbn t_axbo i_axbp. Lens' (Lexer l_axbm s_axbn t_axbo i_axbp) (l_axbm s_axbn -> Point)
lexEmpty :: forall l_axbm s_axbn t_axbo i_axbp. Lens' (Lexer l_axbm s_axbn t_axbo i_axbp) t_axbo
tokenToStyle :: forall l_axbi s_axbj t_axbk i_axbl. Lens' (StyleLexer l_axbi s_axbj t_axbk i_axbl) (t_axbk -> StyleName)
styleLexer :: forall l_axbi s_axbj t_axbk i_axbl l_axFt s_axFu i_axFv. Lens (StyleLexer l_axbi s_axbj t_axbk i_axbl) (StyleLexer l_axFt s_axFu t_axbk i_axFv) (Lexer l_axbi s_axbj (Tok t_axbk) i_axbl) (Lexer l_axFt s_axFu (Tok t_axbk) i_axFv)
(+~) :: 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.Show.Show lexerState => GHC.Show.Show (Yi.Lexer.Alex.AlexState lexerState)
instance GHC.Base.Functor Yi.Lexer.Alex.Tok
instance GHC.Arr.Ix Yi.Lexer.Alex.Posn
instance GHC.Classes.Eq Yi.Lexer.Alex.Posn
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.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
instance GHC.Base.Functor Yi.Lexer.Compilation.AlexLastAcc