    {-| Position information for syntax. Crucial for giving good error messages.
    -}

    module Agda.Syntax.Position
      ( -- * Positions
        Position
      , PositionWithoutFile
      , Position'(..)
      , SrcFile
      , positionInvariant
      , startPos
      , movePos
      , movePosByString
      , backupPos
      , startPos'

        -- * Intervals
      , Interval
      , IntervalWithoutFile
      , Interval'(..)
      , intervalInvariant
      , posToInterval
      , getIntervalFile
      , iLength
      , fuseIntervals
      , setIntervalFile

        -- * Ranges
      , Range
      , Range'(..)
      , rangeInvariant
      , consecutiveAndSeparated
      , intervalsToRange
      , intervalToRange
      , rangeIntervals
      , rangeFile
      , rightMargin
      , noRange
      , posToRange, posToRange'
      , rStart, rStart'
      , rEnd, rEnd'
      , rangeToInterval
      , rangeToIntervalWithFile
      , continuous
      , continuousPerLine
      , PrintRange(..)
      , HasRange(..)
      , SetRange(..)
      , KillRange(..)
      , KillRangeT
      , killRangeMap
      , killRange1, killRange2, killRange3, killRange4, killRange5, killRange6, killRange7
      , killRange8, killRange9, killRange10, killRange11, killRange12, killRange13, killRange14
      , killRange15, killRange16, killRange17, killRange18, killRange19
      , withRangeOf
      , fuseRange
      , fuseRanges
      , beginningOf
      , beginningOfFile
      , interleaveRanges
      ) where

    import Prelude hiding ( null )

    import Control.DeepSeq
    import Control.Monad.Writer (runWriter, tell)

    import qualified Data.Foldable as Fold
    import Data.Function
    import Data.Int
    import Data.List hiding (null)
    import Data.Map (Map)
    import qualified Data.Map as Map
    import Data.Set (Set)
    import qualified Data.Set as Set
    import Data.Data (Data)
    import Data.Sequence (Seq)
    import qualified Data.Sequence as Seq
    import Data.Semigroup (Semigroup(..))
    import Data.Void

    import GHC.Generics (Generic)

    import Agda.Utils.FileName
    import Agda.Utils.List
    import Agda.Utils.List1 (List1)
    import Agda.Utils.List2 (List2)
    import qualified Agda.Utils.Maybe.Strict as Strict
    import Agda.Utils.Null
    import Agda.Utils.Permutation
    import Agda.Utils.Pretty

    import Agda.Utils.Impossible

    {--------------------------------------------------------------------------
        Types and classes
     --------------------------------------------------------------------------}

    -- | Represents a point in the input.
    --
    -- If two positions have the same 'srcFile' and 'posPos' components,
    -- then the final two components should be the same as well, but since
    -- this can be hard to enforce the program should not rely too much on
    -- the last two components; they are mainly there to improve error
    -- messages for the user.
    --
    -- Note the invariant which positions have to satisfy: 'positionInvariant'.
    data Position' a = Pn
      { forall a. Position' a -> a
    srcFile :: !a
        -- ^ File.
      , forall a. Position' a -> Int32
    posPos  :: !Int32
        -- ^ Position, counting from 1.
      , forall a. Position' a -> Int32
    posLine :: !Int32
        -- ^ Line number, counting from 1.
      , forall a. Position' a -> Int32
    posCol  :: !Int32
        -- ^ Column number, counting from 1.
      }
      deriving (Int -> Position' a -> ShowS
    [Position' a] -> ShowS
    Position' a -> String
    (Int -> Position' a -> ShowS)
    -> (Position' a -> String)
    -> ([Position' a] -> ShowS)
    -> Show (Position' a)
    forall a. Show a => Int -> Position' a -> ShowS
    forall a. Show a => [Position' a] -> ShowS
    forall a. Show a => Position' a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Position' a] -> ShowS
    $cshowList :: forall a. Show a => [Position' a] -> ShowS
    show :: Position' a -> String
    $cshow :: forall a. Show a => Position' a -> String
    showsPrec :: Int -> Position' a -> ShowS
    $cshowsPrec :: forall a. Show a => Int -> Position' a -> ShowS
    Show, Typeable (Position' a)
    Typeable (Position' a)
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Position' a -> c (Position' a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Position' a))
    -> (Position' a -> Constr)
    -> (Position' a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Position' a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Position' a)))
    -> ((forall b. Data b => b -> b) -> Position' a -> Position' a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Position' a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Position' a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Position' a -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Position' a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Position' a -> m (Position' a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Position' a -> m (Position' a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Position' a -> m (Position' a))
    -> Data (Position' a)
    Position' a -> DataType
    Position' a -> Constr
    (forall b. Data b => b -> b) -> Position' a -> Position' a
    forall {a}. Data a => Typeable (Position' a)
    forall a. Data a => Position' a -> DataType
    forall a. Data a => Position' a -> Constr
    forall a.
    Data a =>
    (forall b. Data b => b -> b) -> Position' a -> Position' a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Position' a -> u
    forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> Position' a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Position' a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Position' a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Position' a -> m (Position' a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Position' a -> m (Position' a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Position' a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Position' a -> c (Position' a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Position' a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Position' a))
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Position' a -> u
    forall u. (forall d. Data d => d -> u) -> Position' a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Position' a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Position' a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Position' a -> m (Position' a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Position' a -> m (Position' a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Position' a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Position' a -> c (Position' a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Position' a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Position' a))
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Position' a -> m (Position' a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Position' a -> m (Position' a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Position' a -> m (Position' a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Position' a -> m (Position' a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Position' a -> m (Position' a)
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Position' a -> m (Position' a)
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Position' a -> u
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Position' a -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Position' a -> [u]
    $cgmapQ :: forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> Position' a -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Position' a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Position' a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Position' a -> r
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Position' a -> r
    gmapT :: (forall b. Data b => b -> b) -> Position' a -> Position' a
    $cgmapT :: forall a.
    Data a =>
    (forall b. Data b => b -> b) -> Position' a -> Position' a
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Position' a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Position' a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Position' a))
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Position' a))
    dataTypeOf :: Position' a -> DataType
    $cdataTypeOf :: forall a. Data a => Position' a -> DataType
    toConstr :: Position' a -> Constr
    $ctoConstr :: forall a. Data a => Position' a -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Position' a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Position' a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Position' a -> c (Position' a)
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Position' a -> c (Position' a)
    Data, (forall a b. (a -> b) -> Position' a -> Position' b)
    -> (forall a b. a -> Position' b -> Position' a)
    -> Functor Position'
    forall a b. a -> Position' b -> Position' a
    forall a b. (a -> b) -> Position' a -> Position' b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> Position' b -> Position' a
    $c<$ :: forall a b. a -> Position' b -> Position' a
    fmap :: forall a b. (a -> b) -> Position' a -> Position' b
    $cfmap :: forall a b. (a -> b) -> Position' a -> Position' b
    Functor, (forall m. Monoid m => Position' m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Position' a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Position' a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Position' a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Position' a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Position' a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Position' a -> b)
    -> (forall a. (a -> a -> a) -> Position' a -> a)
    -> (forall a. (a -> a -> a) -> Position' a -> a)
    -> (forall a. Position' a -> [a])
    -> (forall a. Position' a -> Bool)
    -> (forall a. Position' a -> Int)
    -> (forall a. Eq a => a -> Position' a -> Bool)
    -> (forall a. Ord a => Position' a -> a)
    -> (forall a. Ord a => Position' a -> a)
    -> (forall a. Num a => Position' a -> a)
    -> (forall a. Num a => Position' a -> a)
    -> Foldable Position'
    forall a. Eq a => a -> Position' a -> Bool
    forall a. Num a => Position' a -> a
    forall a. Ord a => Position' a -> a
    forall m. Monoid m => Position' m -> m
    forall a. Position' a -> Bool
    forall a. Position' a -> Int
    forall a. Position' a -> [a]
    forall a. (a -> a -> a) -> Position' a -> a
    forall m a. Monoid m => (a -> m) -> Position' a -> m
    forall b a. (b -> a -> b) -> b -> Position' a -> b
    forall a b. (a -> b -> b) -> b -> Position' a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    product :: forall a. Num a => Position' a -> a
    $cproduct :: forall a. Num a => Position' a -> a
    sum :: forall a. Num a => Position' a -> a
    $csum :: forall a. Num a => Position' a -> a
    minimum :: forall a. Ord a => Position' a -> a
    $cminimum :: forall a. Ord a => Position' a -> a
    maximum :: forall a. Ord a => Position' a -> a
    $cmaximum :: forall a. Ord a => Position' a -> a
    elem :: forall a. Eq a => a -> Position' a -> Bool
    $celem :: forall a. Eq a => a -> Position' a -> Bool
    length :: forall a. Position' a -> Int
    $clength :: forall a. Position' a -> Int
    null :: forall a. Position' a -> Bool
    $cnull :: forall a. Position' a -> Bool
    toList :: forall a. Position' a -> [a]
    $ctoList :: forall a. Position' a -> [a]
    foldl1 :: forall a. (a -> a -> a) -> Position' a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Position' a -> a
    foldr1 :: forall a. (a -> a -> a) -> Position' a -> a
    $cfoldr1 :: forall a. (a -> a -> a) -> Position' a -> a
    foldl' :: forall b a. (b -> a -> b) -> b -> Position' a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Position' a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Position' a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Position' a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Position' a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Position' a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Position' a -> b
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Position' a -> b
    foldMap' :: forall m a. Monoid m => (a -> m) -> Position' a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Position' a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Position' a -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Position' a -> m
    fold :: forall m. Monoid m => Position' m -> m
    $cfold :: forall m. Monoid m => Position' m -> m
    Foldable, Functor Position'
    Foldable Position'
    Functor Position'
    -> Foldable Position'
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> Position' a -> f (Position' b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Position' (f a) -> f (Position' a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Position' a -> m (Position' b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Position' (m a) -> m (Position' a))
    -> Traversable Position'
    forall (t :: * -> *).
    Functor t
    -> Foldable t
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    Position' (m a) -> m (Position' a)
    forall (f :: * -> *) a.
    Applicative f =>
    Position' (f a) -> f (Position' a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Position' a -> m (Position' b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Position' a -> f (Position' b)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    Position' (m a) -> m (Position' a)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    Position' (m a) -> m (Position' a)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Position' a -> m (Position' b)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Position' a -> m (Position' b)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Position' (f a) -> f (Position' a)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Position' (f a) -> f (Position' a)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Position' a -> f (Position' b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Position' a -> f (Position' b)
    Traversable, (forall x. Position' a -> Rep (Position' a) x)
    -> (forall x. Rep (Position' a) x -> Position' a)
    -> Generic (Position' a)
    forall x. Rep (Position' a) x -> Position' a
    forall x. Position' a -> Rep (Position' a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (Position' a) x -> Position' a
    forall a x. Position' a -> Rep (Position' a) x
    $cto :: forall a x. Rep (Position' a) x -> Position' a
    $cfrom :: forall a x. Position' a -> Rep (Position' a) x
    Generic)

    positionInvariant :: Position' a -> Bool
    positionInvariant :: forall a. Position' a -> Bool
    positionInvariant Position' a
    p =
      Position' a -> Int32
    forall a. Position' a -> Int32
    posPos Position' a
    p Int32 -> Int32 -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int32
    0 Bool -> Bool -> Bool
    && Position' a -> Int32
    forall a. Position' a -> Int32
    posLine Position' a
    p Int32 -> Int32 -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int32
    0 Bool -> Bool -> Bool
    && Position' a -> Int32
    forall a. Position' a -> Int32
    posCol Position' a
    p Int32 -> Int32 -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int32
    0

    importantPart :: Position' a -> (a, Int32)
    importantPart :: forall a. Position' a -> (a, Int32)
    importantPart Position' a
    p = (Position' a -> a
    forall a. Position' a -> a
    srcFile Position' a
    p, Position' a -> Int32
    forall a. Position' a -> Int32
    posPos Position' a
    p)

    instance Eq a => Eq (Position' a) where
      == :: Position' a -> Position' a -> Bool
    (==) = (a, Int32) -> (a, Int32) -> Bool
    forall a. Eq a => a -> a -> Bool
    (==) ((a, Int32) -> (a, Int32) -> Bool)
    -> (Position' a -> (a, Int32))
    -> Position' a
    -> Position' a
    -> Bool
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` Position' a -> (a, Int32)
    forall a. Position' a -> (a, Int32)
    importantPart

    instance Ord a => Ord (Position' a) where
      compare :: Position' a -> Position' a -> Ordering
    compare = (a, Int32) -> (a, Int32) -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare ((a, Int32) -> (a, Int32) -> Ordering)
    -> (Position' a -> (a, Int32))
    -> Position' a
    -> Position' a
    -> Ordering
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` Position' a -> (a, Int32)
    forall a. Position' a -> (a, Int32)
    importantPart

    type SrcFile = Strict.Maybe AbsolutePath

    type Position            = Position' SrcFile
    type PositionWithoutFile = Position' ()

    instance NFData Position where
      rnf :: Position -> ()
    rnf = (Position -> () -> ()
    `seq` ())

    instance NFData PositionWithoutFile where
      rnf :: PositionWithoutFile -> ()
    rnf = (PositionWithoutFile -> () -> ()
    `seq` ())

    -- | An interval. The @iEnd@ position is not included in the interval.
    --
    -- Note the invariant which intervals have to satisfy: 'intervalInvariant'.
    data Interval' a = Interval { forall a. Interval' a -> Position' a
    iStart, forall a. Interval' a -> Position' a
    iEnd :: !(Position' a) }
      deriving (Int -> Interval' a -> ShowS
    [Interval' a] -> ShowS
    Interval' a -> String
    (Int -> Interval' a -> ShowS)
    -> (Interval' a -> String)
    -> ([Interval' a] -> ShowS)
    -> Show (Interval' a)
    forall a. Show a => Int -> Interval' a -> ShowS
    forall a. Show a => [Interval' a] -> ShowS
    forall a. Show a => Interval' a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Interval' a] -> ShowS
    $cshowList :: forall a. Show a => [Interval' a] -> ShowS
    show :: Interval' a -> String
    $cshow :: forall a. Show a => Interval' a -> String
    showsPrec :: Int -> Interval' a -> ShowS
    $cshowsPrec :: forall a. Show a => Int -> Interval' a -> ShowS
    Show, Typeable (Interval' a)
    Typeable (Interval' a)
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Interval' a -> c (Interval' a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Interval' a))
    -> (Interval' a -> Constr)
    -> (Interval' a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Interval' a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Interval' a)))
    -> ((forall b. Data b => b -> b) -> Interval' a -> Interval' a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Interval' a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Interval' a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Interval' a -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Interval' a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a))
    -> Data (Interval' a)
    Interval' a -> DataType
    Interval' a -> Constr
    (forall b. Data b => b -> b) -> Interval' a -> Interval' a
    forall {a}. Data a => Typeable (Interval' a)
    forall a. Data a => Interval' a -> DataType
    forall a. Data a => Interval' a -> Constr
    forall a.
    Data a =>
    (forall b. Data b => b -> b) -> Interval' a -> Interval' a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Interval' a -> u
    forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> Interval' a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Interval' a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Interval' a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Interval' a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Interval' a -> c (Interval' a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Interval' a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Interval' a))
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Interval' a -> u
    forall u. (forall d. Data d => d -> u) -> Interval' a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Interval' a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Interval' a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Interval' a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Interval' a -> c (Interval' a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Interval' a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Interval' a))
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a)
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Interval' a -> m (Interval' a)
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Interval' a -> u
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Interval' a -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Interval' a -> [u]
    $cgmapQ :: forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> Interval' a -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Interval' a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Interval' a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Interval' a -> r
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Interval' a -> r
    gmapT :: (forall b. Data b => b -> b) -> Interval' a -> Interval' a
    $cgmapT :: forall a.
    Data a =>
    (forall b. Data b => b -> b) -> Interval' a -> Interval' a
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Interval' a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Interval' a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Interval' a))
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Interval' a))
    dataTypeOf :: Interval' a -> DataType
    $cdataTypeOf :: forall a. Data a => Interval' a -> DataType
    toConstr :: Interval' a -> Constr
    $ctoConstr :: forall a. Data a => Interval' a -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Interval' a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Interval' a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Interval' a -> c (Interval' a)
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Interval' a -> c (Interval' a)
    Data, Interval' a -> Interval' a -> Bool
    (Interval' a -> Interval' a -> Bool)
    -> (Interval' a -> Interval' a -> Bool) -> Eq (Interval' a)
    forall a. Eq a => Interval' a -> Interval' a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Interval' a -> Interval' a -> Bool
    $c/= :: forall a. Eq a => Interval' a -> Interval' a -> Bool
    == :: Interval' a -> Interval' a -> Bool
    $c== :: forall a. Eq a => Interval' a -> Interval' a -> Bool
    Eq, Eq (Interval' a)
    Eq (Interval' a)
    -> (Interval' a -> Interval' a -> Ordering)
    -> (Interval' a -> Interval' a -> Bool)
    -> (Interval' a -> Interval' a -> Bool)
    -> (Interval' a -> Interval' a -> Bool)
    -> (Interval' a -> Interval' a -> Bool)
    -> (Interval' a -> Interval' a -> Interval' a)
    -> (Interval' a -> Interval' a -> Interval' a)
    -> Ord (Interval' a)
    Interval' a -> Interval' a -> Bool
    Interval' a -> Interval' a -> Ordering
    Interval' a -> Interval' a -> Interval' a
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall {a}. Ord a => Eq (Interval' a)
    forall a. Ord a => Interval' a -> Interval' a -> Bool
    forall a. Ord a => Interval' a -> Interval' a -> Ordering
    forall a. Ord a => Interval' a -> Interval' a -> Interval' a
    min :: Interval' a -> Interval' a -> Interval' a
    $cmin :: forall a. Ord a => Interval' a -> Interval' a -> Interval' a
    max :: Interval' a -> Interval' a -> Interval' a
    $cmax :: forall a. Ord a => Interval' a -> Interval' a -> Interval' a
    >= :: Interval' a -> Interval' a -> Bool
    $c>= :: forall a. Ord a => Interval' a -> Interval' a -> Bool
    > :: Interval' a -> Interval' a -> Bool
    $c> :: forall a. Ord a => Interval' a -> Interval' a -> Bool
    <= :: Interval' a -> Interval' a -> Bool
    $c<= :: forall a. Ord a => Interval' a -> Interval' a -> Bool
    < :: Interval' a -> Interval' a -> Bool
    $c< :: forall a. Ord a => Interval' a -> Interval' a -> Bool
    compare :: Interval' a -> Interval' a -> Ordering
    $ccompare :: forall a. Ord a => Interval' a -> Interval' a -> Ordering
    Ord, (forall a b. (a -> b) -> Interval' a -> Interval' b)
    -> (forall a b. a -> Interval' b -> Interval' a)
    -> Functor Interval'
    forall a b. a -> Interval' b -> Interval' a
    forall a b. (a -> b) -> Interval' a -> Interval' b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> Interval' b -> Interval' a
    $c<$ :: forall a b. a -> Interval' b -> Interval' a
    fmap :: forall a b. (a -> b) -> Interval' a -> Interval' b
    $cfmap :: forall a b. (a -> b) -> Interval' a -> Interval' b
    Functor, (forall m. Monoid m => Interval' m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Interval' a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Interval' a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Interval' a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Interval' a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Interval' a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Interval' a -> b)
    -> (forall a. (a -> a -> a) -> Interval' a -> a)
    -> (forall a. (a -> a -> a) -> Interval' a -> a)
    -> (forall a. Interval' a -> [a])
    -> (forall a. Interval' a -> Bool)
    -> (forall a. Interval' a -> Int)
    -> (forall a. Eq a => a -> Interval' a -> Bool)
    -> (forall a. Ord a => Interval' a -> a)
    -> (forall a. Ord a => Interval' a -> a)
    -> (forall a. Num a => Interval' a -> a)
    -> (forall a. Num a => Interval' a -> a)
    -> Foldable Interval'
    forall a. Eq a => a -> Interval' a -> Bool
    forall a. Num a => Interval' a -> a
    forall a. Ord a => Interval' a -> a
    forall m. Monoid m => Interval' m -> m
    forall a. Interval' a -> Bool
    forall a. Interval' a -> Int
    forall a. Interval' a -> [a]
    forall a. (a -> a -> a) -> Interval' a -> a
    forall m a. Monoid m => (a -> m) -> Interval' a -> m
    forall b a. (b -> a -> b) -> b -> Interval' a -> b
    forall a b. (a -> b -> b) -> b -> Interval' a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    product :: forall a. Num a => Interval' a -> a
    $cproduct :: forall a. Num a => Interval' a -> a
    sum :: forall a. Num a => Interval' a -> a
    $csum :: forall a. Num a => Interval' a -> a
    minimum :: forall a. Ord a => Interval' a -> a
    $cminimum :: forall a. Ord a => Interval' a -> a
    maximum :: forall a. Ord a => Interval' a -> a
    $cmaximum :: forall a. Ord a => Interval' a -> a
    elem :: forall a. Eq a => a -> Interval' a -> Bool
    $celem :: forall a. Eq a => a -> Interval' a -> Bool
    length :: forall a. Interval' a -> Int
    $clength :: forall a. Interval' a -> Int
    null :: forall a. Interval' a -> Bool
    $cnull :: forall a. Interval' a -> Bool
    toList :: forall a. Interval' a -> [a]
    $ctoList :: forall a. Interval' a -> [a]
    foldl1 :: forall a. (a -> a -> a) -> Interval' a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Interval' a -> a
    foldr1 :: forall a. (a -> a -> a) -> Interval' a -> a
    $cfoldr1 :: forall a. (a -> a -> a) -> Interval' a -> a
    foldl' :: forall b a. (b -> a -> b) -> b -> Interval' a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Interval' a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Interval' a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Interval' a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Interval' a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Interval' a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Interval' a -> b
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Interval' a -> b
    foldMap' :: forall m a. Monoid m => (a -> m) -> Interval' a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Interval' a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Interval' a -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Interval' a -> m
    fold :: forall m. Monoid m => Interval' m -> m
    $cfold :: forall m. Monoid m => Interval' m -> m
    Foldable, Functor Interval'
    Foldable Interval'
    Functor Interval'
    -> Foldable Interval'
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> Interval' a -> f (Interval' b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Interval' (f a) -> f (Interval' a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Interval' a -> m (Interval' b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Interval' (m a) -> m (Interval' a))
    -> Traversable Interval'
    forall (t :: * -> *).
    Functor t
    -> Foldable t
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    Interval' (m a) -> m (Interval' a)
    forall (f :: * -> *) a.
    Applicative f =>
    Interval' (f a) -> f (Interval' a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Interval' a -> m (Interval' b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Interval' a -> f (Interval' b)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    Interval' (m a) -> m (Interval' a)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    Interval' (m a) -> m (Interval' a)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Interval' a -> m (Interval' b)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Interval' a -> m (Interval' b)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Interval' (f a) -> f (Interval' a)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Interval' (f a) -> f (Interval' a)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Interval' a -> f (Interval' b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Interval' a -> f (Interval' b)
    Traversable, (forall x. Interval' a -> Rep (Interval' a) x)
    -> (forall x. Rep (Interval' a) x -> Interval' a)
    -> Generic (Interval' a)
    forall x. Rep (Interval' a) x -> Interval' a
    forall x. Interval' a -> Rep (Interval' a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (Interval' a) x -> Interval' a
    forall a x. Interval' a -> Rep (Interval' a) x
    $cto :: forall a x. Rep (Interval' a) x -> Interval' a
    $cfrom :: forall a x. Interval' a -> Rep (Interval' a) x
    Generic)

    type Interval            = Interval' SrcFile
    type IntervalWithoutFile = Interval' ()

    instance NFData Interval where
      rnf :: Interval -> ()
    rnf = (Interval -> () -> ()
    `seq` ())

    instance NFData IntervalWithoutFile where
      rnf :: IntervalWithoutFile -> ()
    rnf = (IntervalWithoutFile -> () -> ()
    `seq` ())

    intervalInvariant :: Ord a => Interval' a -> Bool
    intervalInvariant :: forall a. Ord a => Interval' a -> Bool
    intervalInvariant Interval' a
    i =
      (Position' a -> Bool) -> [Position' a] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all Position' a -> Bool
    forall a. Position' a -> Bool
    positionInvariant [Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    i, Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    i]
        Bool -> Bool -> Bool
    &&
      Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    i Position' a -> Position' a -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    i
        Bool -> Bool -> Bool
    &&
      Position' a -> a
    forall a. Position' a -> a
    srcFile (Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    i) a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    == Position' a -> a
    forall a. Position' a -> a
    srcFile (Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    i)

    -- | Sets the 'srcFile' components of the interval.

    setIntervalFile :: a -> Interval' b -> Interval' a
    setIntervalFile :: forall a b. a -> Interval' b -> Interval' a
    setIntervalFile a
    f (Interval Position' b
    p1 Position' b
    p2) =
      Position' a -> Position' a -> Interval' a
    forall a. Position' a -> Position' a -> Interval' a
    Interval (Position' b
    p1 { srcFile :: a
    srcFile = a
    f }) (Position' b
    p2 { srcFile :: a
    srcFile = a
    f })

    -- | Gets the 'srcFile' component of the interval. Because of the invariant,
    --   they are both the same.
    getIntervalFile :: Interval' a -> a
    getIntervalFile :: forall a. Interval' a -> a
    getIntervalFile = Position' a -> a
    forall a. Position' a -> a
    srcFile (Position' a -> a)
    -> (Interval' a -> Position' a) -> Interval' a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart

    -- | Converts a file name and two positions to an interval.
    posToInterval ::
      a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a
    posToInterval :: forall a.
    a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a
    posToInterval a
    f PositionWithoutFile
    p1 PositionWithoutFile
    p2 = a -> IntervalWithoutFile -> Interval' a
    forall a b. a -> Interval' b -> Interval' a
    setIntervalFile a
    f (IntervalWithoutFile -> Interval' a)
    -> IntervalWithoutFile -> Interval' a
    forall a b. (a -> b) -> a -> b
    $
      if PositionWithoutFile
    p1 PositionWithoutFile -> PositionWithoutFile -> Bool
    forall a. Ord a => a -> a -> Bool
    < PositionWithoutFile
    p2
      then PositionWithoutFile -> PositionWithoutFile -> IntervalWithoutFile
    forall a. Position' a -> Position' a -> Interval' a
    Interval PositionWithoutFile
    p1 PositionWithoutFile
    p2
      else PositionWithoutFile -> PositionWithoutFile -> IntervalWithoutFile
    forall a. Position' a -> Position' a -> Interval' a
    Interval PositionWithoutFile
    p2 PositionWithoutFile
    p1

    -- | The length of an interval.
    iLength :: Interval' a -> Int32
    iLength :: forall a. Interval' a -> Int32
    iLength Interval' a
    i = Position' a -> Int32
    forall a. Position' a -> Int32
    posPos (Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    i) Int32 -> Int32 -> Int32
    forall a. Num a => a -> a -> a
    - Position' a -> Int32
    forall a. Position' a -> Int32
    posPos (Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    i)

    -- | A range is a file name, plus a sequence of intervals, assumed to
    -- point to the given file. The intervals should be consecutive and
    -- separated.
    --
    -- Note the invariant which ranges have to satisfy: 'rangeInvariant'.
    data Range' a
      = NoRange
      | Range !a (Seq IntervalWithoutFile)
      deriving
        (Int -> Range' a -> ShowS
    [Range' a] -> ShowS
    Range' a -> String
    (Int -> Range' a -> ShowS)
    -> (Range' a -> String) -> ([Range' a] -> ShowS) -> Show (Range' a)
    forall a. Show a => Int -> Range' a -> ShowS
    forall a. Show a => [Range' a] -> ShowS
    forall a. Show a => Range' a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Range' a] -> ShowS
    $cshowList :: forall a. Show a => [Range' a] -> ShowS
    show :: Range' a -> String
    $cshow :: forall a. Show a => Range' a -> String
    showsPrec :: Int -> Range' a -> ShowS
    $cshowsPrec :: forall a. Show a => Int -> Range' a -> ShowS
    Show, Typeable (Range' a)
    Typeable (Range' a)
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Range' a -> c (Range' a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Range' a))
    -> (Range' a -> Constr)
    -> (Range' a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Range' a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Range' a)))
    -> ((forall b. Data b => b -> b) -> Range' a -> Range' a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Range' a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Range' a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Range' a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Range' a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Range' a -> m (Range' a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Range' a -> m (Range' a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Range' a -> m (Range' a))
    -> Data (Range' a)
    Range' a -> DataType
    Range' a -> Constr
    (forall b. Data b => b -> b) -> Range' a -> Range' a
    forall {a}. Data a => Typeable (Range' a)
    forall a. Data a => Range' a -> DataType
    forall a. Data a => Range' a -> Constr
    forall a.
    Data a =>
    (forall b. Data b => b -> b) -> Range' a -> Range' a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Range' a -> u
    forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> Range' a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Range' a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Range' a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Range' a -> m (Range' a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Range' a -> m (Range' a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Range' a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Range' a -> c (Range' a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Range' a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Range' a))
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Range' a -> u
    forall u. (forall d. Data d => d -> u) -> Range' a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Range' a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Range' a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Range' a -> m (Range' a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Range' a -> m (Range' a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Range' a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Range' a -> c (Range' a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Range' a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Range' a))
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Range' a -> m (Range' a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Range' a -> m (Range' a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Range' a -> m (Range' a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Range' a -> m (Range' a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Range' a -> m (Range' a)
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Range' a -> m (Range' a)
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Range' a -> u
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Range' a -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Range' a -> [u]
    $cgmapQ :: forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> Range' a -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Range' a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Range' a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Range' a -> r
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Range' a -> r
    gmapT :: (forall b. Data b => b -> b) -> Range' a -> Range' a
    $cgmapT :: forall a.
    Data a =>
    (forall b. Data b => b -> b) -> Range' a -> Range' a
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Range' a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Range' a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Range' a))
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Range' a))
    dataTypeOf :: Range' a -> DataType
    $cdataTypeOf :: forall a. Data a => Range' a -> DataType
    toConstr :: Range' a -> Constr
    $ctoConstr :: forall a. Data a => Range' a -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Range' a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Range' a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Range' a -> c (Range' a)
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Range' a -> c (Range' a)
    Data, Range' a -> Range' a -> Bool
    (Range' a -> Range' a -> Bool)
    -> (Range' a -> Range' a -> Bool) -> Eq (Range' a)
    forall a. Eq a => Range' a -> Range' a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Range' a -> Range' a -> Bool
    $c/= :: forall a. Eq a => Range' a -> Range' a -> Bool
    == :: Range' a -> Range' a -> Bool
    $c== :: forall a. Eq a => Range' a -> Range' a -> Bool
    Eq, Eq (Range' a)
    Eq (Range' a)
    -> (Range' a -> Range' a -> Ordering)
    -> (Range' a -> Range' a -> Bool)
    -> (Range' a -> Range' a -> Bool)
    -> (Range' a -> Range' a -> Bool)
    -> (Range' a -> Range' a -> Bool)
    -> (Range' a -> Range' a -> Range' a)
    -> (Range' a -> Range' a -> Range' a)
    -> Ord (Range' a)
    Range' a -> Range' a -> Bool
    Range' a -> Range' a -> Ordering
    Range' a -> Range' a -> Range' a
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall {a}. Ord a => Eq (Range' a)
    forall a. Ord a => Range' a -> Range' a -> Bool
    forall a. Ord a => Range' a -> Range' a -> Ordering
    forall a. Ord a => Range' a -> Range' a -> Range' a
    min :: Range' a -> Range' a -> Range' a
    $cmin :: forall a. Ord a => Range' a -> Range' a -> Range' a
    max :: Range' a -> Range' a -> Range' a
    $cmax :: forall a. Ord a => Range' a -> Range' a -> Range' a
    >= :: Range' a -> Range' a -> Bool
    $c>= :: forall a. Ord a => Range' a -> Range' a -> Bool
    > :: Range' a -> Range' a -> Bool
    $c> :: forall a. Ord a => Range' a -> Range' a -> Bool
    <= :: Range' a -> Range' a -> Bool
    $c<= :: forall a. Ord a => Range' a -> Range' a -> Bool
    < :: Range' a -> Range' a -> Bool
    $c< :: forall a. Ord a => Range' a -> Range' a -> Bool
    compare :: Range' a -> Range' a -> Ordering
    $ccompare :: forall a. Ord a => Range' a -> Range' a -> Ordering
    Ord, (forall a b. (a -> b) -> Range' a -> Range' b)
    -> (forall a b. a -> Range' b -> Range' a) -> Functor Range'
    forall a b. a -> Range' b -> Range' a
    forall a b. (a -> b) -> Range' a -> Range' b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> Range' b -> Range' a
    $c<$ :: forall a b. a -> Range' b -> Range' a
    fmap :: forall a b. (a -> b) -> Range' a -> Range' b
    $cfmap :: forall a b. (a -> b) -> Range' a -> Range' b
    Functor, (forall m. Monoid m => Range' m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Range' a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Range' a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Range' a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Range' a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Range' a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Range' a -> b)
    -> (forall a. (a -> a -> a) -> Range' a -> a)
    -> (forall a. (a -> a -> a) -> Range' a -> a)
    -> (forall a. Range' a -> [a])
    -> (forall a. Range' a -> Bool)
    -> (forall a. Range' a -> Int)
    -> (forall a. Eq a => a -> Range' a -> Bool)
    -> (forall a. Ord a => Range' a -> a)
    -> (forall a. Ord a => Range' a -> a)
    -> (forall a. Num a => Range' a -> a)
    -> (forall a. Num a => Range' a -> a)
    -> Foldable Range'
    forall a. Eq a => a -> Range' a -> Bool
    forall a. Num a => Range' a -> a
    forall a. Ord a => Range' a -> a
    forall m. Monoid m => Range' m -> m
    forall a. Range' a -> Bool
    forall a. Range' a -> Int
    forall a. Range' a -> [a]
    forall a. (a -> a -> a) -> Range' a -> a
    forall m a. Monoid m => (a -> m) -> Range' a -> m
    forall b a. (b -> a -> b) -> b -> Range' a -> b
    forall a b. (a -> b -> b) -> b -> Range' a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    product :: forall a. Num a => Range' a -> a
    $cproduct :: forall a. Num a => Range' a -> a
    sum :: forall a. Num a => Range' a -> a
    $csum :: forall a. Num a => Range' a -> a
    minimum :: forall a. Ord a => Range' a -> a
    $cminimum :: forall a. Ord a => Range' a -> a
    maximum :: forall a. Ord a => Range' a -> a
    $cmaximum :: forall a. Ord a => Range' a -> a
    elem :: forall a. Eq a => a -> Range' a -> Bool
    $celem :: forall a. Eq a => a -> Range' a -> Bool
    length :: forall a. Range' a -> Int
    $clength :: forall a. Range' a -> Int
    null :: forall a. Range' a -> Bool
    $cnull :: forall a. Range' a -> Bool
    toList :: forall a. Range' a -> [a]
    $ctoList :: forall a. Range' a -> [a]
    foldl1 :: forall a. (a -> a -> a) -> Range' a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Range' a -> a
    foldr1 :: forall a. (a -> a -> a) -> Range' a -> a
    $cfoldr1 :: forall a. (a -> a -> a) -> Range' a -> a
    foldl' :: forall b a. (b -> a -> b) -> b -> Range' a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Range' a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Range' a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Range' a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Range' a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Range' a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Range' a -> b
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Range' a -> b
    foldMap' :: forall m a. Monoid m => (a -> m) -> Range' a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Range' a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Range' a -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Range' a -> m
    fold :: forall m. Monoid m => Range' m -> m
    $cfold :: forall m. Monoid m => Range' m -> m
    Foldable, Functor Range'
    Foldable Range'
    Functor Range'
    -> Foldable Range'
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> Range' a -> f (Range' b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Range' (f a) -> f (Range' a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Range' a -> m (Range' b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Range' (m a) -> m (Range' a))
    -> Traversable Range'
    forall (t :: * -> *).
    Functor t
    -> Foldable t
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Range' (m a) -> m (Range' a)
    forall (f :: * -> *) a.
    Applicative f =>
    Range' (f a) -> f (Range' a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Range' a -> m (Range' b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Range' a -> f (Range' b)
    sequence :: forall (m :: * -> *) a. Monad m => Range' (m a) -> m (Range' a)
    $csequence :: forall (m :: * -> *) a. Monad m => Range' (m a) -> m (Range' a)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Range' a -> m (Range' b)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Range' a -> m (Range' b)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Range' (f a) -> f (Range' a)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Range' (f a) -> f (Range' a)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Range' a -> f (Range' b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Range' a -> f (Range' b)
    Traversable, (forall x. Range' a -> Rep (Range' a) x)
    -> (forall x. Rep (Range' a) x -> Range' a) -> Generic (Range' a)
    forall x. Rep (Range' a) x -> Range' a
    forall x. Range' a -> Rep (Range' a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (Range' a) x -> Range' a
    forall a x. Range' a -> Rep (Range' a) x
    $cto :: forall a x. Rep (Range' a) x -> Range' a
    $cfrom :: forall a x. Range' a -> Rep (Range' a) x
    Generic)

    type Range = Range' SrcFile

    instance NFData a => NFData (Range' a)

    instance Null (Range' a) where
      null :: Range' a -> Bool
    null Range' a
    NoRange = Bool
    True
      null Range{} = Bool
    False

      empty :: Range' a
    empty = Range' a
    forall a. Range' a
    NoRange

    instance Semigroup a => Semigroup (Range' a) where
      Range' a
    NoRange <> :: Range' a -> Range' a -> Range' a
    <> Range' a
    r = Range' a
    r
      Range' a
    r <> Range' a
    NoRange = Range' a
    r
      Range a
    f Seq IntervalWithoutFile
    is <> Range a
    f' Seq IntervalWithoutFile
    is' = a -> Seq IntervalWithoutFile -> Range' a
    forall a. a -> Seq IntervalWithoutFile -> Range' a
    Range (a
    f a -> a -> a
    forall a. Semigroup a => a -> a -> a
    <> a
    f') (Seq IntervalWithoutFile
    is Seq IntervalWithoutFile
    -> Seq IntervalWithoutFile -> Seq IntervalWithoutFile
    forall a. Semigroup a => a -> a -> a
    <> Seq IntervalWithoutFile
    is')

    instance Semigroup a => Monoid (Range' a) where
      mempty :: Range' a
    mempty  = Range' a
    forall a. Null a => a
    empty
      mappend :: Range' a -> Range' a -> Range' a
    mappend = Range' a -> Range' a -> Range' a
    forall a. Semigroup a => a -> a -> a
    (<>)

    -- | To get @'Semigroup' 'Range'@, we need a semigroup instance for 'AbsolutePath'.
    instance Semigroup AbsolutePath where
      AbsolutePath
    f <> :: AbsolutePath -> AbsolutePath -> AbsolutePath
    <> AbsolutePath
    f' = if AbsolutePath
    f AbsolutePath -> AbsolutePath -> Bool
    forall a. Eq a => a -> a -> Bool
    == AbsolutePath
    f' then AbsolutePath
    f else AbsolutePath
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    -- | The intervals that make up the range. The intervals are
    -- consecutive and separated ('consecutiveAndSeparated').
    rangeIntervals :: Range' a -> [IntervalWithoutFile]
    rangeIntervals :: forall a. Range' a -> [IntervalWithoutFile]
    rangeIntervals Range' a
    NoRange      = []
    rangeIntervals (Range a
    _ Seq IntervalWithoutFile
    is) = Seq IntervalWithoutFile -> [IntervalWithoutFile]
    forall (t :: * -> *) a. Foldable t => t a -> [a]
    Fold.toList Seq IntervalWithoutFile
    is

    -- | Turns a file name plus a list of intervals into a range.
    --
    -- Precondition: 'consecutiveAndSeparated'.
    intervalsToRange :: a -> [IntervalWithoutFile] -> Range' a
    intervalsToRange :: forall a. a -> [IntervalWithoutFile] -> Range' a
    intervalsToRange a
    _ [] = Range' a
    forall a. Range' a
    NoRange
    intervalsToRange a
    f [IntervalWithoutFile]
    is = a -> Seq IntervalWithoutFile -> Range' a
    forall a. a -> Seq IntervalWithoutFile -> Range' a
    Range a
    f ([IntervalWithoutFile] -> Seq IntervalWithoutFile
    forall a. [a] -> Seq a
    Seq.fromList [IntervalWithoutFile]
    is)

    -- | Are the intervals consecutive and separated, do they all point to
    -- the same file, and do they satisfy the interval invariant?
    consecutiveAndSeparated :: Ord a => [Interval' a] -> Bool
    consecutiveAndSeparated :: forall a. Ord a => [Interval' a] -> Bool
    consecutiveAndSeparated [Interval' a]
    is =
      (Interval' a -> Bool) -> [Interval' a] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all Interval' a -> Bool
    forall a. Ord a => Interval' a -> Bool
    intervalInvariant [Interval' a]
    is
        Bool -> Bool -> Bool
    &&
      [a] -> Bool
    forall a. Eq a => [a] -> Bool
    allEqual ((Interval' a -> a) -> [Interval' a] -> [a]
    forall a b. (a -> b) -> [a] -> [b]
    map (Position' a -> a
    forall a. Position' a -> a
    srcFile (Position' a -> a)
    -> (Interval' a -> Position' a) -> Interval' a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart) [Interval' a]
    is)
        Bool -> Bool -> Bool
    &&
      ([Interval' a] -> Bool
    forall a. Null a => a -> Bool
    null [Interval' a]
    is
         Bool -> Bool -> Bool
    ||
       [Bool] -> Bool
    forall (t :: * -> *). Foldable t => t Bool -> Bool
    and ((Position' a -> Position' a -> Bool)
    -> [Position' a] -> [Position' a] -> [Bool]
    forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
    zipWith Position' a -> Position' a -> Bool
    forall a. Ord a => a -> a -> Bool
    (<) ((Interval' a -> Position' a) -> [Interval' a] -> [Position' a]
    forall a b. (a -> b) -> [a] -> [b]
    map Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd   ([Interval' a] -> [Interval' a]
    forall a. [a] -> [a]
    init [Interval' a]
    is))
                        ((Interval' a -> Position' a) -> [Interval' a] -> [Position' a]
    forall a b. (a -> b) -> [a] -> [b]
    map Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart ([Interval' a] -> [Interval' a]
    forall a. [a] -> [a]
    tail [Interval' a]
    is))))

    -- | Range invariant.
    rangeInvariant :: Ord a => Range' a -> Bool
    rangeInvariant :: forall a. Ord a => Range' a -> Bool
    rangeInvariant Range' a
    r =
      [IntervalWithoutFile] -> Bool
    forall a. Ord a => [Interval' a] -> Bool
    consecutiveAndSeparated (Range' a -> [IntervalWithoutFile]
    forall a. Range' a -> [IntervalWithoutFile]
    rangeIntervals Range' a
    r)
        Bool -> Bool -> Bool
    &&
      case Range' a
    r of
        Range a
    _ Seq IntervalWithoutFile
    is -> Bool -> Bool
    not (Seq IntervalWithoutFile -> Bool
    forall a. Null a => a -> Bool
    null Seq IntervalWithoutFile
    is)
        Range' a
    NoRange    -> Bool
    True

    -- | The file the range is pointing to.
    rangeFile :: Range -> SrcFile
    rangeFile :: Range -> SrcFile
    rangeFile Range
    NoRange     = SrcFile
    forall a. Maybe a
    Strict.Nothing
    rangeFile (Range SrcFile
    f Seq IntervalWithoutFile
    _) = SrcFile
    f

    -- | Conflate a range to its right margin.
    rightMargin :: Range -> Range
    rightMargin :: Range -> Range
    rightMargin r :: Range
    r@Range
    NoRange      = Range
    r
    rightMargin r :: Range
    r@(Range SrcFile
    f Seq IntervalWithoutFile
    is) = case Seq IntervalWithoutFile -> ViewR IntervalWithoutFile
    forall a. Seq a -> ViewR a
    Seq.viewr Seq IntervalWithoutFile
    is of
      ViewR IntervalWithoutFile
    Seq.EmptyR -> Range
    forall a. HasCallStack => a
    __IMPOSSIBLE__
      Seq IntervalWithoutFile
    _ Seq.:> IntervalWithoutFile
    i -> SrcFile -> IntervalWithoutFile -> Range
    forall a. a -> IntervalWithoutFile -> Range' a
    intervalToRange SrcFile
    f (IntervalWithoutFile
    i { iStart :: PositionWithoutFile
    iStart = IntervalWithoutFile -> PositionWithoutFile
    forall a. Interval' a -> Position' a
    iEnd IntervalWithoutFile
    i })

    -- | Wrapper to indicate that range should be printed.
    newtype PrintRange a = PrintRange a
      deriving (PrintRange a -> PrintRange a -> Bool
    (PrintRange a -> PrintRange a -> Bool)
    -> (PrintRange a -> PrintRange a -> Bool) -> Eq (PrintRange a)
    forall a. Eq a => PrintRange a -> PrintRange a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: PrintRange a -> PrintRange a -> Bool
    $c/= :: forall a. Eq a => PrintRange a -> PrintRange a -> Bool
    == :: PrintRange a -> PrintRange a -> Bool
    $c== :: forall a. Eq a => PrintRange a -> PrintRange a -> Bool
    Eq, Eq (PrintRange a)
    Eq (PrintRange a)
    -> (PrintRange a -> PrintRange a -> Ordering)
    -> (PrintRange a -> PrintRange a -> Bool)
    -> (PrintRange a -> PrintRange a -> Bool)
    -> (PrintRange a -> PrintRange a -> Bool)
    -> (PrintRange a -> PrintRange a -> Bool)
    -> (PrintRange a -> PrintRange a -> PrintRange a)
    -> (PrintRange a -> PrintRange a -> PrintRange a)
    -> Ord (PrintRange a)
    PrintRange a -> PrintRange a -> Bool
    PrintRange a -> PrintRange a -> Ordering
    PrintRange a -> PrintRange a -> PrintRange a
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall {a}. Ord a => Eq (PrintRange a)
    forall a. Ord a => PrintRange a -> PrintRange a -> Bool
    forall a. Ord a => PrintRange a -> PrintRange a -> Ordering
    forall a. Ord a => PrintRange a -> PrintRange a -> PrintRange a
    min :: PrintRange a -> PrintRange a -> PrintRange a
    $cmin :: forall a. Ord a => PrintRange a -> PrintRange a -> PrintRange a
    max :: PrintRange a -> PrintRange a -> PrintRange a
    $cmax :: forall a. Ord a => PrintRange a -> PrintRange a -> PrintRange a
    >= :: PrintRange a -> PrintRange a -> Bool
    $c>= :: forall a. Ord a => PrintRange a -> PrintRange a -> Bool
    > :: PrintRange a -> PrintRange a -> Bool
    $c> :: forall a. Ord a => PrintRange a -> PrintRange a -> Bool
    <= :: PrintRange a -> PrintRange a -> Bool
    $c<= :: forall a. Ord a => PrintRange a -> PrintRange a -> Bool
    < :: PrintRange a -> PrintRange a -> Bool
    $c< :: forall a. Ord a => PrintRange a -> PrintRange a -> Bool
    compare :: PrintRange a -> PrintRange a -> Ordering
    $ccompare :: forall a. Ord a => PrintRange a -> PrintRange a -> Ordering
    Ord, PrintRange a -> Range
    (PrintRange a -> Range) -> HasRange (PrintRange a)
    forall a. HasRange a => PrintRange a -> Range
    forall a. (a -> Range) -> HasRange a
    getRange :: PrintRange a -> Range
    $cgetRange :: forall a. HasRange a => PrintRange a -> Range
    HasRange, HasRange (PrintRange a)
    HasRange (PrintRange a)
    -> (Range -> PrintRange a -> PrintRange a)
    -> SetRange (PrintRange a)
    Range -> PrintRange a -> PrintRange a
    forall {a}. SetRange a => HasRange (PrintRange a)
    forall a. SetRange a => Range -> PrintRange a -> PrintRange a
    forall a. HasRange a -> (Range -> a -> a) -> SetRange a
    setRange :: Range -> PrintRange a -> PrintRange a
    $csetRange :: forall a. SetRange a => Range -> PrintRange a -> PrintRange a
    SetRange, KillRangeT (PrintRange a)
    KillRangeT (PrintRange a) -> KillRange (PrintRange a)
    forall a. KillRange a => KillRangeT (PrintRange a)
    forall a. KillRangeT a -> KillRange a
    killRange :: KillRangeT (PrintRange a)
    $ckillRange :: forall a. KillRange a => KillRangeT (PrintRange a)
    KillRange)

    -- | Things that have a range are instances of this class.
    class HasRange a where
      getRange :: a -> Range

      default getRange :: (Foldable t, HasRange b, t b ~ a) => a -> Range
      getRange = (b -> Range -> Range) -> Range -> t b -> Range
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    Fold.foldr b -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange Range
    forall a. Range' a
    noRange

    instance HasRange Interval where
        getRange :: Interval -> Range
    getRange Interval
    i =
          SrcFile -> IntervalWithoutFile -> Range
    forall a. a -> IntervalWithoutFile -> Range' a
    intervalToRange (Position -> SrcFile
    forall a. Position' a -> a
    srcFile (Interval -> Position
    forall a. Interval' a -> Position' a
    iStart Interval
    i))
                          (() -> Interval -> IntervalWithoutFile
    forall a b. a -> Interval' b -> Interval' a
    setIntervalFile () Interval
    i)

    instance HasRange Range where
        getRange :: Range -> Range
    getRange = Range -> Range
    forall a. a -> a
    id

    instance HasRange () where
      getRange :: () -> Range
    getRange ()
    _ = Range
    forall a. Range' a
    noRange

    instance HasRange Bool where
        getRange :: Bool -> Range
    getRange Bool
    _ = Range
    forall a. Range' a
    noRange

    -- | Precondition: The ranges of the list elements must point to the
    -- same file (or be empty).
    instance HasRange a => HasRange [a]

    -- | Precondition: The ranges of the list elements must point to the
    -- same file (or be empty).
    instance HasRange a => HasRange (List1 a)
    instance HasRange a => HasRange (List2 a)
    instance HasRange a => HasRange (Maybe a)

    -- | Precondition: The ranges of the tuple elements must point to the
    -- same file (or be empty).
    instance (HasRange a, HasRange b) => HasRange (a,b) where
        getRange :: (a, b) -> Range
    getRange = (a -> b -> Range) -> (a, b) -> Range
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry a -> b -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange

    -- | Precondition: The ranges of the tuple elements must point to the
    -- same file (or be empty).
    instance (HasRange a, HasRange b, HasRange c) => HasRange (a,b,c) where
        getRange :: (a, b, c) -> Range
    getRange (a
    x,b
    y,c
    z) = (a, (b, c)) -> Range
    forall a. HasRange a => a -> Range
    getRange (a
    x,(b
    y,c
    z))

    -- | Precondition: The ranges of the tuple elements must point to the
    -- same file (or be empty).
    instance (HasRange a, HasRange b, HasRange c, HasRange d) => HasRange (a,b,c,d) where
        getRange :: (a, b, c, d) -> Range
    getRange (a
    x,b
    y,c
    z,d
    w) = (a, (b, (c, d))) -> Range
    forall a. HasRange a => a -> Range
    getRange (a
    x,(b
    y,(c
    z,d
    w)))

    -- | Precondition: The ranges of the tuple elements must point to the
    -- same file (or be empty).
    instance (HasRange a, HasRange b, HasRange c, HasRange d, HasRange e) => HasRange (a,b,c,d,e) where
        getRange :: (a, b, c, d, e) -> Range
    getRange (a
    x,b
    y,c
    z,d
    w,e
    v) = (a, (b, (c, (d, e)))) -> Range
    forall a. HasRange a => a -> Range
    getRange (a
    x,(b
    y,(c
    z,(d
    w,e
    v))))

    -- | Precondition: The ranges of the tuple elements must point to the
    -- same file (or be empty).
    instance (HasRange a, HasRange b, HasRange c, HasRange d, HasRange e, HasRange f) => HasRange (a,b,c,d,e,f) where
        getRange :: (a, b, c, d, e, f) -> Range
    getRange (a
    x,b
    y,c
    z,d
    w,e
    v,f
    u) = (a, (b, (c, (d, (e, f))))) -> Range
    forall a. HasRange a => a -> Range
    getRange (a
    x,(b
    y,(c
    z,(d
    w,(e
    v,f
    u)))))

    -- | Precondition: The ranges of the tuple elements must point to the
    -- same file (or be empty).
    instance (HasRange a, HasRange b, HasRange c, HasRange d, HasRange e, HasRange f, HasRange g) => HasRange (a,b,c,d,e,f,g) where
        getRange :: (a, b, c, d, e, f, g) -> Range
    getRange (a
    x,b
    y,c
    z,d
    w,e
    v,f
    u,g
    t) = (a, (b, (c, (d, (e, (f, g)))))) -> Range
    forall a. HasRange a => a -> Range
    getRange (a
    x,(b
    y,(c
    z,(d
    w,(e
    v,(f
    u,g
    t))))))

    instance (HasRange a, HasRange b) => HasRange (Either a b) where
        getRange :: Either a b -> Range
    getRange = (a -> Range) -> (b -> Range) -> Either a b -> Range
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    either a -> Range
    forall a. HasRange a => a -> Range
    getRange b -> Range
    forall a. HasRange a => a -> Range
    getRange

    -- | If it is also possible to set the range, this is the class.
    --
    --   Instances should satisfy @'getRange' ('setRange' r x) == r@.
    class HasRange a => SetRange a where
      setRange :: Range -> a -> a

      default setRange :: (Functor f, SetRange b, f b ~ a) => Range -> a -> a
      setRange = (b -> b) -> f b -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((b -> b) -> f b -> f b)
    -> (Range -> b -> b) -> Range -> f b -> f b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Range -> b -> b
    forall a. SetRange a => Range -> a -> a
    setRange

    instance SetRange Range where
      setRange :: Range -> Range -> Range
    setRange = Range -> Range -> Range
    forall a b. a -> b -> a
    const

    instance SetRange a => SetRange [a]
    instance SetRange a => SetRange (Maybe a)

    -- | Killing the range of an object sets all range information to 'noRange'.
    class KillRange a where
      killRange :: KillRangeT a

      default killRange :: (Functor f, KillRange b, f b ~ a) => KillRangeT a
      killRange = (b -> b) -> f b -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap b -> b
    forall a. KillRange a => KillRangeT a
    killRange

    type KillRangeT a = a -> a

    -- | Remove ranges in keys and values of a map.
    killRangeMap :: (KillRange k, KillRange v) => KillRangeT (Map k v)
    killRangeMap :: forall k v. (KillRange k, KillRange v) => KillRangeT (Map k v)
    killRangeMap = (k -> k) -> Map k v -> Map k v
    forall k1 k2 a. (k1 -> k2) -> Map k1 a -> Map k2 a
    Map.mapKeysMonotonic k -> k
    forall a. KillRange a => KillRangeT a
    killRange (Map k v -> Map k v) -> (Map k v -> Map k v) -> Map k v -> Map k v
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (v -> v) -> Map k v -> Map k v
    forall a b k. (a -> b) -> Map k a -> Map k b
    Map.map v -> v
    forall a. KillRange a => KillRangeT a
    killRange

    killRange1 :: KillRange a => (a -> b) -> a -> b

    killRange2 :: (KillRange a, KillRange b) => (a -> b -> c) -> a -> b -> c

    killRange3 :: (KillRange a, KillRange b, KillRange c) =>
                  (a -> b -> c -> d) -> a -> b -> c -> d

    killRange4 :: (KillRange a, KillRange b, KillRange c, KillRange d) =>
                  (a -> b -> c -> d -> e) -> a -> b -> c -> d -> e

    killRange5 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                  , KillRange e ) =>
                  (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> f

    killRange6 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                  , KillRange e, KillRange f ) =>
                  (a -> b -> c -> d -> e -> f -> g) -> a -> b -> c -> d -> e -> f -> g

    killRange7 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                  , KillRange e, KillRange f, KillRange g ) =>
                  (a -> b -> c -> d -> e -> f -> g -> h) -> a -> b -> c -> d -> e -> f -> g -> h

    killRange8 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                  , KillRange e, KillRange f, KillRange g, KillRange h ) =>
                  (a -> b -> c -> d -> e -> f -> g -> h -> i) ->
                  a -> b -> c -> d -> e -> f -> g -> h -> i

    killRange9 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                  , KillRange e, KillRange f, KillRange g, KillRange h
                  , KillRange i ) =>
                  (a -> b -> c -> d -> e -> f -> g -> h -> i -> j) ->
                  a -> b -> c -> d -> e -> f -> g -> h -> i -> j

    killRange10 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                   , KillRange e, KillRange f, KillRange g, KillRange h
                   , KillRange i, KillRange j ) =>
                   (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k) ->
                   a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k

    killRange11 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                   , KillRange e, KillRange f, KillRange g, KillRange h
                   , KillRange i, KillRange j, KillRange k ) =>
                   (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l) ->
                   a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l

    killRange12 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                   , KillRange e, KillRange f, KillRange g, KillRange h
                   , KillRange i, KillRange j, KillRange k, KillRange l ) =>
                   (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m) ->
                   a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m

    killRange13 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                   , KillRange e, KillRange f, KillRange g, KillRange h
                   , KillRange i, KillRange j, KillRange k, KillRange l
                   , KillRange m ) =>
                   (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n) ->
                   a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n

    killRange14 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                   , KillRange e, KillRange f, KillRange g, KillRange h
                   , KillRange i, KillRange j, KillRange k, KillRange l
                   , KillRange m, KillRange n ) =>
                   (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o) ->
                   a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o

    killRange15 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                   , KillRange e, KillRange f, KillRange g, KillRange h
                   , KillRange i, KillRange j, KillRange k, KillRange l
                   , KillRange m, KillRange n, KillRange o ) =>
                   (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p) ->
                   a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p

    killRange16 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                   , KillRange e, KillRange f, KillRange g, KillRange h
                   , KillRange i, KillRange j, KillRange k, KillRange l
                   , KillRange m, KillRange n, KillRange o, KillRange p ) =>
                   (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q) ->
                   a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q

    killRange17 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                   , KillRange e, KillRange f, KillRange g, KillRange h
                   , KillRange i, KillRange j, KillRange k, KillRange l
                   , KillRange m, KillRange n, KillRange o, KillRange p
                   , KillRange q ) =>
                   (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r) ->
                   a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r

    killRange18 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                   , KillRange e, KillRange f, KillRange g, KillRange h
                   , KillRange i, KillRange j, KillRange k, KillRange l
                   , KillRange m, KillRange n, KillRange o, KillRange p
                   , KillRange q, KillRange r ) =>
                   (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s) ->
                   a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s

    killRange19 :: ( KillRange a, KillRange b, KillRange c, KillRange d
                   , KillRange e, KillRange f, KillRange g, KillRange h
                   , KillRange i, KillRange j, KillRange k, KillRange l
                   , KillRange m, KillRange n, KillRange o, KillRange p
                   , KillRange q, KillRange r, KillRange s ) =>
                   (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t) ->
                   a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t

    killRange1 :: forall a b. KillRange a => (a -> b) -> a -> b
    killRange1  a -> b
    f a
    a = a -> b
    f (KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange2 :: forall a b c.
    (KillRange a, KillRange b) =>
    (a -> b -> c) -> a -> b -> c
    killRange2  a -> b -> c
    f a
    a = (b -> c) -> b -> c
    forall a b. KillRange a => (a -> b) -> a -> b
    killRange1 (a -> b -> c
    f (a -> b -> c) -> a -> b -> c
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange3 :: forall a b c d.
    (KillRange a, KillRange b, KillRange c) =>
    (a -> b -> c -> d) -> a -> b -> c -> d
    killRange3  a -> b -> c -> d
    f a
    a = (b -> c -> d) -> b -> c -> d
    forall a b c.
    (KillRange a, KillRange b) =>
    (a -> b -> c) -> a -> b -> c
    killRange2 (a -> b -> c -> d
    f (a -> b -> c -> d) -> a -> b -> c -> d
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange4 :: forall a b c d e.
    (KillRange a, KillRange b, KillRange c, KillRange d) =>
    (a -> b -> c -> d -> e) -> a -> b -> c -> d -> e
    killRange4  a -> b -> c -> d -> e
    f a
    a = (b -> c -> d -> e) -> b -> c -> d -> e
    forall a b c d.
    (KillRange a, KillRange b, KillRange c) =>
    (a -> b -> c -> d) -> a -> b -> c -> d
    killRange3 (a -> b -> c -> d -> e
    f (a -> b -> c -> d -> e) -> a -> b -> c -> d -> e
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange5 :: forall a b c d e f.
    (KillRange a, KillRange b, KillRange c, KillRange d,
     KillRange e) =>
    (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> f
    killRange5  a -> b -> c -> d -> e -> f
    f a
    a = (b -> c -> d -> e -> f) -> b -> c -> d -> e -> f
    forall a b c d e.
    (KillRange a, KillRange b, KillRange c, KillRange d) =>
    (a -> b -> c -> d -> e) -> a -> b -> c -> d -> e
    killRange4 (a -> b -> c -> d -> e -> f
    f (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> f
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange6 :: forall a b c d e f g.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f) =>
    (a -> b -> c -> d -> e -> f -> g)
    -> a -> b -> c -> d -> e -> f -> g
    killRange6  a -> b -> c -> d -> e -> f -> g
    f a
    a = (b -> c -> d -> e -> f -> g) -> b -> c -> d -> e -> f -> g
    forall a b c d e f.
    (KillRange a, KillRange b, KillRange c, KillRange d,
     KillRange e) =>
    (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> f
    killRange5 (a -> b -> c -> d -> e -> f -> g
    f (a -> b -> c -> d -> e -> f -> g)
    -> a -> b -> c -> d -> e -> f -> g
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange7 :: forall a b c d e f g h.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g) =>
    (a -> b -> c -> d -> e -> f -> g -> h)
    -> a -> b -> c -> d -> e -> f -> g -> h
    killRange7  a -> b -> c -> d -> e -> f -> g -> h
    f a
    a = (b -> c -> d -> e -> f -> g -> h)
    -> b -> c -> d -> e -> f -> g -> h
    forall a b c d e f g.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f) =>
    (a -> b -> c -> d -> e -> f -> g)
    -> a -> b -> c -> d -> e -> f -> g
    killRange6 (a -> b -> c -> d -> e -> f -> g -> h
    f (a -> b -> c -> d -> e -> f -> g -> h)
    -> a -> b -> c -> d -> e -> f -> g -> h
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange8 :: forall a b c d e f g h i.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h) =>
    (a -> b -> c -> d -> e -> f -> g -> h -> i)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i
    killRange8  a -> b -> c -> d -> e -> f -> g -> h -> i
    f a
    a = (b -> c -> d -> e -> f -> g -> h -> i)
    -> b -> c -> d -> e -> f -> g -> h -> i
    forall a b c d e f g h.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g) =>
    (a -> b -> c -> d -> e -> f -> g -> h)
    -> a -> b -> c -> d -> e -> f -> g -> h
    killRange7 (a -> b -> c -> d -> e -> f -> g -> h -> i
    f (a -> b -> c -> d -> e -> f -> g -> h -> i)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange9 :: forall a b c d e f g h i j.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i) =>
    (a -> b -> c -> d -> e -> f -> g -> h -> i -> j)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j
    killRange9  a -> b -> c -> d -> e -> f -> g -> h -> i -> j
    f a
    a = (b -> c -> d -> e -> f -> g -> h -> i -> j)
    -> b -> c -> d -> e -> f -> g -> h -> i -> j
    forall a b c d e f g h i.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h) =>
    (a -> b -> c -> d -> e -> f -> g -> h -> i)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i
    killRange8 (a -> b -> c -> d -> e -> f -> g -> h -> i -> j
    f (a -> b -> c -> d -> e -> f -> g -> h -> i -> j)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange10 :: forall a b c d e f g h i j k.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j) =>
    (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k
    killRange10 a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k
    f a
    a = (b -> c -> d -> e -> f -> g -> h -> i -> j -> k)
    -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k
    forall a b c d e f g h i j.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i) =>
    (a -> b -> c -> d -> e -> f -> g -> h -> i -> j)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j
    killRange9 (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k
    f (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange11 :: forall a b c d e f g h i j k l.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k) =>
    (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l
    killRange11 a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l
    f a
    a = (b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l)
    -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l
    forall a b c d e f g h i j k.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j) =>
    (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k
    killRange10 (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l
    f (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange12 :: forall a b c d e f g h i j k l m.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l) =>
    (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m
    killRange12 a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m
    f a
    a = (b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m)
    -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m
    forall a b c d e f g h i j k l.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k) =>
    (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l
    killRange11 (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m
    f (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange13 :: forall a b c d e f g h i j k l m n.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m) =>
    (a
     -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    killRange13 a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n
    f a
    a = (b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n)
    -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n
    forall a b c d e f g h i j k l m.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l) =>
    (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m
    killRange12 (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n
    f (a
     -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange14 :: forall a b c d e f g h i j k l m n o.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    killRange14 a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    f a
    a = (b
     -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o)
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    forall a b c d e f g h i j k l m n.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m) =>
    (a
     -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    killRange13 (a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    f (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange15 :: forall a b c d e f g h i j k l m n o p.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n, KillRange o) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    killRange15 a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    f a
    a = (b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p)
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    forall a b c d e f g h i j k l m n o.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    killRange14 (a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    f (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange16 :: forall a b c d e f g h i j k l m n o p q.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n, KillRange o,
     KillRange p) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    killRange16 a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    f a
    a = (b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q)
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    forall a b c d e f g h i j k l m n o p.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n, KillRange o) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    killRange15 (a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    f (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange17 :: forall a b c d e f g h i j k l m n o p q r.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n, KillRange o,
     KillRange p, KillRange q) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    killRange17 a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    f a
    a = (b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r)
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    forall a b c d e f g h i j k l m n o p q.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n, KillRange o,
     KillRange p) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    killRange16 (a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    f (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange18 :: forall a b c d e f g h i j k l m n o p q r s.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n, KillRange o,
     KillRange p, KillRange q, KillRange r) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r
     -> s)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    -> s
    killRange18 a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    -> s
    f a
    a = (b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r
     -> s)
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    -> s
    forall a b c d e f g h i j k l m n o p q r.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n, KillRange o,
     KillRange p, KillRange q) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    killRange17 (a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    -> s
    f (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r
     -> s)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    -> s
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)
    killRange19 :: forall a b c d e f g h i j k l m n o p q r s t.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n, KillRange o,
     KillRange p, KillRange q, KillRange r, KillRange s) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r
     -> s
     -> t)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    -> s
    -> t
    killRange19 a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    -> s
    -> t
    f a
    a = (b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r
     -> s
     -> t)
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    -> s
    -> t
    forall a b c d e f g h i j k l m n o p q r s.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n, KillRange o,
     KillRange p, KillRange q, KillRange r) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r
     -> s)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    -> s
    killRange18 (a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    -> s
    -> t
    f (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r
     -> s
     -> t)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    -> s
    -> t
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)

    instance KillRange Range where
      killRange :: Range -> Range
    killRange Range
    _ = Range
    forall a. Range' a
    noRange

    instance KillRange Void where
      killRange :: KillRangeT Void
    killRange = KillRangeT Void
    forall a. a -> a
    id

    instance KillRange () where
      killRange :: () -> ()
    killRange = () -> ()
    forall a. a -> a
    id

    instance KillRange Bool where
      killRange :: Bool -> Bool
    killRange = Bool -> Bool
    forall a. a -> a
    id

    instance KillRange Int where
      killRange :: KillRangeT Int
    killRange = KillRangeT Int
    forall a. a -> a
    id

    instance KillRange Integer where
      killRange :: KillRangeT Integer
    killRange = KillRangeT Integer
    forall a. a -> a
    id

    instance KillRange Permutation where
      killRange :: KillRangeT Permutation
    killRange = KillRangeT Permutation
    forall a. a -> a
    id

    -- | Overlaps with @KillRange [a]@.
    instance {-# OVERLAPPING #-} KillRange String where
      killRange :: ShowS
    killRange = ShowS
    forall a. a -> a
    id

    instance {-# OVERLAPPABLE #-} KillRange a => KillRange [a]
    instance {-# OVERLAPPABLE #-} KillRange a => KillRange (Map k a)

    instance KillRange a => KillRange (Drop a)
    instance KillRange a => KillRange (List1 a)
    instance KillRange a => KillRange (List2 a)
    instance KillRange a => KillRange (Maybe a)
    instance KillRange a => KillRange (Strict.Maybe a)

    instance {-# OVERLAPPABLE #-} (Ord a, KillRange a) => KillRange (Set a) where
      killRange :: KillRangeT (Set a)
    killRange = (a -> a) -> KillRangeT (Set a)
    forall b a. Ord b => (a -> b) -> Set a -> Set b
    Set.map a -> a
    forall a. KillRange a => KillRangeT a
    killRange

    instance (KillRange a, KillRange b) => KillRange (a, b) where
      killRange :: KillRangeT (a, b)
    killRange (a
    x, b
    y) = (KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    x, KillRangeT b
    forall a. KillRange a => KillRangeT a
    killRange b
    y)

    instance (KillRange a, KillRange b, KillRange c) =>
             KillRange (a, b, c) where
      killRange :: KillRangeT (a, b, c)
    killRange (a
    x, b
    y, c
    z) = (a -> b -> c -> (a, b, c)) -> a -> b -> c -> (a, b, c)
    forall a b c d.
    (KillRange a, KillRange b, KillRange c) =>
    (a -> b -> c -> d) -> a -> b -> c -> d
    killRange3 (,,) a
    x b
    y c
    z

    instance (KillRange a, KillRange b, KillRange c, KillRange d) =>
             KillRange (a, b, c, d) where
      killRange :: KillRangeT (a, b, c, d)
    killRange (a
    x, b
    y, c
    z, d
    u) = (a -> b -> c -> d -> (a, b, c, d))
    -> a -> b -> c -> d -> (a, b, c, d)
    forall a b c d e.
    (KillRange a, KillRange b, KillRange c, KillRange d) =>
    (a -> b -> c -> d -> e) -> a -> b -> c -> d -> e
    killRange4 (,,,) a
    x b
    y c
    z d
    u

    instance (KillRange a, KillRange b) => KillRange (Either a b) where
      killRange :: KillRangeT (Either a b)
    killRange (Left  a
    x) = a -> Either a b
    forall a b. a -> Either a b
    Left  (a -> Either a b) -> a -> Either a b
    forall a b. (a -> b) -> a -> b
    $ KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    x
      killRange (Right b
    x) = b -> Either a b
    forall a b. b -> Either a b
    Right (b -> Either a b) -> b -> Either a b
    forall a b. (a -> b) -> a -> b
    $ KillRangeT b
    forall a. KillRange a => KillRangeT a
    killRange b
    x

    ------------------------------------------------------------------------
    -- Printing
    ------------------------------------------------------------------------

    instance Pretty a => Pretty (Position' (Strict.Maybe a)) where
      pretty :: Position' (Maybe a) -> Doc
    pretty (Pn Maybe a
    Strict.Nothing  Int32
    _ Int32
    l Int32
    c) = Int32 -> Doc
    forall a. Pretty a => a -> Doc
    pretty Int32
    l Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Doc
    "," Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Int32 -> Doc
    forall a. Pretty a => a -> Doc
    pretty Int32
    c
      pretty (Pn (Strict.Just a
    f) Int32
    _ Int32
    l Int32
    c) =
        a -> Doc
    forall a. Pretty a => a -> Doc
    pretty a
    f Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Doc
    ":" Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Int32 -> Doc
    forall a. Pretty a => a -> Doc
    pretty Int32
    l Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Doc
    "," Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Int32 -> Doc
    forall a. Pretty a => a -> Doc
    pretty Int32
    c

    instance Pretty PositionWithoutFile where
      pretty :: PositionWithoutFile -> Doc
    pretty PositionWithoutFile
    p = Position -> Doc
    forall a. Pretty a => a -> Doc
    pretty (PositionWithoutFile
    p { srcFile :: SrcFile
    srcFile = SrcFile
    forall a. Maybe a
    Strict.Nothing } :: Position)

    instance Pretty IntervalWithoutFile where
      pretty :: IntervalWithoutFile -> Doc
    pretty (Interval PositionWithoutFile
    s PositionWithoutFile
    e) = Doc
    start Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Doc
    "-" Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Doc
    end
        where
          sl :: Int32
    sl = PositionWithoutFile -> Int32
    forall a. Position' a -> Int32
    posLine PositionWithoutFile
    s
          el :: Int32
    el = PositionWithoutFile -> Int32
    forall a. Position' a -> Int32
    posLine PositionWithoutFile
    e
          sc :: Int32
    sc = PositionWithoutFile -> Int32
    forall a. Position' a -> Int32
    posCol PositionWithoutFile
    s
          ec :: Int32
    ec = PositionWithoutFile -> Int32
    forall a. Position' a -> Int32
    posCol PositionWithoutFile
    e

          start :: Doc
          start :: Doc
    start = Int32 -> Doc
    forall a. Pretty a => a -> Doc
    pretty Int32
    sl Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Doc
    comma Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Int32 -> Doc
    forall a. Pretty a => a -> Doc
    pretty Int32
    sc

          Doc
    end :: Doc
            | Int32
    sl Int32 -> Int32 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int32
    el  = Int32 -> Doc
    forall a. Pretty a => a -> Doc
    pretty Int32
    ec
            | Bool
    otherwise = Int32 -> Doc
    forall a. Pretty a => a -> Doc
    pretty Int32
    el Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Doc
    comma Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Int32 -> Doc
    forall a. Pretty a => a -> Doc
    pretty Int32
    ec

    instance Pretty a => Pretty (Interval' (Strict.Maybe a)) where
      pretty :: Interval' (Maybe a) -> Doc
    pretty i :: Interval' (Maybe a)
    i@(Interval Position' (Maybe a)
    s Position' (Maybe a)
    _) = Doc
    file Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> IntervalWithoutFile -> Doc
    forall a. Pretty a => a -> Doc
    pretty (() -> Interval' (Maybe a) -> IntervalWithoutFile
    forall a b. a -> Interval' b -> Interval' a
    setIntervalFile () Interval' (Maybe a)
    i)
        where
          file :: Doc
          file :: Doc
    file = case Position' (Maybe a) -> Maybe a
    forall a. Position' a -> a
    srcFile Position' (Maybe a)
    s of
                   Maybe a
    Strict.Nothing -> Doc
    forall a. Null a => a
    empty
                   Strict.Just a
    f  -> a -> Doc
    forall a. Pretty a => a -> Doc
    pretty a
    f Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Doc
    colon

    instance Pretty a => Pretty (Range' (Strict.Maybe a)) where
      pretty :: Range' (Maybe a) -> Doc
    pretty Range' (Maybe a)
    r = Doc
    -> (Interval' (Maybe a) -> Doc)
    -> Maybe (Interval' (Maybe a))
    -> Doc
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Doc
    forall a. Null a => a
    empty Interval' (Maybe a) -> Doc
    forall a. Pretty a => a -> Doc
    pretty (Range' (Maybe a) -> Maybe (Interval' (Maybe a))
    forall a. Range' a -> Maybe (Interval' a)
    rangeToIntervalWithFile Range' (Maybe a)
    r)

    instance (Pretty a, HasRange a) => Pretty (PrintRange a) where
      pretty :: PrintRange a -> Doc
    pretty (PrintRange a
    a) = a -> Doc
    forall a. Pretty a => a -> Doc
    pretty a
    a Doc -> Doc -> Doc
    <+> Doc -> Doc
    parens (Doc
    "at" Doc -> Doc -> Doc
    <+> Range -> Doc
    forall a. Pretty a => a -> Doc
    pretty (a -> Range
    forall a. HasRange a => a -> Range
    getRange a
    a))

    {--------------------------------------------------------------------------
        Functions on positions and ranges
     --------------------------------------------------------------------------}

    -- | The first position in a file: position 1, line 1, column 1.
    startPos' :: a -> Position' a
    startPos' :: forall a. a -> Position' a
    startPos' a
    f = Pn :: forall a. a -> Int32 -> Int32 -> Int32 -> Position' a
    Pn
      { srcFile :: a
    srcFile = a
    f
      , posPos :: Int32
    posPos  = Int32
    1
      , posLine :: Int32
    posLine = Int32
    1
      , posCol :: Int32
    posCol  = Int32
    1
      }

    -- | The first position in a file: position 1, line 1, column 1.
    startPos :: Maybe AbsolutePath -> Position
    startPos :: Maybe AbsolutePath -> Position
    startPos = SrcFile -> Position
    forall a. a -> Position' a
    startPos' (SrcFile -> Position)
    -> (Maybe AbsolutePath -> SrcFile)
    -> Maybe AbsolutePath
    -> Position
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Maybe AbsolutePath -> SrcFile
    forall a. Maybe a -> Maybe a
    Strict.toStrict

    -- | Ranges between two unknown positions
    noRange :: Range' a
    noRange :: forall a. Range' a
    noRange = Range' a
    forall a. Range' a
    NoRange

    -- | Advance the position by one character.
    --   A newline character (@'\n'@) moves the position to the first
    --   character in the next line. Any other character moves the
    --   position to the next column.
    movePos :: Position' a -> Char -> Position' a
    movePos :: forall a. Position' a -> Char -> Position' a
    movePos (Pn a
    f Int32
    p Int32
    l Int32
    c) Char
    '\n' = a -> Int32 -> Int32 -> Int32 -> Position' a
    forall a. a -> Int32 -> Int32 -> Int32 -> Position' a
    Pn a
    f (Int32
    p Int32 -> Int32 -> Int32
    forall a. Num a => a -> a -> a
    + Int32
    1) (Int32
    l Int32 -> Int32 -> Int32
    forall a. Num a => a -> a -> a
    + Int32
    1) Int32
    1
    movePos (Pn a
    f Int32
    p Int32
    l Int32
    c) Char
    _    = a -> Int32 -> Int32 -> Int32 -> Position' a
    forall a. a -> Int32 -> Int32 -> Int32 -> Position' a
    Pn a
    f (Int32
    p Int32 -> Int32 -> Int32
    forall a. Num a => a -> a -> a
    + Int32
    1) Int32
    l (Int32
    c Int32 -> Int32 -> Int32
    forall a. Num a => a -> a -> a
    + Int32
    1)

    -- | Advance the position by a string.
    --
    --   > movePosByString = foldl' movePos
    movePosByString :: Position' a -> String -> Position' a
    movePosByString :: forall a. Position' a -> String -> Position' a
    movePosByString = (Position' a -> Char -> Position' a)
    -> Position' a -> String -> Position' a
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl' Position' a -> Char -> Position' a
    forall a. Position' a -> Char -> Position' a
    movePos

    -- | Backup the position by one character.
    --
    -- Precondition: The character must not be @'\n'@.
    backupPos :: Position' a -> Position' a
    backupPos :: forall a. Position' a -> Position' a
    backupPos (Pn a
    f Int32
    p Int32
    l Int32
    c) = a -> Int32 -> Int32 -> Int32 -> Position' a
    forall a. a -> Int32 -> Int32 -> Int32 -> Position' a
    Pn a
    f (Int32
    p Int32 -> Int32 -> Int32
    forall a. Num a => a -> a -> a
    - Int32
    1) Int32
    l (Int32
    c Int32 -> Int32 -> Int32
    forall a. Num a => a -> a -> a
    - Int32
    1)

    -- | Converts a file name and two positions to a range.
    posToRange' ::
      a -> PositionWithoutFile -> PositionWithoutFile -> Range' a
    posToRange' :: forall a.
    a -> PositionWithoutFile -> PositionWithoutFile -> Range' a
    posToRange' a
    f PositionWithoutFile
    p1 PositionWithoutFile
    p2 = a -> IntervalWithoutFile -> Range' a
    forall a. a -> IntervalWithoutFile -> Range' a
    intervalToRange a
    f (()
    -> PositionWithoutFile
    -> PositionWithoutFile
    -> IntervalWithoutFile
    forall a.
    a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a
    posToInterval () PositionWithoutFile
    p1 PositionWithoutFile
    p2)

    -- | Converts two positions to a range.
    --
    -- Precondition: The positions have to point to the same file.
    posToRange :: Position' a -> Position' a -> Range' a
    posToRange :: forall a. Position' a -> Position' a -> Range' a
    posToRange Position' a
    p1 Position' a
    p2 =
      a -> PositionWithoutFile -> PositionWithoutFile -> Range' a
    forall a.
    a -> PositionWithoutFile -> PositionWithoutFile -> Range' a
    posToRange' (Position' a -> a
    forall a. Position' a -> a
    srcFile Position' a
    p1) (Position' a
    p1 { srcFile :: ()
    srcFile = () }) (Position' a
    p2 { srcFile :: ()
    srcFile = () })

    -- | Converts a file name and an interval to a range.
    intervalToRange :: a -> IntervalWithoutFile -> Range' a
    intervalToRange :: forall a. a -> IntervalWithoutFile -> Range' a
    intervalToRange a
    f IntervalWithoutFile
    i = a -> Seq IntervalWithoutFile -> Range' a
    forall a. a -> Seq IntervalWithoutFile -> Range' a
    Range a
    f (IntervalWithoutFile -> Seq IntervalWithoutFile
    forall a. a -> Seq a
    Seq.singleton IntervalWithoutFile
    i)

    -- | Converts a range to an interval, if possible.
    rangeToIntervalWithFile :: Range' a -> Maybe (Interval' a)
    rangeToIntervalWithFile :: forall a. Range' a -> Maybe (Interval' a)
    rangeToIntervalWithFile Range' a
    NoRange      = Maybe (Interval' a)
    forall a. Maybe a
    Nothing
    rangeToIntervalWithFile (Range a
    f Seq IntervalWithoutFile
    is) = case (Seq IntervalWithoutFile -> ViewL IntervalWithoutFile
    forall a. Seq a -> ViewL a
    Seq.viewl Seq IntervalWithoutFile
    is, Seq IntervalWithoutFile -> ViewR IntervalWithoutFile
    forall a. Seq a -> ViewR a
    Seq.viewr Seq IntervalWithoutFile
    is) of
      (IntervalWithoutFile
    head Seq.:< Seq IntervalWithoutFile
    _, Seq IntervalWithoutFile
    _ Seq.:> IntervalWithoutFile
    last) -> Interval' a -> Maybe (Interval' a)
    forall a. a -> Maybe a
    Just (Interval' a -> Maybe (Interval' a))
    -> Interval' a -> Maybe (Interval' a)
    forall a b. (a -> b) -> a -> b
    $ a -> IntervalWithoutFile -> Interval' a
    forall a b. a -> Interval' b -> Interval' a
    setIntervalFile a
    f (IntervalWithoutFile -> Interval' a)
    -> IntervalWithoutFile -> Interval' a
    forall a b. (a -> b) -> a -> b
    $
                                          Interval :: forall a. Position' a -> Position' a -> Interval' a
    Interval { iStart :: PositionWithoutFile
    iStart = IntervalWithoutFile -> PositionWithoutFile
    forall a. Interval' a -> Position' a
    iStart IntervalWithoutFile
    head
                                                   , iEnd :: PositionWithoutFile
    iEnd   = IntervalWithoutFile -> PositionWithoutFile
    forall a. Interval' a -> Position' a
    iEnd   IntervalWithoutFile
    last
                                                   }
      (ViewL IntervalWithoutFile, ViewR IntervalWithoutFile)
    _                              -> Maybe (Interval' a)
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    -- | Converts a range to an interval, if possible. Note that the
    -- information about the source file is lost.
    rangeToInterval :: Range' a -> Maybe IntervalWithoutFile
    rangeToInterval :: forall a. Range' a -> Maybe IntervalWithoutFile
    rangeToInterval Range' a
    NoRange      = Maybe IntervalWithoutFile
    forall a. Maybe a
    Nothing
    rangeToInterval (Range a
    _ Seq IntervalWithoutFile
    is) = case (Seq IntervalWithoutFile -> ViewL IntervalWithoutFile
    forall a. Seq a -> ViewL a
    Seq.viewl Seq IntervalWithoutFile
    is, Seq IntervalWithoutFile -> ViewR IntervalWithoutFile
    forall a. Seq a -> ViewR a
    Seq.viewr Seq IntervalWithoutFile
    is) of
      (IntervalWithoutFile
    head Seq.:< Seq IntervalWithoutFile
    _, Seq IntervalWithoutFile
    _ Seq.:> IntervalWithoutFile
    last) -> IntervalWithoutFile -> Maybe IntervalWithoutFile
    forall a. a -> Maybe a
    Just (IntervalWithoutFile -> Maybe IntervalWithoutFile)
    -> IntervalWithoutFile -> Maybe IntervalWithoutFile
    forall a b. (a -> b) -> a -> b
    $
                                          Interval :: forall a. Position' a -> Position' a -> Interval' a
    Interval { iStart :: PositionWithoutFile
    iStart = IntervalWithoutFile -> PositionWithoutFile
    forall a. Interval' a -> Position' a
    iStart IntervalWithoutFile
    head
                                                   , iEnd :: PositionWithoutFile
    iEnd   = IntervalWithoutFile -> PositionWithoutFile
    forall a. Interval' a -> Position' a
    iEnd   IntervalWithoutFile
    last
                                                   }
      (ViewL IntervalWithoutFile, ViewR IntervalWithoutFile)
    _                              -> Maybe IntervalWithoutFile
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    -- | Returns the shortest continuous range containing the given one.
    continuous :: Range' a -> Range' a
    continuous :: forall a. Range' a -> Range' a
    continuous Range' a
    NoRange = Range' a
    forall a. Range' a
    NoRange
    continuous r :: Range' a
    r@(Range a
    f Seq IntervalWithoutFile
    _) = case Range' a -> Maybe IntervalWithoutFile
    forall a. Range' a -> Maybe IntervalWithoutFile
    rangeToInterval Range' a
    r of
      Maybe IntervalWithoutFile
    Nothing -> Range' a
    forall a. HasCallStack => a
    __IMPOSSIBLE__
      Just IntervalWithoutFile
    i  -> a -> IntervalWithoutFile -> Range' a
    forall a. a -> IntervalWithoutFile -> Range' a
    intervalToRange a
    f IntervalWithoutFile
    i

    -- | Removes gaps between intervals on the same line.
    continuousPerLine :: Ord a => Range' a -> Range' a
    continuousPerLine :: forall a. Ord a => Range' a -> Range' a
    continuousPerLine r :: Range' a
    r@Range' a
    NoRange     = Range' a
    r
    continuousPerLine r :: Range' a
    r@(Range a
    f Seq IntervalWithoutFile
    _) =
      a -> Seq IntervalWithoutFile -> Range' a
    forall a. a -> Seq IntervalWithoutFile -> Range' a
    Range a
    f (([IntervalWithoutFile]
     -> Maybe (IntervalWithoutFile, [IntervalWithoutFile]))
    -> [IntervalWithoutFile] -> Seq IntervalWithoutFile
    forall b a. (b -> Maybe (a, b)) -> b -> Seq a
    Seq.unfoldr [IntervalWithoutFile]
    -> Maybe (IntervalWithoutFile, [IntervalWithoutFile])
    forall {a}.
    Ord a =>
    [Interval' a] -> Maybe (Interval' a, [Interval' a])
    step (Range' a -> [IntervalWithoutFile]
    forall a. Range' a -> [IntervalWithoutFile]
    rangeIntervals Range' a
    r))
      where
      step :: [Interval' a] -> Maybe (Interval' a, [Interval' a])
    step []  = Maybe (Interval' a, [Interval' a])
    forall a. Maybe a
    Nothing
      step [Interval' a
    i] = (Interval' a, [Interval' a]) -> Maybe (Interval' a, [Interval' a])
    forall a. a -> Maybe a
    Just (Interval' a
    i, [])
      step (Interval' a
    i : is :: [Interval' a]
    is@(Interval' a
    j : [Interval' a]
    js))
        | Bool
    sameLine  = [Interval' a] -> Maybe (Interval' a, [Interval' a])
    step (Interval' a -> Interval' a -> Interval' a
    forall a. Ord a => Interval' a -> Interval' a -> Interval' a
    fuseIntervals Interval' a
    i Interval' a
    j Interval' a -> [Interval' a] -> [Interval' a]
    forall a. a -> [a] -> [a]
    : [Interval' a]
    js)
        | Bool
    otherwise = (Interval' a, [Interval' a]) -> Maybe (Interval' a, [Interval' a])
    forall a. a -> Maybe a
    Just (Interval' a
    i, [Interval' a]
    is)
        where
        sameLine :: Bool
    sameLine = Position' a -> Int32
    forall a. Position' a -> Int32
    posLine (Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    i) Int32 -> Int32 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Position' a -> Int32
    forall a. Position' a -> Int32
    posLine (Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    j)

    -- | The initial position in the range, if any.
    rStart' :: Range' a -> Maybe PositionWithoutFile
    rStart' :: forall a. Range' a -> Maybe PositionWithoutFile
    rStart' Range' a
    r = IntervalWithoutFile -> PositionWithoutFile
    forall a. Interval' a -> Position' a
    iStart (IntervalWithoutFile -> PositionWithoutFile)
    -> Maybe IntervalWithoutFile -> Maybe PositionWithoutFile
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Range' a -> Maybe IntervalWithoutFile
    forall a. Range' a -> Maybe IntervalWithoutFile
    rangeToInterval Range' a
    r

    -- | The initial position in the range, if any.
    rStart :: Range' a -> Maybe (Position' a)
    rStart :: forall a. Range' a -> Maybe (Position' a)
    rStart Range' a
    NoRange       = Maybe (Position' a)
    forall a. Maybe a
    Nothing
    rStart r :: Range' a
    r@(Range a
    f Seq IntervalWithoutFile
    _) = (\PositionWithoutFile
    p -> PositionWithoutFile
    p { srcFile :: a
    srcFile = a
    f }) (PositionWithoutFile -> Position' a)
    -> Maybe PositionWithoutFile -> Maybe (Position' a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Range' a -> Maybe PositionWithoutFile
    forall a. Range' a -> Maybe PositionWithoutFile
    rStart' Range' a
    r

    -- | The position after the final position in the range, if any.
    rEnd' :: Range' a -> Maybe PositionWithoutFile
    rEnd' :: forall a. Range' a -> Maybe PositionWithoutFile
    rEnd' Range' a
    r = IntervalWithoutFile -> PositionWithoutFile
    forall a. Interval' a -> Position' a
    iEnd (IntervalWithoutFile -> PositionWithoutFile)
    -> Maybe IntervalWithoutFile -> Maybe PositionWithoutFile
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Range' a -> Maybe IntervalWithoutFile
    forall a. Range' a -> Maybe IntervalWithoutFile
    rangeToInterval Range' a
    r

    -- | The position after the final position in the range, if any.
    rEnd :: Range' a -> Maybe (Position' a)
    rEnd :: forall a. Range' a -> Maybe (Position' a)
    rEnd Range' a
    NoRange       = Maybe (Position' a)
    forall a. Maybe a
    Nothing
    rEnd r :: Range' a
    r@(Range a
    f Seq IntervalWithoutFile
    _) = (\PositionWithoutFile
    p -> PositionWithoutFile
    p { srcFile :: a
    srcFile = a
    f }) (PositionWithoutFile -> Position' a)
    -> Maybe PositionWithoutFile -> Maybe (Position' a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Range' a -> Maybe PositionWithoutFile
    forall a. Range' a -> Maybe PositionWithoutFile
    rEnd' Range' a
    r

    -- | Finds the least interval which covers the arguments.
    --
    -- Precondition: The intervals must point to the same file.
    fuseIntervals :: Ord a => Interval' a -> Interval' a -> Interval' a
    fuseIntervals :: forall a. Ord a => Interval' a -> Interval' a -> Interval' a
    fuseIntervals Interval' a
    x Interval' a
    y = Interval :: forall a. Position' a -> Position' a -> Interval' a
    Interval { iStart :: Position' a
    iStart = Position' a
    s, iEnd :: Position' a
    iEnd = Position' a
    e }
        where
        s :: Position' a
    s = Position' a -> [Position' a] -> Position' a
    forall a. a -> [a] -> a
    headWithDefault Position' a
    forall a. HasCallStack => a
    __IMPOSSIBLE__ ([Position' a] -> Position' a) -> [Position' a] -> Position' a
    forall a b. (a -> b) -> a -> b
    $ [Position' a] -> [Position' a]
    forall a. Ord a => [a] -> [a]
    sort [Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    x, Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    y]
        e :: Position' a
    e = Position' a -> [Position' a] -> Position' a
    forall a. a -> [a] -> a
    lastWithDefault Position' a
    forall a. HasCallStack => a
    __IMPOSSIBLE__ ([Position' a] -> Position' a) -> [Position' a] -> Position' a
    forall a b. (a -> b) -> a -> b
    $ [Position' a] -> [Position' a]
    forall a. Ord a => [a] -> [a]
    sort [Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd   Interval' a
    x, Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd   Interval' a
    y]

    -- | @fuseRanges r r'@ unions the ranges @r@ and @r'@.
    --
    --   Meaning it finds the least range @r0@ that covers @r@ and @r'@.
    --
    -- Precondition: The ranges must point to the same file (or be empty).
    fuseRanges :: (Ord a) => Range' a -> Range' a -> Range' a
    fuseRanges :: forall a. Ord a => Range' a -> Range' a -> Range' a
    fuseRanges Range' a
    NoRange       Range' a
    is2           = Range' a
    is2
    fuseRanges Range' a
    is1           Range' a
    NoRange       = Range' a
    is1
    fuseRanges (Range a
    f Seq IntervalWithoutFile
    is1) (Range a
    _ Seq IntervalWithoutFile
    is2) = a -> Seq IntervalWithoutFile -> Range' a
    forall a. a -> Seq IntervalWithoutFile -> Range' a
    Range a
    f (Seq IntervalWithoutFile
    -> Seq IntervalWithoutFile -> Seq IntervalWithoutFile
    forall {a}.
    Ord a =>
    Seq (Interval' a) -> Seq (Interval' a) -> Seq (Interval' a)
    fuse Seq IntervalWithoutFile
    is1 Seq IntervalWithoutFile
    is2)
      where
      fuse :: Seq (Interval' a) -> Seq (Interval' a) -> Seq (Interval' a)
    fuse Seq (Interval' a)
    is1 Seq (Interval' a)
    is2 = case (Seq (Interval' a) -> ViewL (Interval' a)
    forall a. Seq a -> ViewL a
    Seq.viewl Seq (Interval' a)
    is1, Seq (Interval' a) -> ViewR (Interval' a)
    forall a. Seq a -> ViewR a
    Seq.viewr Seq (Interval' a)
    is1,
                           Seq (Interval' a) -> ViewL (Interval' a)
    forall a. Seq a -> ViewL a
    Seq.viewl Seq (Interval' a)
    is2, Seq (Interval' a) -> ViewR (Interval' a)
    forall a. Seq a -> ViewR a
    Seq.viewr Seq (Interval' a)
    is2) of
        (ViewL (Interval' a)
    Seq.EmptyL, ViewR (Interval' a)
    _, ViewL (Interval' a)
    _, ViewR (Interval' a)
    _) -> Seq (Interval' a)
    is2
        (ViewL (Interval' a)
    _, ViewR (Interval' a)
    _, ViewL (Interval' a)
    Seq.EmptyL, ViewR (Interval' a)
    _) -> Seq (Interval' a)
    is1
        (Interval' a
    s1 Seq.:< Seq (Interval' a)
    r1, Seq (Interval' a)
    l1 Seq.:> Interval' a
    e1, Interval' a
    s2 Seq.:< Seq (Interval' a)
    r2, Seq (Interval' a)
    l2 Seq.:> Interval' a
    e2)
            -- Special cases.
          | Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    e1 Position' a -> Position' a -> Bool
    forall a. Ord a => a -> a -> Bool
    <  Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    s2 -> Seq (Interval' a)
    is1 Seq (Interval' a) -> Seq (Interval' a) -> Seq (Interval' a)
    forall a. Seq a -> Seq a -> Seq a
    Seq.>< Seq (Interval' a)
    is2
          | Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    e2 Position' a -> Position' a -> Bool
    forall a. Ord a => a -> a -> Bool
    <  Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    s1 -> Seq (Interval' a)
    is2 Seq (Interval' a) -> Seq (Interval' a) -> Seq (Interval' a)
    forall a. Seq a -> Seq a -> Seq a
    Seq.>< Seq (Interval' a)
    is1
          | Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    e1 Position' a -> Position' a -> Bool
    forall a. Eq a => a -> a -> Bool
    == Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    s2 -> Seq (Interval' a)
    -> Interval' a
    -> Interval' a
    -> Seq (Interval' a)
    -> Seq (Interval' a)
    forall {a}.
    Seq (Interval' a)
    -> Interval' a
    -> Interval' a
    -> Seq (Interval' a)
    -> Seq (Interval' a)
    mergeTouching Seq (Interval' a)
    l1 Interval' a
    e1 Interval' a
    s2 Seq (Interval' a)
    r2
          | Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    e2 Position' a -> Position' a -> Bool
    forall a. Eq a => a -> a -> Bool
    == Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    s1 -> Seq (Interval' a)
    -> Interval' a
    -> Interval' a
    -> Seq (Interval' a)
    -> Seq (Interval' a)
    forall {a}.
    Seq (Interval' a)
    -> Interval' a
    -> Interval' a
    -> Seq (Interval' a)
    -> Seq (Interval' a)
    mergeTouching Seq (Interval' a)
    l2 Interval' a
    e2 Interval' a
    s1 Seq (Interval' a)
    r1
            -- General cases.
          | Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    s1 Position' a -> Position' a -> Bool
    forall a. Ord a => a -> a -> Bool
    <  Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    s2 -> Interval' a
    -> Seq (Interval' a)
    -> Interval' a
    -> Seq (Interval' a)
    -> Seq (Interval' a)
    outputLeftPrefix Interval' a
    s1 Seq (Interval' a)
    r1 Interval' a
    s2 Seq (Interval' a)
    is2
          | Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    s2 Position' a -> Position' a -> Bool
    forall a. Ord a => a -> a -> Bool
    <  Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    s1 -> Interval' a
    -> Seq (Interval' a)
    -> Interval' a
    -> Seq (Interval' a)
    -> Seq (Interval' a)
    outputLeftPrefix Interval' a
    s2 Seq (Interval' a)
    r2 Interval' a
    s1 Seq (Interval' a)
    is1
          | Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    s1 Position' a -> Position' a -> Bool
    forall a. Ord a => a -> a -> Bool
    <  Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd   Interval' a
    s2 -> Interval' a
    -> Seq (Interval' a)
    -> Interval' a
    -> Seq (Interval' a)
    -> Seq (Interval' a)
    fuseSome Interval' a
    s1 Seq (Interval' a)
    r1 Interval' a
    s2 Seq (Interval' a)
    r2
          | Bool
    otherwise            -> Interval' a
    -> Seq (Interval' a)
    -> Interval' a
    -> Seq (Interval' a)
    -> Seq (Interval' a)
    fuseSome Interval' a
    s2 Seq (Interval' a)
    r2 Interval' a
    s1 Seq (Interval' a)
    r1
        (ViewL (Interval' a), ViewR (Interval' a), ViewL (Interval' a),
     ViewR (Interval' a))
    _ -> Seq (Interval' a)
    forall a. HasCallStack => a
    __IMPOSSIBLE__

      mergeTouching :: Seq (Interval' a)
    -> Interval' a
    -> Interval' a
    -> Seq (Interval' a)
    -> Seq (Interval' a)
    mergeTouching Seq (Interval' a)
    l Interval' a
    e Interval' a
    s Seq (Interval' a)
    r = Seq (Interval' a)
    l Seq (Interval' a) -> Seq (Interval' a) -> Seq (Interval' a)
    forall a. Seq a -> Seq a -> Seq a
    Seq.>< Interval' a
    i Interval' a -> Seq (Interval' a) -> Seq (Interval' a)
    forall a. a -> Seq a -> Seq a
    Seq.<| Seq (Interval' a)
    r
        where
        i :: Interval' a
    i = Interval :: forall a. Position' a -> Position' a -> Interval' a
    Interval { iStart :: Position' a
    iStart = Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    e, iEnd :: Position' a
    iEnd = Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    s }

      -- The following two functions could use binary search instead of
      -- linear.

      outputLeftPrefix :: Interval' a
    -> Seq (Interval' a)
    -> Interval' a
    -> Seq (Interval' a)
    -> Seq (Interval' a)
    outputLeftPrefix Interval' a
    s1 Seq (Interval' a)
    r1 Interval' a
    s2 Seq (Interval' a)
    is2 = Interval' a
    s1 Interval' a -> Seq (Interval' a) -> Seq (Interval' a)
    forall a. a -> Seq a -> Seq a
    Seq.<| Seq (Interval' a)
    r1' Seq (Interval' a) -> Seq (Interval' a) -> Seq (Interval' a)
    forall a. Seq a -> Seq a -> Seq a
    Seq.>< Seq (Interval' a) -> Seq (Interval' a) -> Seq (Interval' a)
    fuse Seq (Interval' a)
    r1'' Seq (Interval' a)
    is2
        where
        (Seq (Interval' a)
    r1', Seq (Interval' a)
    r1'') = (Interval' a -> Bool)
    -> Seq (Interval' a) -> (Seq (Interval' a), Seq (Interval' a))
    forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
    Seq.spanl (\Interval' a
    s -> Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    s Position' a -> Position' a -> Bool
    forall a. Ord a => a -> a -> Bool
    < Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iStart Interval' a
    s2) Seq (Interval' a)
    r1

      fuseSome :: Interval' a
    -> Seq (Interval' a)
    -> Interval' a
    -> Seq (Interval' a)
    -> Seq (Interval' a)
    fuseSome Interval' a
    s1 Seq (Interval' a)
    r1 Interval' a
    s2 Seq (Interval' a)
    r2 = Seq (Interval' a) -> Seq (Interval' a) -> Seq (Interval' a)
    fuse Seq (Interval' a)
    r1' (Interval' a -> Interval' a -> Interval' a
    forall a. Ord a => Interval' a -> Interval' a -> Interval' a
    fuseIntervals Interval' a
    s1 Interval' a
    s2 Interval' a -> Seq (Interval' a) -> Seq (Interval' a)
    forall a. a -> Seq a -> Seq a
    Seq.<| Seq (Interval' a)
    r2)
        where
        r1' :: Seq (Interval' a)
    r1' = (Interval' a -> Bool) -> Seq (Interval' a) -> Seq (Interval' a)
    forall a. (a -> Bool) -> Seq a -> Seq a
    Seq.dropWhileL (\Interval' a
    s -> Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    s Position' a -> Position' a -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Interval' a -> Position' a
    forall a. Interval' a -> Position' a
    iEnd Interval' a
    s2) Seq (Interval' a)
    r1

    -- | Precondition: The ranges must point to the same file (or be
    -- empty).
    fuseRange :: (HasRange u, HasRange t) => u -> t -> Range
    fuseRange :: forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange u
    x t
    y = Range -> Range -> Range
    forall a. Ord a => Range' a -> Range' a -> Range' a
    fuseRanges (u -> Range
    forall a. HasRange a => a -> Range
    getRange u
    x) (t -> Range
    forall a. HasRange a => a -> Range
    getRange t
    y)

    -- | @beginningOf r@ is an empty range (a single, empty interval)
    -- positioned at the beginning of @r@. If @r@ does not have a
    -- beginning, then 'noRange' is returned.
    beginningOf :: Range -> Range
    beginningOf :: Range -> Range
    beginningOf Range
    NoRange       = Range
    forall a. Range' a
    NoRange
    beginningOf r :: Range
    r@(Range SrcFile
    f Seq IntervalWithoutFile
    _) = case Range -> Maybe PositionWithoutFile
    forall a. Range' a -> Maybe PositionWithoutFile
    rStart' Range
    r of
      Maybe PositionWithoutFile
    Nothing  -> Range
    forall a. HasCallStack => a
    __IMPOSSIBLE__
      Just PositionWithoutFile
    pos -> SrcFile -> PositionWithoutFile -> PositionWithoutFile -> Range
    forall a.
    a -> PositionWithoutFile -> PositionWithoutFile -> Range' a
    posToRange' SrcFile
    f PositionWithoutFile
    pos PositionWithoutFile
    pos

    -- | @beginningOfFile r@ is an empty range (a single, empty interval)
    -- at the beginning of @r@'s starting position's file. If there is no
    -- such position, then an empty range is returned.
    beginningOfFile :: Range -> Range
    beginningOfFile :: Range -> Range
    beginningOfFile Range
    NoRange     = Range
    forall a. Range' a
    NoRange
    beginningOfFile (Range SrcFile
    f Seq IntervalWithoutFile
    _) = SrcFile -> PositionWithoutFile -> PositionWithoutFile -> Range
    forall a.
    a -> PositionWithoutFile -> PositionWithoutFile -> Range' a
    posToRange' SrcFile
    f PositionWithoutFile
    p PositionWithoutFile
    p
      where p :: PositionWithoutFile
    p = () -> PositionWithoutFile
    forall a. a -> Position' a
    startPos' ()

    -- | @x \`withRangeOf\` y@ sets the range of @x@ to the range of @y@.
    withRangeOf :: (SetRange t, HasRange u) => t -> u -> t
    t
    x withRangeOf :: forall t u. (SetRange t, HasRange u) => t -> u -> t
    `withRangeOf` u
    y = Range -> t -> t
    forall a. SetRange a => Range -> a -> a
    setRange (u -> Range
    forall a. HasRange a => a -> Range
    getRange u
    y) t
    x

    -- | Interleaves two streams of ranged elements
    --
    --   It will report the conflicts as a list of conflicting pairs.
    --   In case of conflict, the element with the earliest start position
    --   is placed first. In case of a tie, the element with the earliest
    --   ending position is placed first. If both tie, the element from the
    --   first list is placed first.
    interleaveRanges :: (HasRange a) => [a] -> [a] -> ([a], [(a,a)])
    interleaveRanges :: forall a. HasRange a => [a] -> [a] -> ([a], [(a, a)])
    interleaveRanges [a]
    as [a]
    bs = Writer [(a, a)] [a] -> ([a], [(a, a)])
    forall w a. Writer w a -> (a, w)
    runWriter(Writer [(a, a)] [a] -> ([a], [(a, a)]))
    -> Writer [(a, a)] [a] -> ([a], [(a, a)])
    forall a b. (a -> b) -> a -> b
    $ [a] -> [a] -> Writer [(a, a)] [a]
    forall {f :: * -> *} {a}.
    (HasRange a, MonadWriter [(a, a)] f) =>
    [a] -> [a] -> f [a]
    go [a]
    as [a]
    bs
      where
        go :: [a] -> [a] -> f [a]
    go []         [a]
    as = [a] -> f [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [a]
    as
        go [a]
    as         [] = [a] -> f [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [a]
    as
        go as :: [a]
    as@(a
    a:[a]
    as') bs :: [a]
    bs@(a
    b:[a]
    bs') =
          let ra :: Range
    ra = a -> Range
    forall a. HasRange a => a -> Range
    getRange a
    a
              rb :: Range
    rb = a -> Range
    forall a. HasRange a => a -> Range
    getRange a
    b

              ra0 :: Maybe Position
    ra0 = Range -> Maybe Position
    forall a. Range' a -> Maybe (Position' a)
    rStart Range
    ra
              rb0 :: Maybe Position
    rb0 = Range -> Maybe Position
    forall a. Range' a -> Maybe (Position' a)
    rStart Range
    rb

              ra1 :: Maybe Position
    ra1 = Range -> Maybe Position
    forall a. Range' a -> Maybe (Position' a)
    rEnd Range
    ra
              rb1 :: Maybe Position
    rb1 = Range -> Maybe Position
    forall a. Range' a -> Maybe (Position' a)
    rEnd Range
    rb
          in
          if Maybe Position
    ra1 Maybe Position -> Maybe Position -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Maybe Position
    rb0 then
            (a
    aa -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :) ([a] -> [a]) -> f [a] -> f [a]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [a] -> [a] -> f [a]
    go [a]
    as' [a]
    bs
          else if Maybe Position
    rb1 Maybe Position -> Maybe Position -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Maybe Position
    ra0 then
            (a
    ba -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :) ([a] -> [a]) -> f [a] -> f [a]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [a] -> [a] -> f [a]
    go [a]
    as [a]
    bs'
          else do
            [(a, a)] -> f ()
    forall w (m :: * -> *). MonadWriter w m => w -> m ()
    tell [(a
    a,a
    b)]
            if Maybe Position
    ra0 Maybe Position -> Maybe Position -> Bool
    forall a. Ord a => a -> a -> Bool
    < Maybe Position
    rb0 Bool -> Bool -> Bool
    || (Maybe Position
    ra0 Maybe Position -> Maybe Position -> Bool
    forall a. Eq a => a -> a -> Bool
    == Maybe Position
    rb0 Bool -> Bool -> Bool
    && Maybe Position
    ra1 Maybe Position -> Maybe Position -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Maybe Position
    rb1) then
              (a
    aa -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :) ([a] -> [a]) -> f [a] -> f [a]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [a] -> [a] -> f [a]
    go [a]
    as' [a]
    bs
            else
              (a
    ba -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :) ([a] -> [a]) -> f [a] -> f [a]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [a] -> [a] -> f [a]
    go [a]
    as [a]
    bs'