    {-| Some common syntactic entities are defined in this module.
    -}
    module Agda.Syntax.Common
      ( module Agda.Syntax.Common
      , module Agda.Syntax.Common.KeywordRange
      , module Agda.Syntax.TopLevelModuleName.Boot
      , Induction(..)
      )
      where

    import Agda.Syntax.TopLevelModuleName.Boot

    import Prelude hiding (null)

    import Control.DeepSeq
    import Control.Arrow ((&&&))
    import Control.Applicative ((<|>), liftA2)

    import Data.Bifunctor
    import Data.ByteString.Char8 (ByteString)
    import qualified Data.ByteString.Char8 as ByteString
    import qualified Data.Foldable as Fold
    import Data.Function (on)
    import Data.Hashable (Hashable(..))
    import qualified Data.Strict.Maybe as Strict
    import Data.Word
    import Data.IntSet (IntSet)
    import qualified Data.IntSet as IntSet
    import Data.HashSet (HashSet)
    import qualified Data.HashSet as HashSet
    import Data.Text (Text)

    import GHC.Generics (Generic)

    import Agda.Syntax.Common.Aspect (Induction(..))
    import Agda.Syntax.Common.KeywordRange
    import Agda.Syntax.Common.Pretty
    import Agda.Syntax.Concrete.Glyph
    import Agda.Syntax.Position

    import Agda.Utils.BiMap (HasTag(..))
    import Agda.Utils.Boolean (Boolean(fromBool), IsBool(toBool))
    import Agda.Utils.Float (toStringWithoutDotZero)
    import Agda.Utils.Functor
    import Agda.Utils.Lens
    import Agda.Utils.List  ( lastMaybe )
    import Agda.Utils.List1  ( List1, pattern (:|), (<|) )
    import qualified Agda.Utils.List1 as List1
    import Agda.Utils.Maybe
    import Agda.Utils.Null
    import Agda.Utils.PartialOrd
    import Agda.Utils.POMonoid

    import Agda.Utils.Impossible

    -- | Number @>= 0@.
    type Nat    = Int
    type Arity  = Nat

    -- | Number @>= 1@.
    type Nat1   = Nat

    ---------------------------------------------------------------------------
    -- * IsMain
    ---------------------------------------------------------------------------

    data IsMain = IsMain | NotMain
      deriving (IsMain -> IsMain -> Bool
    (IsMain -> IsMain -> Bool)
    -> (IsMain -> IsMain -> Bool) -> Eq IsMain
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IsMain -> IsMain -> Bool
    == :: IsMain -> IsMain -> Bool
    $c/= :: IsMain -> IsMain -> Bool
    /= :: IsMain -> IsMain -> Bool
    Eq, Int -> IsMain -> ShowS
    [IsMain] -> ShowS
    IsMain -> ArgName
    (Int -> IsMain -> ShowS)
    -> (IsMain -> ArgName) -> ([IsMain] -> ShowS) -> Show IsMain
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IsMain -> ShowS
    showsPrec :: Int -> IsMain -> ShowS
    $cshow :: IsMain -> ArgName
    show :: IsMain -> ArgName
    $cshowList :: [IsMain] -> ShowS
    showList :: [IsMain] -> ShowS
    Show)

    -- | Conjunctive semigroup ('NotMain' is absorbing).
    instance Semigroup IsMain where
      IsMain
    NotMain <> :: IsMain -> IsMain -> IsMain
    <> IsMain
    _ = IsMain
    NotMain
      IsMain
    _       <> IsMain
    NotMain = IsMain
    NotMain
      IsMain
    IsMain  <> IsMain
    IsMain = IsMain
    IsMain

    instance Monoid IsMain where
      mempty :: IsMain
    mempty = IsMain
    IsMain
      mappend :: IsMain -> IsMain -> IsMain
    mappend = IsMain -> IsMain -> IsMain
    forall a. Semigroup a => a -> a -> a
    (<>)

    ---------------------------------------------------------------------------
    -- * File
    ---------------------------------------------------------------------------

    data FileType = AgdaFileType | MdFileType | RstFileType | TexFileType | OrgFileType | TypstFileType | TreeFileType
      deriving (FileType -> FileType -> Bool
    (FileType -> FileType -> Bool)
    -> (FileType -> FileType -> Bool) -> Eq FileType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FileType -> FileType -> Bool
    == :: FileType -> FileType -> Bool
    $c/= :: FileType -> FileType -> Bool
    /= :: FileType -> FileType -> Bool
    Eq, Eq FileType
    Eq FileType =>
    (FileType -> FileType -> Ordering)
    -> (FileType -> FileType -> Bool)
    -> (FileType -> FileType -> Bool)
    -> (FileType -> FileType -> Bool)
    -> (FileType -> FileType -> Bool)
    -> (FileType -> FileType -> FileType)
    -> (FileType -> FileType -> FileType)
    -> Ord FileType
    FileType -> FileType -> Bool
    FileType -> FileType -> Ordering
    FileType -> FileType -> FileType
    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
    $ccompare :: FileType -> FileType -> Ordering
    compare :: FileType -> FileType -> Ordering
    $c< :: FileType -> FileType -> Bool
    < :: FileType -> FileType -> Bool
    $c<= :: FileType -> FileType -> Bool
    <= :: FileType -> FileType -> Bool
    $c> :: FileType -> FileType -> Bool
    > :: FileType -> FileType -> Bool
    $c>= :: FileType -> FileType -> Bool
    >= :: FileType -> FileType -> Bool
    $cmax :: FileType -> FileType -> FileType
    max :: FileType -> FileType -> FileType
    $cmin :: FileType -> FileType -> FileType
    min :: FileType -> FileType -> FileType
    Ord, Int -> FileType -> ShowS
    [FileType] -> ShowS
    FileType -> ArgName
    (Int -> FileType -> ShowS)
    -> (FileType -> ArgName) -> ([FileType] -> ShowS) -> Show FileType
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FileType -> ShowS
    showsPrec :: Int -> FileType -> ShowS
    $cshow :: FileType -> ArgName
    show :: FileType -> ArgName
    $cshowList :: [FileType] -> ShowS
    showList :: [FileType] -> ShowS
    Show, (forall x. FileType -> Rep FileType x)
    -> (forall x. Rep FileType x -> FileType) -> Generic FileType
    forall x. Rep FileType x -> FileType
    forall x. FileType -> Rep FileType x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. FileType -> Rep FileType x
    from :: forall x. FileType -> Rep FileType x
    $cto :: forall x. Rep FileType x -> FileType
    to :: forall x. Rep FileType x -> FileType
    Generic)

    instance Pretty FileType where
      pretty :: FileType -> Doc
    pretty = \case
        FileType
    AgdaFileType -> Doc
    "Agda"
        FileType
    MdFileType   -> Doc
    "Markdown"
        FileType
    RstFileType  -> Doc
    "ReStructedText"
        FileType
    TexFileType  -> Doc
    "LaTeX"
        FileType
    OrgFileType  -> Doc
    "org-mode"
        FileType
    TypstFileType -> Doc
    "Typst"
        FileType
    TreeFileType -> Doc
    "Forester"

    instance NFData FileType

    ---------------------------------------------------------------------------
    -- * Agda variants
    ---------------------------------------------------------------------------

    -- | Variants of Cubical Agda.

    data Cubical = CErased | CFull
        deriving (Cubical -> Cubical -> Bool
    (Cubical -> Cubical -> Bool)
    -> (Cubical -> Cubical -> Bool) -> Eq Cubical
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Cubical -> Cubical -> Bool
    == :: Cubical -> Cubical -> Bool
    $c/= :: Cubical -> Cubical -> Bool
    /= :: Cubical -> Cubical -> Bool
    Eq, Int -> Cubical -> ShowS
    [Cubical] -> ShowS
    Cubical -> ArgName
    (Int -> Cubical -> ShowS)
    -> (Cubical -> ArgName) -> ([Cubical] -> ShowS) -> Show Cubical
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Cubical -> ShowS
    showsPrec :: Int -> Cubical -> ShowS
    $cshow :: Cubical -> ArgName
    show :: Cubical -> ArgName
    $cshowList :: [Cubical] -> ShowS
    showList :: [Cubical] -> ShowS
    Show, (forall x. Cubical -> Rep Cubical x)
    -> (forall x. Rep Cubical x -> Cubical) -> Generic Cubical
    forall x. Rep Cubical x -> Cubical
    forall x. Cubical -> Rep Cubical x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Cubical -> Rep Cubical x
    from :: forall x. Cubical -> Rep Cubical x
    $cto :: forall x. Rep Cubical x -> Cubical
    to :: forall x. Rep Cubical x -> Cubical
    Generic)

    instance NFData Cubical

    cubicalOptionString :: Cubical -> String
    cubicalOptionString :: Cubical -> ArgName
    cubicalOptionString = \case
      Cubical
    CErased -> ArgName
    "--erased-cubical"
      Cubical
    CFull   -> ArgName
    "--cubical"

    -- | Agda variants.
    --
    -- Only some variants are tracked.

    data Language
      = WithoutK
      | WithK
      | Cubical Cubical
        deriving (Language -> Language -> Bool
    (Language -> Language -> Bool)
    -> (Language -> Language -> Bool) -> Eq Language
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Language -> Language -> Bool
    == :: Language -> Language -> Bool
    $c/= :: Language -> Language -> Bool
    /= :: Language -> Language -> Bool
    Eq, Int -> Language -> ShowS
    [Language] -> ShowS
    Language -> ArgName
    (Int -> Language -> ShowS)
    -> (Language -> ArgName) -> ([Language] -> ShowS) -> Show Language
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Language -> ShowS
    showsPrec :: Int -> Language -> ShowS
    $cshow :: Language -> ArgName
    show :: Language -> ArgName
    $cshowList :: [Language] -> ShowS
    showList :: [Language] -> ShowS
    Show, (forall x. Language -> Rep Language x)
    -> (forall x. Rep Language x -> Language) -> Generic Language
    forall x. Rep Language x -> Language
    forall x. Language -> Rep Language x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Language -> Rep Language x
    from :: forall x. Language -> Rep Language x
    $cto :: forall x. Rep Language x -> Language
    to :: forall x. Rep Language x -> Language
    Generic)

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

    instance NFData Language

    ---------------------------------------------------------------------------
    -- * Backends
    ---------------------------------------------------------------------------

    type BackendName = Text

    ---------------------------------------------------------------------------
    -- * Some enums
    ---------------------------------------------------------------------------

    -- | Distinguish constructors from pattern synonyms.

    data ConstructorOrPatternSynonym = IsConstructor | IsPatternSynonym
      deriving (Int -> ConstructorOrPatternSynonym -> ShowS
    [ConstructorOrPatternSynonym] -> ShowS
    ConstructorOrPatternSynonym -> ArgName
    (Int -> ConstructorOrPatternSynonym -> ShowS)
    -> (ConstructorOrPatternSynonym -> ArgName)
    -> ([ConstructorOrPatternSynonym] -> ShowS)
    -> Show ConstructorOrPatternSynonym
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ConstructorOrPatternSynonym -> ShowS
    showsPrec :: Int -> ConstructorOrPatternSynonym -> ShowS
    $cshow :: ConstructorOrPatternSynonym -> ArgName
    show :: ConstructorOrPatternSynonym -> ArgName
    $cshowList :: [ConstructorOrPatternSynonym] -> ShowS
    showList :: [ConstructorOrPatternSynonym] -> ShowS
    Show, (forall x.
     ConstructorOrPatternSynonym -> Rep ConstructorOrPatternSynonym x)
    -> (forall x.
        Rep ConstructorOrPatternSynonym x -> ConstructorOrPatternSynonym)
    -> Generic ConstructorOrPatternSynonym
    forall x.
    Rep ConstructorOrPatternSynonym x -> ConstructorOrPatternSynonym
    forall x.
    ConstructorOrPatternSynonym -> Rep ConstructorOrPatternSynonym x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x.
    ConstructorOrPatternSynonym -> Rep ConstructorOrPatternSynonym x
    from :: forall x.
    ConstructorOrPatternSynonym -> Rep ConstructorOrPatternSynonym x
    $cto :: forall x.
    Rep ConstructorOrPatternSynonym x -> ConstructorOrPatternSynonym
    to :: forall x.
    Rep ConstructorOrPatternSynonym x -> ConstructorOrPatternSynonym
    Generic, Int -> ConstructorOrPatternSynonym
    ConstructorOrPatternSynonym -> Int
    ConstructorOrPatternSynonym -> [ConstructorOrPatternSynonym]
    ConstructorOrPatternSynonym -> ConstructorOrPatternSynonym
    ConstructorOrPatternSynonym
    -> ConstructorOrPatternSynonym -> [ConstructorOrPatternSynonym]
    ConstructorOrPatternSynonym
    -> ConstructorOrPatternSynonym
    -> ConstructorOrPatternSynonym
    -> [ConstructorOrPatternSynonym]
    (ConstructorOrPatternSynonym -> ConstructorOrPatternSynonym)
    -> (ConstructorOrPatternSynonym -> ConstructorOrPatternSynonym)
    -> (Int -> ConstructorOrPatternSynonym)
    -> (ConstructorOrPatternSynonym -> Int)
    -> (ConstructorOrPatternSynonym -> [ConstructorOrPatternSynonym])
    -> (ConstructorOrPatternSynonym
        -> ConstructorOrPatternSynonym -> [ConstructorOrPatternSynonym])
    -> (ConstructorOrPatternSynonym
        -> ConstructorOrPatternSynonym -> [ConstructorOrPatternSynonym])
    -> (ConstructorOrPatternSynonym
        -> ConstructorOrPatternSynonym
        -> ConstructorOrPatternSynonym
        -> [ConstructorOrPatternSynonym])
    -> Enum ConstructorOrPatternSynonym
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: ConstructorOrPatternSynonym -> ConstructorOrPatternSynonym
    succ :: ConstructorOrPatternSynonym -> ConstructorOrPatternSynonym
    $cpred :: ConstructorOrPatternSynonym -> ConstructorOrPatternSynonym
    pred :: ConstructorOrPatternSynonym -> ConstructorOrPatternSynonym
    $ctoEnum :: Int -> ConstructorOrPatternSynonym
    toEnum :: Int -> ConstructorOrPatternSynonym
    $cfromEnum :: ConstructorOrPatternSynonym -> Int
    fromEnum :: ConstructorOrPatternSynonym -> Int
    $cenumFrom :: ConstructorOrPatternSynonym -> [ConstructorOrPatternSynonym]
    enumFrom :: ConstructorOrPatternSynonym -> [ConstructorOrPatternSynonym]
    $cenumFromThen :: ConstructorOrPatternSynonym
    -> ConstructorOrPatternSynonym -> [ConstructorOrPatternSynonym]
    enumFromThen :: ConstructorOrPatternSynonym
    -> ConstructorOrPatternSynonym -> [ConstructorOrPatternSynonym]
    $cenumFromTo :: ConstructorOrPatternSynonym
    -> ConstructorOrPatternSynonym -> [ConstructorOrPatternSynonym]
    enumFromTo :: ConstructorOrPatternSynonym
    -> ConstructorOrPatternSynonym -> [ConstructorOrPatternSynonym]
    $cenumFromThenTo :: ConstructorOrPatternSynonym
    -> ConstructorOrPatternSynonym
    -> ConstructorOrPatternSynonym
    -> [ConstructorOrPatternSynonym]
    enumFromThenTo :: ConstructorOrPatternSynonym
    -> ConstructorOrPatternSynonym
    -> ConstructorOrPatternSynonym
    -> [ConstructorOrPatternSynonym]
    Enum, ConstructorOrPatternSynonym
    ConstructorOrPatternSynonym
    -> ConstructorOrPatternSynonym
    -> Bounded ConstructorOrPatternSynonym
    forall a. a -> a -> Bounded a
    $cminBound :: ConstructorOrPatternSynonym
    minBound :: ConstructorOrPatternSynonym
    $cmaxBound :: ConstructorOrPatternSynonym
    maxBound :: ConstructorOrPatternSynonym
    Bounded)

    instance Pretty ConstructorOrPatternSynonym where
      pretty :: ConstructorOrPatternSynonym -> Doc
    pretty = \case
        ConstructorOrPatternSynonym
    IsConstructor    -> Doc
    "constructor"
        ConstructorOrPatternSynonym
    IsPatternSynonym -> Doc
    "pattern synonym"

    instance NFData ConstructorOrPatternSynonym

    -- | Distinguish parsing a DISPLAY pragma from an ordinary left hand side.

    data DisplayLHS = YesDisplayLHS | NoDisplayLHS
      deriving (DisplayLHS -> DisplayLHS -> Bool
    (DisplayLHS -> DisplayLHS -> Bool)
    -> (DisplayLHS -> DisplayLHS -> Bool) -> Eq DisplayLHS
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DisplayLHS -> DisplayLHS -> Bool
    == :: DisplayLHS -> DisplayLHS -> Bool
    $c/= :: DisplayLHS -> DisplayLHS -> Bool
    /= :: DisplayLHS -> DisplayLHS -> Bool
    Eq, Int -> DisplayLHS -> ShowS
    [DisplayLHS] -> ShowS
    DisplayLHS -> ArgName
    (Int -> DisplayLHS -> ShowS)
    -> (DisplayLHS -> ArgName)
    -> ([DisplayLHS] -> ShowS)
    -> Show DisplayLHS
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DisplayLHS -> ShowS
    showsPrec :: Int -> DisplayLHS -> ShowS
    $cshow :: DisplayLHS -> ArgName
    show :: DisplayLHS -> ArgName
    $cshowList :: [DisplayLHS] -> ShowS
    showList :: [DisplayLHS] -> ShowS
    Show, (forall x. DisplayLHS -> Rep DisplayLHS x)
    -> (forall x. Rep DisplayLHS x -> DisplayLHS) -> Generic DisplayLHS
    forall x. Rep DisplayLHS x -> DisplayLHS
    forall x. DisplayLHS -> Rep DisplayLHS x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DisplayLHS -> Rep DisplayLHS x
    from :: forall x. DisplayLHS -> Rep DisplayLHS x
    $cto :: forall x. Rep DisplayLHS x -> DisplayLHS
    to :: forall x. Rep DisplayLHS x -> DisplayLHS
    Generic, Int -> DisplayLHS
    DisplayLHS -> Int
    DisplayLHS -> [DisplayLHS]
    DisplayLHS -> DisplayLHS
    DisplayLHS -> DisplayLHS -> [DisplayLHS]
    DisplayLHS -> DisplayLHS -> DisplayLHS -> [DisplayLHS]
    (DisplayLHS -> DisplayLHS)
    -> (DisplayLHS -> DisplayLHS)
    -> (Int -> DisplayLHS)
    -> (DisplayLHS -> Int)
    -> (DisplayLHS -> [DisplayLHS])
    -> (DisplayLHS -> DisplayLHS -> [DisplayLHS])
    -> (DisplayLHS -> DisplayLHS -> [DisplayLHS])
    -> (DisplayLHS -> DisplayLHS -> DisplayLHS -> [DisplayLHS])
    -> Enum DisplayLHS
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: DisplayLHS -> DisplayLHS
    succ :: DisplayLHS -> DisplayLHS
    $cpred :: DisplayLHS -> DisplayLHS
    pred :: DisplayLHS -> DisplayLHS
    $ctoEnum :: Int -> DisplayLHS
    toEnum :: Int -> DisplayLHS
    $cfromEnum :: DisplayLHS -> Int
    fromEnum :: DisplayLHS -> Int
    $cenumFrom :: DisplayLHS -> [DisplayLHS]
    enumFrom :: DisplayLHS -> [DisplayLHS]
    $cenumFromThen :: DisplayLHS -> DisplayLHS -> [DisplayLHS]
    enumFromThen :: DisplayLHS -> DisplayLHS -> [DisplayLHS]
    $cenumFromTo :: DisplayLHS -> DisplayLHS -> [DisplayLHS]
    enumFromTo :: DisplayLHS -> DisplayLHS -> [DisplayLHS]
    $cenumFromThenTo :: DisplayLHS -> DisplayLHS -> DisplayLHS -> [DisplayLHS]
    enumFromThenTo :: DisplayLHS -> DisplayLHS -> DisplayLHS -> [DisplayLHS]
    Enum, DisplayLHS
    DisplayLHS -> DisplayLHS -> Bounded DisplayLHS
    forall a. a -> a -> Bounded a
    $cminBound :: DisplayLHS
    minBound :: DisplayLHS
    $cmaxBound :: DisplayLHS
    maxBound :: DisplayLHS
    Bounded)

    instance Boolean DisplayLHS where
      fromBool :: Bool -> DisplayLHS
    fromBool = \case
        Bool
    True -> DisplayLHS
    YesDisplayLHS
        Bool
    False -> DisplayLHS
    NoDisplayLHS

    instance IsBool DisplayLHS where
      toBool :: DisplayLHS -> Bool
    toBool = \case
        DisplayLHS
    YesDisplayLHS -> Bool
    True
        DisplayLHS
    NoDisplayLHS -> Bool
    False

    -- | Expression kinds: Expressions or patterns.

    data ExprKind = IsExpr | IsPattern
      deriving (ExprKind -> ExprKind -> Bool
    (ExprKind -> ExprKind -> Bool)
    -> (ExprKind -> ExprKind -> Bool) -> Eq ExprKind
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ExprKind -> ExprKind -> Bool
    == :: ExprKind -> ExprKind -> Bool
    $c/= :: ExprKind -> ExprKind -> Bool
    /= :: ExprKind -> ExprKind -> Bool
    Eq, Int -> ExprKind -> ShowS
    [ExprKind] -> ShowS
    ExprKind -> ArgName
    (Int -> ExprKind -> ShowS)
    -> (ExprKind -> ArgName) -> ([ExprKind] -> ShowS) -> Show ExprKind
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ExprKind -> ShowS
    showsPrec :: Int -> ExprKind -> ShowS
    $cshow :: ExprKind -> ArgName
    show :: ExprKind -> ArgName
    $cshowList :: [ExprKind] -> ShowS
    showList :: [ExprKind] -> ShowS
    Show)

    ---------------------------------------------------------------------------
    -- * Record Directives
    ---------------------------------------------------------------------------

    data RecordDirectives' a = RecordDirectives
      { forall a. RecordDirectives' a -> Maybe (Ranged Induction)
    recInductive   :: Maybe (Ranged Induction)
      , forall a. RecordDirectives' a -> Maybe (Ranged HasEta0)
    recHasEta      :: Maybe (Ranged HasEta0)
      , forall a. RecordDirectives' a -> Maybe Range
    recPattern     :: Maybe Range
      , forall a. RecordDirectives' a -> a
    recConstructor :: a
      } deriving ((forall a b.
     (a -> b) -> RecordDirectives' a -> RecordDirectives' b)
    -> (forall a b. a -> RecordDirectives' b -> RecordDirectives' a)
    -> Functor RecordDirectives'
    forall a b. a -> RecordDirectives' b -> RecordDirectives' a
    forall a b. (a -> b) -> RecordDirectives' a -> RecordDirectives' b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> RecordDirectives' a -> RecordDirectives' b
    fmap :: forall a b. (a -> b) -> RecordDirectives' a -> RecordDirectives' b
    $c<$ :: forall a b. a -> RecordDirectives' b -> RecordDirectives' a
    <$ :: forall a b. a -> RecordDirectives' b -> RecordDirectives' a
    Functor, Int -> RecordDirectives' a -> ShowS
    [RecordDirectives' a] -> ShowS
    RecordDirectives' a -> ArgName
    (Int -> RecordDirectives' a -> ShowS)
    -> (RecordDirectives' a -> ArgName)
    -> ([RecordDirectives' a] -> ShowS)
    -> Show (RecordDirectives' a)
    forall a. Show a => Int -> RecordDirectives' a -> ShowS
    forall a. Show a => [RecordDirectives' a] -> ShowS
    forall a. Show a => RecordDirectives' a -> ArgName
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> RecordDirectives' a -> ShowS
    showsPrec :: Int -> RecordDirectives' a -> ShowS
    $cshow :: forall a. Show a => RecordDirectives' a -> ArgName
    show :: RecordDirectives' a -> ArgName
    $cshowList :: forall a. Show a => [RecordDirectives' a] -> ShowS
    showList :: [RecordDirectives' a] -> ShowS
    Show, RecordDirectives' a -> RecordDirectives' a -> Bool
    (RecordDirectives' a -> RecordDirectives' a -> Bool)
    -> (RecordDirectives' a -> RecordDirectives' a -> Bool)
    -> Eq (RecordDirectives' a)
    forall a.
    Eq a =>
    RecordDirectives' a -> RecordDirectives' a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a.
    Eq a =>
    RecordDirectives' a -> RecordDirectives' a -> Bool
    == :: RecordDirectives' a -> RecordDirectives' a -> Bool
    $c/= :: forall a.
    Eq a =>
    RecordDirectives' a -> RecordDirectives' a -> Bool
    /= :: RecordDirectives' a -> RecordDirectives' a -> Bool
    Eq, (forall m. Monoid m => RecordDirectives' m -> m)
    -> (forall m a. Monoid m => (a -> m) -> RecordDirectives' a -> m)
    -> (forall m a. Monoid m => (a -> m) -> RecordDirectives' a -> m)
    -> (forall a b. (a -> b -> b) -> b -> RecordDirectives' a -> b)
    -> (forall a b. (a -> b -> b) -> b -> RecordDirectives' a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RecordDirectives' a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RecordDirectives' a -> b)
    -> (forall a. (a -> a -> a) -> RecordDirectives' a -> a)
    -> (forall a. (a -> a -> a) -> RecordDirectives' a -> a)
    -> (forall a. RecordDirectives' a -> [a])
    -> (forall a. RecordDirectives' a -> Bool)
    -> (forall a. RecordDirectives' a -> Int)
    -> (forall a. Eq a => a -> RecordDirectives' a -> Bool)
    -> (forall a. Ord a => RecordDirectives' a -> a)
    -> (forall a. Ord a => RecordDirectives' a -> a)
    -> (forall a. Num a => RecordDirectives' a -> a)
    -> (forall a. Num a => RecordDirectives' a -> a)
    -> Foldable RecordDirectives'
    forall a. Eq a => a -> RecordDirectives' a -> Bool
    forall a. Num a => RecordDirectives' a -> a
    forall a. Ord a => RecordDirectives' a -> a
    forall m. Monoid m => RecordDirectives' m -> m
    forall a. RecordDirectives' a -> Bool
    forall a. RecordDirectives' a -> Int
    forall a. RecordDirectives' a -> [a]
    forall a. (a -> a -> a) -> RecordDirectives' a -> a
    forall m a. Monoid m => (a -> m) -> RecordDirectives' a -> m
    forall b a. (b -> a -> b) -> b -> RecordDirectives' a -> b
    forall a b. (a -> b -> b) -> b -> RecordDirectives' 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
    $cfold :: forall m. Monoid m => RecordDirectives' m -> m
    fold :: forall m. Monoid m => RecordDirectives' m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> RecordDirectives' a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> RecordDirectives' a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> RecordDirectives' a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> RecordDirectives' a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> RecordDirectives' a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> RecordDirectives' a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> RecordDirectives' a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> RecordDirectives' a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> RecordDirectives' a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> RecordDirectives' a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> RecordDirectives' a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> RecordDirectives' a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> RecordDirectives' a -> a
    foldr1 :: forall a. (a -> a -> a) -> RecordDirectives' a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> RecordDirectives' a -> a
    foldl1 :: forall a. (a -> a -> a) -> RecordDirectives' a -> a
    $ctoList :: forall a. RecordDirectives' a -> [a]
    toList :: forall a. RecordDirectives' a -> [a]
    $cnull :: forall a. RecordDirectives' a -> Bool
    null :: forall a. RecordDirectives' a -> Bool
    $clength :: forall a. RecordDirectives' a -> Int
    length :: forall a. RecordDirectives' a -> Int
    $celem :: forall a. Eq a => a -> RecordDirectives' a -> Bool
    elem :: forall a. Eq a => a -> RecordDirectives' a -> Bool
    $cmaximum :: forall a. Ord a => RecordDirectives' a -> a
    maximum :: forall a. Ord a => RecordDirectives' a -> a
    $cminimum :: forall a. Ord a => RecordDirectives' a -> a
    minimum :: forall a. Ord a => RecordDirectives' a -> a
    $csum :: forall a. Num a => RecordDirectives' a -> a
    sum :: forall a. Num a => RecordDirectives' a -> a
    $cproduct :: forall a. Num a => RecordDirectives' a -> a
    product :: forall a. Num a => RecordDirectives' a -> a
    Foldable, Functor RecordDirectives'
    Foldable RecordDirectives'
    (Functor RecordDirectives', Foldable RecordDirectives') =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> RecordDirectives' a -> f (RecordDirectives' b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        RecordDirectives' (f a) -> f (RecordDirectives' a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> RecordDirectives' a -> m (RecordDirectives' b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        RecordDirectives' (m a) -> m (RecordDirectives' a))
    -> Traversable RecordDirectives'
    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 =>
    RecordDirectives' (m a) -> m (RecordDirectives' a)
    forall (f :: * -> *) a.
    Applicative f =>
    RecordDirectives' (f a) -> f (RecordDirectives' a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RecordDirectives' a -> m (RecordDirectives' b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RecordDirectives' a -> f (RecordDirectives' b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RecordDirectives' a -> f (RecordDirectives' b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RecordDirectives' a -> f (RecordDirectives' b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    RecordDirectives' (f a) -> f (RecordDirectives' a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    RecordDirectives' (f a) -> f (RecordDirectives' a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RecordDirectives' a -> m (RecordDirectives' b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RecordDirectives' a -> m (RecordDirectives' b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    RecordDirectives' (m a) -> m (RecordDirectives' a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    RecordDirectives' (m a) -> m (RecordDirectives' a)
    Traversable)

    instance Null a => Null (RecordDirectives' a) where
      empty :: RecordDirectives' a
    empty = RecordDirectives' a
    forall a. Null a => RecordDirectives' a
    emptyRecordDirectives
      null :: RecordDirectives' a -> Bool
    null (RecordDirectives Maybe (Ranged Induction)
    a Maybe (Ranged HasEta0)
    b Maybe Range
    c a
    d) = [Bool] -> Bool
    forall (t :: * -> *). Foldable t => t Bool -> Bool
    and [Maybe (Ranged Induction) -> Bool
    forall a. Null a => a -> Bool
    null Maybe (Ranged Induction)
    a, Maybe (Ranged HasEta0) -> Bool
    forall a. Null a => a -> Bool
    null Maybe (Ranged HasEta0)
    b, Maybe Range -> Bool
    forall a. Null a => a -> Bool
    null Maybe Range
    c, a -> Bool
    forall a. Null a => a -> Bool
    null a
    d]

    emptyRecordDirectives :: Null a => RecordDirectives' a
    emptyRecordDirectives :: forall a. Null a => RecordDirectives' a
    emptyRecordDirectives = Maybe (Ranged Induction)
    -> Maybe (Ranged HasEta0)
    -> Maybe Range
    -> a
    -> RecordDirectives' a
    forall a.
    Maybe (Ranged Induction)
    -> Maybe (Ranged HasEta0)
    -> Maybe Range
    -> a
    -> RecordDirectives' a
    RecordDirectives Maybe (Ranged Induction)
    forall a. Null a => a
    empty Maybe (Ranged HasEta0)
    forall a. Null a => a
    empty Maybe Range
    forall a. Null a => a
    empty a
    forall a. Null a => a
    empty

    instance HasRange a => HasRange (RecordDirectives' a) where
      getRange :: RecordDirectives' a -> Range
    getRange (RecordDirectives Maybe (Ranged Induction)
    a Maybe (Ranged HasEta0)
    b Maybe Range
    c a
    d) = (Maybe (Ranged Induction), Maybe (Ranged HasEta0), Maybe Range, a)
    -> Range
    forall a. HasRange a => a -> Range
    getRange (Maybe (Ranged Induction)
    a,Maybe (Ranged HasEta0)
    b,Maybe Range
    c,a
    d)

    instance KillRange a => KillRange (RecordDirectives' a) where
      killRange :: KillRangeT (RecordDirectives' a)
    killRange (RecordDirectives Maybe (Ranged Induction)
    a Maybe (Ranged HasEta0)
    b Maybe Range
    c a
    d) = (Maybe (Ranged Induction)
     -> Maybe (Ranged HasEta0)
     -> Maybe Range
     -> a
     -> RecordDirectives' a)
    -> Maybe (Ranged Induction)
    -> Maybe (Ranged HasEta0)
    -> Maybe Range
    -> a
    -> RecordDirectives' a
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN Maybe (Ranged Induction)
    -> Maybe (Ranged HasEta0)
    -> Maybe Range
    -> a
    -> RecordDirectives' a
    forall a.
    Maybe (Ranged Induction)
    -> Maybe (Ranged HasEta0)
    -> Maybe Range
    -> a
    -> RecordDirectives' a
    RecordDirectives Maybe (Ranged Induction)
    a Maybe (Ranged HasEta0)
    b Maybe Range
    c a
    d

    instance NFData a => NFData (RecordDirectives' a) where
      rnf :: RecordDirectives' a -> ()
    rnf (RecordDirectives Maybe (Ranged Induction)
    a Maybe (Ranged HasEta0)
    b Maybe Range
    c a
    d) = Maybe Range
    c Maybe Range -> () -> ()
    forall a b. a -> b -> b
    `seq` (Maybe (Ranged Induction), Maybe (Ranged HasEta0), a) -> ()
    forall a. NFData a => a -> ()
    rnf (Maybe (Ranged Induction)
    a, Maybe (Ranged HasEta0)
    b, a
    d)

    ---------------------------------------------------------------------------
    -- * Eta-equality
    ---------------------------------------------------------------------------

    -- | Does a record come with eta-equality?
    data HasEta' a
      = YesEta
      | NoEta a
      deriving (Int -> HasEta' a -> ShowS
    [HasEta' a] -> ShowS
    HasEta' a -> ArgName
    (Int -> HasEta' a -> ShowS)
    -> (HasEta' a -> ArgName)
    -> ([HasEta' a] -> ShowS)
    -> Show (HasEta' a)
    forall a. Show a => Int -> HasEta' a -> ShowS
    forall a. Show a => [HasEta' a] -> ShowS
    forall a. Show a => HasEta' a -> ArgName
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> HasEta' a -> ShowS
    showsPrec :: Int -> HasEta' a -> ShowS
    $cshow :: forall a. Show a => HasEta' a -> ArgName
    show :: HasEta' a -> ArgName
    $cshowList :: forall a. Show a => [HasEta' a] -> ShowS
    showList :: [HasEta' a] -> ShowS
    Show, HasEta' a -> HasEta' a -> Bool
    (HasEta' a -> HasEta' a -> Bool)
    -> (HasEta' a -> HasEta' a -> Bool) -> Eq (HasEta' a)
    forall a. Eq a => HasEta' a -> HasEta' a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => HasEta' a -> HasEta' a -> Bool
    == :: HasEta' a -> HasEta' a -> Bool
    $c/= :: forall a. Eq a => HasEta' a -> HasEta' a -> Bool
    /= :: HasEta' a -> HasEta' a -> Bool
    Eq, Eq (HasEta' a)
    Eq (HasEta' a) =>
    (HasEta' a -> HasEta' a -> Ordering)
    -> (HasEta' a -> HasEta' a -> Bool)
    -> (HasEta' a -> HasEta' a -> Bool)
    -> (HasEta' a -> HasEta' a -> Bool)
    -> (HasEta' a -> HasEta' a -> Bool)
    -> (HasEta' a -> HasEta' a -> HasEta' a)
    -> (HasEta' a -> HasEta' a -> HasEta' a)
    -> Ord (HasEta' a)
    HasEta' a -> HasEta' a -> Bool
    HasEta' a -> HasEta' a -> Ordering
    HasEta' a -> HasEta' a -> HasEta' 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 (HasEta' a)
    forall a. Ord a => HasEta' a -> HasEta' a -> Bool
    forall a. Ord a => HasEta' a -> HasEta' a -> Ordering
    forall a. Ord a => HasEta' a -> HasEta' a -> HasEta' a
    $ccompare :: forall a. Ord a => HasEta' a -> HasEta' a -> Ordering
    compare :: HasEta' a -> HasEta' a -> Ordering
    $c< :: forall a. Ord a => HasEta' a -> HasEta' a -> Bool
    < :: HasEta' a -> HasEta' a -> Bool
    $c<= :: forall a. Ord a => HasEta' a -> HasEta' a -> Bool
    <= :: HasEta' a -> HasEta' a -> Bool
    $c> :: forall a. Ord a => HasEta' a -> HasEta' a -> Bool
    > :: HasEta' a -> HasEta' a -> Bool
    $c>= :: forall a. Ord a => HasEta' a -> HasEta' a -> Bool
    >= :: HasEta' a -> HasEta' a -> Bool
    $cmax :: forall a. Ord a => HasEta' a -> HasEta' a -> HasEta' a
    max :: HasEta' a -> HasEta' a -> HasEta' a
    $cmin :: forall a. Ord a => HasEta' a -> HasEta' a -> HasEta' a
    min :: HasEta' a -> HasEta' a -> HasEta' a
    Ord, (forall a b. (a -> b) -> HasEta' a -> HasEta' b)
    -> (forall a b. a -> HasEta' b -> HasEta' a) -> Functor HasEta'
    forall a b. a -> HasEta' b -> HasEta' a
    forall a b. (a -> b) -> HasEta' a -> HasEta' b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> HasEta' a -> HasEta' b
    fmap :: forall a b. (a -> b) -> HasEta' a -> HasEta' b
    $c<$ :: forall a b. a -> HasEta' b -> HasEta' a
    <$ :: forall a b. a -> HasEta' b -> HasEta' a
    Functor, (forall m. Monoid m => HasEta' m -> m)
    -> (forall m a. Monoid m => (a -> m) -> HasEta' a -> m)
    -> (forall m a. Monoid m => (a -> m) -> HasEta' a -> m)
    -> (forall a b. (a -> b -> b) -> b -> HasEta' a -> b)
    -> (forall a b. (a -> b -> b) -> b -> HasEta' a -> b)
    -> (forall b a. (b -> a -> b) -> b -> HasEta' a -> b)
    -> (forall b a. (b -> a -> b) -> b -> HasEta' a -> b)
    -> (forall a. (a -> a -> a) -> HasEta' a -> a)
    -> (forall a. (a -> a -> a) -> HasEta' a -> a)
    -> (forall a. HasEta' a -> [a])
    -> (forall a. HasEta' a -> Bool)
    -> (forall a. HasEta' a -> Int)
    -> (forall a. Eq a => a -> HasEta' a -> Bool)
    -> (forall a. Ord a => HasEta' a -> a)
    -> (forall a. Ord a => HasEta' a -> a)
    -> (forall a. Num a => HasEta' a -> a)
    -> (forall a. Num a => HasEta' a -> a)
    -> Foldable HasEta'
    forall a. Eq a => a -> HasEta' a -> Bool
    forall a. Num a => HasEta' a -> a
    forall a. Ord a => HasEta' a -> a
    forall m. Monoid m => HasEta' m -> m
    forall a. HasEta' a -> Bool
    forall a. HasEta' a -> Int
    forall a. HasEta' a -> [a]
    forall a. (a -> a -> a) -> HasEta' a -> a
    forall m a. Monoid m => (a -> m) -> HasEta' a -> m
    forall b a. (b -> a -> b) -> b -> HasEta' a -> b
    forall a b. (a -> b -> b) -> b -> HasEta' 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
    $cfold :: forall m. Monoid m => HasEta' m -> m
    fold :: forall m. Monoid m => HasEta' m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> HasEta' a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> HasEta' a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> HasEta' a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> HasEta' a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> HasEta' a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> HasEta' a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> HasEta' a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> HasEta' a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> HasEta' a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> HasEta' a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> HasEta' a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> HasEta' a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> HasEta' a -> a
    foldr1 :: forall a. (a -> a -> a) -> HasEta' a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> HasEta' a -> a
    foldl1 :: forall a. (a -> a -> a) -> HasEta' a -> a
    $ctoList :: forall a. HasEta' a -> [a]
    toList :: forall a. HasEta' a -> [a]
    $cnull :: forall a. HasEta' a -> Bool
    null :: forall a. HasEta' a -> Bool
    $clength :: forall a. HasEta' a -> Int
    length :: forall a. HasEta' a -> Int
    $celem :: forall a. Eq a => a -> HasEta' a -> Bool
    elem :: forall a. Eq a => a -> HasEta' a -> Bool
    $cmaximum :: forall a. Ord a => HasEta' a -> a
    maximum :: forall a. Ord a => HasEta' a -> a
    $cminimum :: forall a. Ord a => HasEta' a -> a
    minimum :: forall a. Ord a => HasEta' a -> a
    $csum :: forall a. Num a => HasEta' a -> a
    sum :: forall a. Num a => HasEta' a -> a
    $cproduct :: forall a. Num a => HasEta' a -> a
    product :: forall a. Num a => HasEta' a -> a
    Foldable, Functor HasEta'
    Foldable HasEta'
    (Functor HasEta', Foldable HasEta') =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> HasEta' a -> f (HasEta' b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        HasEta' (f a) -> f (HasEta' a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> HasEta' a -> m (HasEta' b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        HasEta' (m a) -> m (HasEta' a))
    -> Traversable HasEta'
    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 => HasEta' (m a) -> m (HasEta' a)
    forall (f :: * -> *) a.
    Applicative f =>
    HasEta' (f a) -> f (HasEta' a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> HasEta' a -> m (HasEta' b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> HasEta' a -> f (HasEta' b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> HasEta' a -> f (HasEta' b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> HasEta' a -> f (HasEta' b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    HasEta' (f a) -> f (HasEta' a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    HasEta' (f a) -> f (HasEta' a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> HasEta' a -> m (HasEta' b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> HasEta' a -> m (HasEta' b)
    $csequence :: forall (m :: * -> *) a. Monad m => HasEta' (m a) -> m (HasEta' a)
    sequence :: forall (m :: * -> *) a. Monad m => HasEta' (m a) -> m (HasEta' a)
    Traversable)

    instance HasRange a => HasRange (HasEta' a) where
      getRange :: HasEta' a -> Range
    getRange = (a -> Range) -> HasEta' a -> Range
    forall m a. Monoid m => (a -> m) -> HasEta' a -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    foldMap a -> Range
    forall a. HasRange a => a -> Range
    getRange

    instance KillRange a => KillRange (HasEta' a) where
      killRange :: KillRangeT (HasEta' a)
    killRange = (a -> a) -> KillRangeT (HasEta' a)
    forall a b. (a -> b) -> HasEta' a -> HasEta' b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> a
    forall a. KillRange a => KillRangeT a
    killRange

    instance NFData a => NFData (HasEta' a) where
      rnf :: HasEta' a -> ()
    rnf HasEta' a
    YesEta    = ()
      rnf (NoEta a
    p) = a -> ()
    forall a. NFData a => a -> ()
    rnf a
    p

    -- | Pattern and copattern matching is allowed in the presence of eta.
    --
    --   In the absence of eta, we have to choose whether we want to allow
    --   matching on the constructor or copattern matching with the projections.
    --   Having both leads to breakage of subject reduction (issue #4560).

    type HasEta  = HasEta' PatternOrCopattern
    type HasEta0 = HasEta' ()

    -- | For a record without eta, which type of matching do we allow?
    data PatternOrCopattern
      = PatternMatching
          -- ^ Can match on the record constructor.
      | CopatternMatching
          -- ^ Can copattern match using the projections. (Default.)
      deriving (Int -> PatternOrCopattern -> ShowS
    [PatternOrCopattern] -> ShowS
    PatternOrCopattern -> ArgName
    (Int -> PatternOrCopattern -> ShowS)
    -> (PatternOrCopattern -> ArgName)
    -> ([PatternOrCopattern] -> ShowS)
    -> Show PatternOrCopattern
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PatternOrCopattern -> ShowS
    showsPrec :: Int -> PatternOrCopattern -> ShowS
    $cshow :: PatternOrCopattern -> ArgName
    show :: PatternOrCopattern -> ArgName
    $cshowList :: [PatternOrCopattern] -> ShowS
    showList :: [PatternOrCopattern] -> ShowS
    Show, PatternOrCopattern -> PatternOrCopattern -> Bool
    (PatternOrCopattern -> PatternOrCopattern -> Bool)
    -> (PatternOrCopattern -> PatternOrCopattern -> Bool)
    -> Eq PatternOrCopattern
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PatternOrCopattern -> PatternOrCopattern -> Bool
    == :: PatternOrCopattern -> PatternOrCopattern -> Bool
    $c/= :: PatternOrCopattern -> PatternOrCopattern -> Bool
    /= :: PatternOrCopattern -> PatternOrCopattern -> Bool
    Eq, Eq PatternOrCopattern
    Eq PatternOrCopattern =>
    (PatternOrCopattern -> PatternOrCopattern -> Ordering)
    -> (PatternOrCopattern -> PatternOrCopattern -> Bool)
    -> (PatternOrCopattern -> PatternOrCopattern -> Bool)
    -> (PatternOrCopattern -> PatternOrCopattern -> Bool)
    -> (PatternOrCopattern -> PatternOrCopattern -> Bool)
    -> (PatternOrCopattern -> PatternOrCopattern -> PatternOrCopattern)
    -> (PatternOrCopattern -> PatternOrCopattern -> PatternOrCopattern)
    -> Ord PatternOrCopattern
    PatternOrCopattern -> PatternOrCopattern -> Bool
    PatternOrCopattern -> PatternOrCopattern -> Ordering
    PatternOrCopattern -> PatternOrCopattern -> PatternOrCopattern
    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
    $ccompare :: PatternOrCopattern -> PatternOrCopattern -> Ordering
    compare :: PatternOrCopattern -> PatternOrCopattern -> Ordering
    $c< :: PatternOrCopattern -> PatternOrCopattern -> Bool
    < :: PatternOrCopattern -> PatternOrCopattern -> Bool
    $c<= :: PatternOrCopattern -> PatternOrCopattern -> Bool
    <= :: PatternOrCopattern -> PatternOrCopattern -> Bool
    $c> :: PatternOrCopattern -> PatternOrCopattern -> Bool
    > :: PatternOrCopattern -> PatternOrCopattern -> Bool
    $c>= :: PatternOrCopattern -> PatternOrCopattern -> Bool
    >= :: PatternOrCopattern -> PatternOrCopattern -> Bool
    $cmax :: PatternOrCopattern -> PatternOrCopattern -> PatternOrCopattern
    max :: PatternOrCopattern -> PatternOrCopattern -> PatternOrCopattern
    $cmin :: PatternOrCopattern -> PatternOrCopattern -> PatternOrCopattern
    min :: PatternOrCopattern -> PatternOrCopattern -> PatternOrCopattern
    Ord, Int -> PatternOrCopattern
    PatternOrCopattern -> Int
    PatternOrCopattern -> [PatternOrCopattern]
    PatternOrCopattern -> PatternOrCopattern
    PatternOrCopattern -> PatternOrCopattern -> [PatternOrCopattern]
    PatternOrCopattern
    -> PatternOrCopattern -> PatternOrCopattern -> [PatternOrCopattern]
    (PatternOrCopattern -> PatternOrCopattern)
    -> (PatternOrCopattern -> PatternOrCopattern)
    -> (Int -> PatternOrCopattern)
    -> (PatternOrCopattern -> Int)
    -> (PatternOrCopattern -> [PatternOrCopattern])
    -> (PatternOrCopattern
        -> PatternOrCopattern -> [PatternOrCopattern])
    -> (PatternOrCopattern
        -> PatternOrCopattern -> [PatternOrCopattern])
    -> (PatternOrCopattern
        -> PatternOrCopattern
        -> PatternOrCopattern
        -> [PatternOrCopattern])
    -> Enum PatternOrCopattern
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: PatternOrCopattern -> PatternOrCopattern
    succ :: PatternOrCopattern -> PatternOrCopattern
    $cpred :: PatternOrCopattern -> PatternOrCopattern
    pred :: PatternOrCopattern -> PatternOrCopattern
    $ctoEnum :: Int -> PatternOrCopattern
    toEnum :: Int -> PatternOrCopattern
    $cfromEnum :: PatternOrCopattern -> Int
    fromEnum :: PatternOrCopattern -> Int
    $cenumFrom :: PatternOrCopattern -> [PatternOrCopattern]
    enumFrom :: PatternOrCopattern -> [PatternOrCopattern]
    $cenumFromThen :: PatternOrCopattern -> PatternOrCopattern -> [PatternOrCopattern]
    enumFromThen :: PatternOrCopattern -> PatternOrCopattern -> [PatternOrCopattern]
    $cenumFromTo :: PatternOrCopattern -> PatternOrCopattern -> [PatternOrCopattern]
    enumFromTo :: PatternOrCopattern -> PatternOrCopattern -> [PatternOrCopattern]
    $cenumFromThenTo :: PatternOrCopattern
    -> PatternOrCopattern -> PatternOrCopattern -> [PatternOrCopattern]
    enumFromThenTo :: PatternOrCopattern
    -> PatternOrCopattern -> PatternOrCopattern -> [PatternOrCopattern]
    Enum, PatternOrCopattern
    PatternOrCopattern
    -> PatternOrCopattern -> Bounded PatternOrCopattern
    forall a. a -> a -> Bounded a
    $cminBound :: PatternOrCopattern
    minBound :: PatternOrCopattern
    $cmaxBound :: PatternOrCopattern
    maxBound :: PatternOrCopattern
    Bounded)

    instance NFData PatternOrCopattern where
      rnf :: PatternOrCopattern -> ()
    rnf PatternOrCopattern
    PatternMatching   = ()
      rnf PatternOrCopattern
    CopatternMatching = ()

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

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

    -- | Can we pattern match on the record constructor?
    class PatternMatchingAllowed a where
      patternMatchingAllowed :: a -> Bool

    instance PatternMatchingAllowed PatternOrCopattern where
      patternMatchingAllowed :: PatternOrCopattern -> Bool
    patternMatchingAllowed = (PatternOrCopattern -> PatternOrCopattern -> Bool
    forall a. Eq a => a -> a -> Bool
    == PatternOrCopattern
    PatternMatching)

    instance PatternMatchingAllowed HasEta where
      patternMatchingAllowed :: HasEta -> Bool
    patternMatchingAllowed = \case
        HasEta
    YesEta -> Bool
    True
        NoEta PatternOrCopattern
    p -> PatternOrCopattern -> Bool
    forall a. PatternMatchingAllowed a => a -> Bool
    patternMatchingAllowed PatternOrCopattern
    p

    -- | Can we construct a record by copattern matching?
    class CopatternMatchingAllowed a where
      copatternMatchingAllowed :: a -> Bool

    instance CopatternMatchingAllowed PatternOrCopattern where
      copatternMatchingAllowed :: PatternOrCopattern -> Bool
    copatternMatchingAllowed = (PatternOrCopattern -> PatternOrCopattern -> Bool
    forall a. Eq a => a -> a -> Bool
    == PatternOrCopattern
    CopatternMatching)

    instance CopatternMatchingAllowed HasEta where
      copatternMatchingAllowed :: HasEta -> Bool
    copatternMatchingAllowed = \case
        HasEta
    YesEta -> Bool
    True
        NoEta PatternOrCopattern
    p -> PatternOrCopattern -> Bool
    forall a. CopatternMatchingAllowed a => a -> Bool
    copatternMatchingAllowed PatternOrCopattern
    p

    ---------------------------------------------------------------------------
    -- * Induction
    ---------------------------------------------------------------------------

    instance Pretty Induction where
      pretty :: Induction -> Doc
    pretty Induction
    Inductive   = Doc
    "inductive"
      pretty Induction
    CoInductive = Doc
    "coinductive"

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

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

    instance PatternMatchingAllowed Induction where
      patternMatchingAllowed :: Induction -> Bool
    patternMatchingAllowed = (Induction -> Induction -> Bool
    forall a. Eq a => a -> a -> Bool
    == Induction
    Inductive)

    ---------------------------------------------------------------------------
    -- * Overlapping instances
    ---------------------------------------------------------------------------

    data Overlappable = YesOverlap | NoOverlap
      deriving (Int -> Overlappable -> ShowS
    [Overlappable] -> ShowS
    Overlappable -> ArgName
    (Int -> Overlappable -> ShowS)
    -> (Overlappable -> ArgName)
    -> ([Overlappable] -> ShowS)
    -> Show Overlappable
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Overlappable -> ShowS
    showsPrec :: Int -> Overlappable -> ShowS
    $cshow :: Overlappable -> ArgName
    show :: Overlappable -> ArgName
    $cshowList :: [Overlappable] -> ShowS
    showList :: [Overlappable] -> ShowS
    Show, Overlappable -> Overlappable -> Bool
    (Overlappable -> Overlappable -> Bool)
    -> (Overlappable -> Overlappable -> Bool) -> Eq Overlappable
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Overlappable -> Overlappable -> Bool
    == :: Overlappable -> Overlappable -> Bool
    $c/= :: Overlappable -> Overlappable -> Bool
    /= :: Overlappable -> Overlappable -> Bool
    Eq, Eq Overlappable
    Eq Overlappable =>
    (Overlappable -> Overlappable -> Ordering)
    -> (Overlappable -> Overlappable -> Bool)
    -> (Overlappable -> Overlappable -> Bool)
    -> (Overlappable -> Overlappable -> Bool)
    -> (Overlappable -> Overlappable -> Bool)
    -> (Overlappable -> Overlappable -> Overlappable)
    -> (Overlappable -> Overlappable -> Overlappable)
    -> Ord Overlappable
    Overlappable -> Overlappable -> Bool
    Overlappable -> Overlappable -> Ordering
    Overlappable -> Overlappable -> Overlappable
    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
    $ccompare :: Overlappable -> Overlappable -> Ordering
    compare :: Overlappable -> Overlappable -> Ordering
    $c< :: Overlappable -> Overlappable -> Bool
    < :: Overlappable -> Overlappable -> Bool
    $c<= :: Overlappable -> Overlappable -> Bool
    <= :: Overlappable -> Overlappable -> Bool
    $c> :: Overlappable -> Overlappable -> Bool
    > :: Overlappable -> Overlappable -> Bool
    $c>= :: Overlappable -> Overlappable -> Bool
    >= :: Overlappable -> Overlappable -> Bool
    $cmax :: Overlappable -> Overlappable -> Overlappable
    max :: Overlappable -> Overlappable -> Overlappable
    $cmin :: Overlappable -> Overlappable -> Overlappable
    min :: Overlappable -> Overlappable -> Overlappable
    Ord)

    -- | Just for the 'Hiding' instance. Should never combine different
    --   overlapping.
    instance Semigroup Overlappable where
      Overlappable
    NoOverlap  <> :: Overlappable -> Overlappable -> Overlappable
    <> Overlappable
    NoOverlap  = Overlappable
    NoOverlap
      Overlappable
    YesOverlap <> Overlappable
    YesOverlap = Overlappable
    YesOverlap
      Overlappable
    _          <> Overlappable
    _          = Overlappable
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    instance Monoid Overlappable where
      mempty :: Overlappable
    mempty  = Overlappable
    NoOverlap
      mappend :: Overlappable -> Overlappable -> Overlappable
    mappend = Overlappable -> Overlappable -> Overlappable
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance NFData Overlappable where
      rnf :: Overlappable -> ()
    rnf Overlappable
    NoOverlap  = ()
      rnf Overlappable
    YesOverlap = ()

    -- | The possible overlap modes for an instance, also used for instance candidates.
    data OverlapMode
      = Overlappable
      -- ^ User-written OVERLAPPABLE pragma: this candidate can *be removed*
      -- by a more specific candidate.

      | Overlapping
      -- ^ User-written OVERLAPPING pragma: this candidate can *remove* a
      -- less specific candidate.

      | Overlaps
      -- ^ User-written OVERLAPS pragma: both overlappable and overlapping.

      | DefaultOverlap
      -- ^ No user-written overlap pragma. This instance can be overlapped
      -- by an OVERLAPPING instance, and it can overlap OVERLAPPABLE
      -- instances.

      | Incoherent
      -- ^ User-written INCOHERENT pragma: both overlappable and
      -- overlapping; and, if there are multiple candidates after all
      -- overlap has been handled, make an arbitrary choice.

      | FieldOverlap
      -- ^ Overlapping instances in record fields.
      deriving (Int -> OverlapMode -> ShowS
    [OverlapMode] -> ShowS
    OverlapMode -> ArgName
    (Int -> OverlapMode -> ShowS)
    -> (OverlapMode -> ArgName)
    -> ([OverlapMode] -> ShowS)
    -> Show OverlapMode
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OverlapMode -> ShowS
    showsPrec :: Int -> OverlapMode -> ShowS
    $cshow :: OverlapMode -> ArgName
    show :: OverlapMode -> ArgName
    $cshowList :: [OverlapMode] -> ShowS
    showList :: [OverlapMode] -> ShowS
    Show, OverlapMode -> OverlapMode -> Bool
    (OverlapMode -> OverlapMode -> Bool)
    -> (OverlapMode -> OverlapMode -> Bool) -> Eq OverlapMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OverlapMode -> OverlapMode -> Bool
    == :: OverlapMode -> OverlapMode -> Bool
    $c/= :: OverlapMode -> OverlapMode -> Bool
    /= :: OverlapMode -> OverlapMode -> Bool
    Eq, Eq OverlapMode
    Eq OverlapMode =>
    (OverlapMode -> OverlapMode -> Ordering)
    -> (OverlapMode -> OverlapMode -> Bool)
    -> (OverlapMode -> OverlapMode -> Bool)
    -> (OverlapMode -> OverlapMode -> Bool)
    -> (OverlapMode -> OverlapMode -> Bool)
    -> (OverlapMode -> OverlapMode -> OverlapMode)
    -> (OverlapMode -> OverlapMode -> OverlapMode)
    -> Ord OverlapMode
    OverlapMode -> OverlapMode -> Bool
    OverlapMode -> OverlapMode -> Ordering
    OverlapMode -> OverlapMode -> OverlapMode
    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
    $ccompare :: OverlapMode -> OverlapMode -> Ordering
    compare :: OverlapMode -> OverlapMode -> Ordering
    $c< :: OverlapMode -> OverlapMode -> Bool
    < :: OverlapMode -> OverlapMode -> Bool
    $c<= :: OverlapMode -> OverlapMode -> Bool
    <= :: OverlapMode -> OverlapMode -> Bool
    $c> :: OverlapMode -> OverlapMode -> Bool
    > :: OverlapMode -> OverlapMode -> Bool
    $c>= :: OverlapMode -> OverlapMode -> Bool
    >= :: OverlapMode -> OverlapMode -> Bool
    $cmax :: OverlapMode -> OverlapMode -> OverlapMode
    max :: OverlapMode -> OverlapMode -> OverlapMode
    $cmin :: OverlapMode -> OverlapMode -> OverlapMode
    min :: OverlapMode -> OverlapMode -> OverlapMode
    Ord, Int -> OverlapMode
    OverlapMode -> Int
    OverlapMode -> [OverlapMode]
    OverlapMode -> OverlapMode
    OverlapMode -> OverlapMode -> [OverlapMode]
    OverlapMode -> OverlapMode -> OverlapMode -> [OverlapMode]
    (OverlapMode -> OverlapMode)
    -> (OverlapMode -> OverlapMode)
    -> (Int -> OverlapMode)
    -> (OverlapMode -> Int)
    -> (OverlapMode -> [OverlapMode])
    -> (OverlapMode -> OverlapMode -> [OverlapMode])
    -> (OverlapMode -> OverlapMode -> [OverlapMode])
    -> (OverlapMode -> OverlapMode -> OverlapMode -> [OverlapMode])
    -> Enum OverlapMode
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: OverlapMode -> OverlapMode
    succ :: OverlapMode -> OverlapMode
    $cpred :: OverlapMode -> OverlapMode
    pred :: OverlapMode -> OverlapMode
    $ctoEnum :: Int -> OverlapMode
    toEnum :: Int -> OverlapMode
    $cfromEnum :: OverlapMode -> Int
    fromEnum :: OverlapMode -> Int
    $cenumFrom :: OverlapMode -> [OverlapMode]
    enumFrom :: OverlapMode -> [OverlapMode]
    $cenumFromThen :: OverlapMode -> OverlapMode -> [OverlapMode]
    enumFromThen :: OverlapMode -> OverlapMode -> [OverlapMode]
    $cenumFromTo :: OverlapMode -> OverlapMode -> [OverlapMode]
    enumFromTo :: OverlapMode -> OverlapMode -> [OverlapMode]
    $cenumFromThenTo :: OverlapMode -> OverlapMode -> OverlapMode -> [OverlapMode]
    enumFromThenTo :: OverlapMode -> OverlapMode -> OverlapMode -> [OverlapMode]
    Enum, OverlapMode
    OverlapMode -> OverlapMode -> Bounded OverlapMode
    forall a. a -> a -> Bounded a
    $cminBound :: OverlapMode
    minBound :: OverlapMode
    $cmaxBound :: OverlapMode
    maxBound :: OverlapMode
    Bounded)

    instance Pretty OverlapMode where
      pretty :: OverlapMode -> Doc
    pretty = \case
        OverlapMode
    Overlappable   -> Doc
    "OVERLAPPABLE"
        OverlapMode
    Overlapping    -> Doc
    "OVERLAPPING"
        OverlapMode
    Incoherent     -> Doc
    "INCOHERENT"
        OverlapMode
    Overlaps       -> Doc
    "OVERLAPS"
        OverlapMode
    FieldOverlap   -> Doc
    "overlap"
        OverlapMode
    DefaultOverlap -> Doc
    forall a. Null a => a
    empty

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

    instance NFData OverlapMode where
      rnf :: OverlapMode -> ()
    rnf = \case
        OverlapMode
    Overlappable   -> ()
        OverlapMode
    Overlapping    -> ()
        OverlapMode
    Overlaps       -> ()
        OverlapMode
    DefaultOverlap -> ()
        OverlapMode
    FieldOverlap   -> ()
        OverlapMode
    Incoherent     -> ()

    class HasOverlapMode a where
      lensOverlapMode :: Lens' a OverlapMode

    instance HasOverlapMode OverlapMode where
      lensOverlapMode :: Lens' OverlapMode OverlapMode
    lensOverlapMode = (OverlapMode -> f OverlapMode) -> OverlapMode -> f OverlapMode
    forall a. a -> a
    id

    isIncoherent, isOverlappable, isOverlapping :: HasOverlapMode a => a -> Bool
    isIncoherent :: forall a. HasOverlapMode a => a -> Bool
    isIncoherent a
    x = case a
    x a -> Lens' a OverlapMode -> OverlapMode
    forall o i. o -> Lens' o i -> i
    ^. (OverlapMode -> f OverlapMode) -> a -> f a
    forall a. HasOverlapMode a => Lens' a OverlapMode
    Lens' a OverlapMode
    lensOverlapMode of
      OverlapMode
    Incoherent -> Bool
    True
      OverlapMode
    _          -> Bool
    False

    isOverlappable :: forall a. HasOverlapMode a => a -> Bool
    isOverlappable a
    x = case a
    x a -> Lens' a OverlapMode -> OverlapMode
    forall o i. o -> Lens' o i -> i
    ^. (OverlapMode -> f OverlapMode) -> a -> f a
    forall a. HasOverlapMode a => Lens' a OverlapMode
    Lens' a OverlapMode
    lensOverlapMode of
      OverlapMode
    Overlappable -> Bool
    True
      OverlapMode
    Incoherent   -> Bool
    True
      OverlapMode
    Overlaps     -> Bool
    True
      OverlapMode
    _            -> Bool
    False

    isOverlapping :: forall a. HasOverlapMode a => a -> Bool
    isOverlapping a
    x = case a
    x a -> Lens' a OverlapMode -> OverlapMode
    forall o i. o -> Lens' o i -> i
    ^. (OverlapMode -> f OverlapMode) -> a -> f a
    forall a. HasOverlapMode a => Lens' a OverlapMode
    Lens' a OverlapMode
    lensOverlapMode of
      OverlapMode
    Overlapping -> Bool
    True
      OverlapMode
    Incoherent  -> Bool
    True
      OverlapMode
    Overlaps    -> Bool
    True
      OverlapMode
    _           -> Bool
    False

    ---------------------------------------------------------------------------
    -- * Hiding
    ---------------------------------------------------------------------------

    data Hiding  = Hidden | Instance Overlappable | NotHidden
      deriving (Int -> Hiding -> ShowS
    [Hiding] -> ShowS
    Hiding -> ArgName
    (Int -> Hiding -> ShowS)
    -> (Hiding -> ArgName) -> ([Hiding] -> ShowS) -> Show Hiding
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Hiding -> ShowS
    showsPrec :: Int -> Hiding -> ShowS
    $cshow :: Hiding -> ArgName
    show :: Hiding -> ArgName
    $cshowList :: [Hiding] -> ShowS
    showList :: [Hiding] -> ShowS
    Show, Hiding -> Hiding -> Bool
    (Hiding -> Hiding -> Bool)
    -> (Hiding -> Hiding -> Bool) -> Eq Hiding
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Hiding -> Hiding -> Bool
    == :: Hiding -> Hiding -> Bool
    $c/= :: Hiding -> Hiding -> Bool
    /= :: Hiding -> Hiding -> Bool
    Eq, Eq Hiding
    Eq Hiding =>
    (Hiding -> Hiding -> Ordering)
    -> (Hiding -> Hiding -> Bool)
    -> (Hiding -> Hiding -> Bool)
    -> (Hiding -> Hiding -> Bool)
    -> (Hiding -> Hiding -> Bool)
    -> (Hiding -> Hiding -> Hiding)
    -> (Hiding -> Hiding -> Hiding)
    -> Ord Hiding
    Hiding -> Hiding -> Bool
    Hiding -> Hiding -> Ordering
    Hiding -> Hiding -> Hiding
    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
    $ccompare :: Hiding -> Hiding -> Ordering
    compare :: Hiding -> Hiding -> Ordering
    $c< :: Hiding -> Hiding -> Bool
    < :: Hiding -> Hiding -> Bool
    $c<= :: Hiding -> Hiding -> Bool
    <= :: Hiding -> Hiding -> Bool
    $c> :: Hiding -> Hiding -> Bool
    > :: Hiding -> Hiding -> Bool
    $c>= :: Hiding -> Hiding -> Bool
    >= :: Hiding -> Hiding -> Bool
    $cmax :: Hiding -> Hiding -> Hiding
    max :: Hiding -> Hiding -> Hiding
    $cmin :: Hiding -> Hiding -> Hiding
    min :: Hiding -> Hiding -> Hiding
    Ord)

    instance Pretty Hiding where
      pretty :: Hiding -> Doc
    pretty = ArgName -> Doc
    forall a. ArgName -> Doc a
    text (ArgName -> Doc) -> (Hiding -> ArgName) -> Hiding -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Hiding -> ArgName
    hidingToString

    hidingToString :: Hiding -> String
    hidingToString :: Hiding -> ArgName
    hidingToString = \case
      Hiding
    Hidden     -> ArgName
    "hidden"
      Hiding
    NotHidden  -> ArgName
    "visible"
      Instance{} -> ArgName
    "instance"

    instance Null Hiding where
      empty :: Hiding
    empty = Hiding
    NotHidden

    -- | 'Hiding' is an idempotent partial monoid, with unit 'NotHidden'.
    --   'Instance' and 'NotHidden' are incompatible.
    instance Semigroup Hiding where
      Hiding
    NotHidden  <> :: Hiding -> Hiding -> Hiding
    <> Hiding
    h           = Hiding
    h
      Hiding
    h          <> Hiding
    NotHidden   = Hiding
    h
      Hiding
    Hidden     <> Hiding
    Hidden      = Hiding
    Hidden
      Instance Overlappable
    o <> Instance Overlappable
    o' = Overlappable -> Hiding
    Instance (Overlappable
    o Overlappable -> Overlappable -> Overlappable
    forall a. Semigroup a => a -> a -> a
    <> Overlappable
    o')
      Hiding
    _          <> Hiding
    _           = Hiding
    forall a. HasCallStack => a
    __IMPOSSIBLE__

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

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

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

    instance NFData Hiding where
      rnf :: Hiding -> ()
    rnf Hiding
    Hidden       = ()
      rnf (Instance Overlappable
    o) = Overlappable -> ()
    forall a. NFData a => a -> ()
    rnf Overlappable
    o
      rnf Hiding
    NotHidden    = ()

    -- | Decorating something with 'Hiding' information.
    data WithHiding a = WithHiding
      { forall a. WithHiding a -> Hiding
    whHiding :: !Hiding
      , forall a. WithHiding a -> a
    whThing  :: a
      }
      deriving (WithHiding a -> WithHiding a -> Bool
    (WithHiding a -> WithHiding a -> Bool)
    -> (WithHiding a -> WithHiding a -> Bool) -> Eq (WithHiding a)
    forall a. Eq a => WithHiding a -> WithHiding a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => WithHiding a -> WithHiding a -> Bool
    == :: WithHiding a -> WithHiding a -> Bool
    $c/= :: forall a. Eq a => WithHiding a -> WithHiding a -> Bool
    /= :: WithHiding a -> WithHiding a -> Bool
    Eq, Eq (WithHiding a)
    Eq (WithHiding a) =>
    (WithHiding a -> WithHiding a -> Ordering)
    -> (WithHiding a -> WithHiding a -> Bool)
    -> (WithHiding a -> WithHiding a -> Bool)
    -> (WithHiding a -> WithHiding a -> Bool)
    -> (WithHiding a -> WithHiding a -> Bool)
    -> (WithHiding a -> WithHiding a -> WithHiding a)
    -> (WithHiding a -> WithHiding a -> WithHiding a)
    -> Ord (WithHiding a)
    WithHiding a -> WithHiding a -> Bool
    WithHiding a -> WithHiding a -> Ordering
    WithHiding a -> WithHiding a -> WithHiding 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 (WithHiding a)
    forall a. Ord a => WithHiding a -> WithHiding a -> Bool
    forall a. Ord a => WithHiding a -> WithHiding a -> Ordering
    forall a. Ord a => WithHiding a -> WithHiding a -> WithHiding a
    $ccompare :: forall a. Ord a => WithHiding a -> WithHiding a -> Ordering
    compare :: WithHiding a -> WithHiding a -> Ordering
    $c< :: forall a. Ord a => WithHiding a -> WithHiding a -> Bool
    < :: WithHiding a -> WithHiding a -> Bool
    $c<= :: forall a. Ord a => WithHiding a -> WithHiding a -> Bool
    <= :: WithHiding a -> WithHiding a -> Bool
    $c> :: forall a. Ord a => WithHiding a -> WithHiding a -> Bool
    > :: WithHiding a -> WithHiding a -> Bool
    $c>= :: forall a. Ord a => WithHiding a -> WithHiding a -> Bool
    >= :: WithHiding a -> WithHiding a -> Bool
    $cmax :: forall a. Ord a => WithHiding a -> WithHiding a -> WithHiding a
    max :: WithHiding a -> WithHiding a -> WithHiding a
    $cmin :: forall a. Ord a => WithHiding a -> WithHiding a -> WithHiding a
    min :: WithHiding a -> WithHiding a -> WithHiding a
    Ord, Int -> WithHiding a -> ShowS
    [WithHiding a] -> ShowS
    WithHiding a -> ArgName
    (Int -> WithHiding a -> ShowS)
    -> (WithHiding a -> ArgName)
    -> ([WithHiding a] -> ShowS)
    -> Show (WithHiding a)
    forall a. Show a => Int -> WithHiding a -> ShowS
    forall a. Show a => [WithHiding a] -> ShowS
    forall a. Show a => WithHiding a -> ArgName
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> WithHiding a -> ShowS
    showsPrec :: Int -> WithHiding a -> ShowS
    $cshow :: forall a. Show a => WithHiding a -> ArgName
    show :: WithHiding a -> ArgName
    $cshowList :: forall a. Show a => [WithHiding a] -> ShowS
    showList :: [WithHiding a] -> ShowS
    Show, (forall a b. (a -> b) -> WithHiding a -> WithHiding b)
    -> (forall a b. a -> WithHiding b -> WithHiding a)
    -> Functor WithHiding
    forall a b. a -> WithHiding b -> WithHiding a
    forall a b. (a -> b) -> WithHiding a -> WithHiding b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> WithHiding a -> WithHiding b
    fmap :: forall a b. (a -> b) -> WithHiding a -> WithHiding b
    $c<$ :: forall a b. a -> WithHiding b -> WithHiding a
    <$ :: forall a b. a -> WithHiding b -> WithHiding a
    Functor, (forall m. Monoid m => WithHiding m -> m)
    -> (forall m a. Monoid m => (a -> m) -> WithHiding a -> m)
    -> (forall m a. Monoid m => (a -> m) -> WithHiding a -> m)
    -> (forall a b. (a -> b -> b) -> b -> WithHiding a -> b)
    -> (forall a b. (a -> b -> b) -> b -> WithHiding a -> b)
    -> (forall b a. (b -> a -> b) -> b -> WithHiding a -> b)
    -> (forall b a. (b -> a -> b) -> b -> WithHiding a -> b)
    -> (forall a. (a -> a -> a) -> WithHiding a -> a)
    -> (forall a. (a -> a -> a) -> WithHiding a -> a)
    -> (forall a. WithHiding a -> [a])
    -> (forall a. WithHiding a -> Bool)
    -> (forall a. WithHiding a -> Int)
    -> (forall a. Eq a => a -> WithHiding a -> Bool)
    -> (forall a. Ord a => WithHiding a -> a)
    -> (forall a. Ord a => WithHiding a -> a)
    -> (forall a. Num a => WithHiding a -> a)
    -> (forall a. Num a => WithHiding a -> a)
    -> Foldable WithHiding
    forall a. Eq a => a -> WithHiding a -> Bool
    forall a. Num a => WithHiding a -> a
    forall a. Ord a => WithHiding a -> a
    forall m. Monoid m => WithHiding m -> m
    forall a. WithHiding a -> Bool
    forall a. WithHiding a -> Int
    forall a. WithHiding a -> [a]
    forall a. (a -> a -> a) -> WithHiding a -> a
    forall m a. Monoid m => (a -> m) -> WithHiding a -> m
    forall b a. (b -> a -> b) -> b -> WithHiding a -> b
    forall a b. (a -> b -> b) -> b -> WithHiding 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
    $cfold :: forall m. Monoid m => WithHiding m -> m
    fold :: forall m. Monoid m => WithHiding m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> WithHiding a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> WithHiding a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> WithHiding a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> WithHiding a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> WithHiding a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> WithHiding a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> WithHiding a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> WithHiding a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> WithHiding a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> WithHiding a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> WithHiding a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> WithHiding a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> WithHiding a -> a
    foldr1 :: forall a. (a -> a -> a) -> WithHiding a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> WithHiding a -> a
    foldl1 :: forall a. (a -> a -> a) -> WithHiding a -> a
    $ctoList :: forall a. WithHiding a -> [a]
    toList :: forall a. WithHiding a -> [a]
    $cnull :: forall a. WithHiding a -> Bool
    null :: forall a. WithHiding a -> Bool
    $clength :: forall a. WithHiding a -> Int
    length :: forall a. WithHiding a -> Int
    $celem :: forall a. Eq a => a -> WithHiding a -> Bool
    elem :: forall a. Eq a => a -> WithHiding a -> Bool
    $cmaximum :: forall a. Ord a => WithHiding a -> a
    maximum :: forall a. Ord a => WithHiding a -> a
    $cminimum :: forall a. Ord a => WithHiding a -> a
    minimum :: forall a. Ord a => WithHiding a -> a
    $csum :: forall a. Num a => WithHiding a -> a
    sum :: forall a. Num a => WithHiding a -> a
    $cproduct :: forall a. Num a => WithHiding a -> a
    product :: forall a. Num a => WithHiding a -> a
    Foldable, Functor WithHiding
    Foldable WithHiding
    (Functor WithHiding, Foldable WithHiding) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> WithHiding a -> f (WithHiding b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        WithHiding (f a) -> f (WithHiding a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> WithHiding a -> m (WithHiding b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        WithHiding (m a) -> m (WithHiding a))
    -> Traversable WithHiding
    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 =>
    WithHiding (m a) -> m (WithHiding a)
    forall (f :: * -> *) a.
    Applicative f =>
    WithHiding (f a) -> f (WithHiding a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> WithHiding a -> m (WithHiding b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> WithHiding a -> f (WithHiding b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> WithHiding a -> f (WithHiding b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> WithHiding a -> f (WithHiding b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    WithHiding (f a) -> f (WithHiding a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    WithHiding (f a) -> f (WithHiding a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> WithHiding a -> m (WithHiding b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> WithHiding a -> m (WithHiding b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    WithHiding (m a) -> m (WithHiding a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    WithHiding (m a) -> m (WithHiding a)
    Traversable)

    instance Decoration WithHiding where
      traverseF :: forall (m :: * -> *) a b.
    Functor m =>
    (a -> m b) -> WithHiding a -> m (WithHiding b)
    traverseF a -> m b
    f (WithHiding Hiding
    h a
    a) = Hiding -> b -> WithHiding b
    forall a. Hiding -> a -> WithHiding a
    WithHiding Hiding
    h (b -> WithHiding b) -> m b -> m (WithHiding b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> m b
    f a
    a

    instance Applicative WithHiding where
      pure :: forall a. a -> WithHiding a
    pure = Hiding -> a -> WithHiding a
    forall a. Hiding -> a -> WithHiding a
    WithHiding Hiding
    forall a. Monoid a => a
    mempty
      WithHiding Hiding
    h a -> b
    f <*> :: forall a b. WithHiding (a -> b) -> WithHiding a -> WithHiding b
    <*> WithHiding Hiding
    h' a
    a = Hiding -> b -> WithHiding b
    forall a. Hiding -> a -> WithHiding a
    WithHiding (Hiding -> Hiding -> Hiding
    forall a. Monoid a => a -> a -> a
    mappend Hiding
    h Hiding
    h') (a -> b
    f a
    a)

    instance HasRange a => HasRange (WithHiding a) where
      getRange :: WithHiding a -> Range
    getRange = a -> Range
    forall a. HasRange a => a -> Range
    getRange (a -> Range) -> (WithHiding a -> a) -> WithHiding a -> Range
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . WithHiding a -> a
    forall (t :: * -> *) a. Decoration t => t a -> a
    dget

    instance SetRange a => SetRange (WithHiding a) where
      setRange :: Range -> WithHiding a -> WithHiding a
    setRange = (a -> a) -> WithHiding a -> WithHiding a
    forall a b. (a -> b) -> WithHiding a -> WithHiding b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((a -> a) -> WithHiding a -> WithHiding a)
    -> (Range -> a -> a) -> Range -> WithHiding a -> WithHiding a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Range -> a -> a
    forall a. SetRange a => Range -> a -> a
    setRange

    instance KillRange a => KillRange (WithHiding a) where
      killRange :: KillRangeT (WithHiding a)
    killRange = (a -> a) -> KillRangeT (WithHiding a)
    forall a b. (a -> b) -> WithHiding a -> WithHiding b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> a
    forall a. KillRange a => KillRangeT a
    killRange

    instance NFData a => NFData (WithHiding a) where
      rnf :: WithHiding a -> ()
    rnf (WithHiding Hiding
    _ a
    a) = a -> ()
    forall a. NFData a => a -> ()
    rnf a
    a

    -- | A lens to access the 'Hiding' attribute in data structures.
    --   Minimal implementation: @getHiding@ and @mapHiding@ or @LensArgInfo@.
    class LensHiding a where

      getHiding :: a -> Hiding

      setHiding :: Hiding -> a -> a
      setHiding Hiding
    h = (Hiding -> Hiding) -> a -> a
    forall a. LensHiding a => (Hiding -> Hiding) -> a -> a
    mapHiding (Hiding -> Hiding -> Hiding
    forall a b. a -> b -> a
    const Hiding
    h)

      mapHiding :: (Hiding -> Hiding) -> a -> a

      default getHiding :: LensArgInfo a => a -> Hiding
      getHiding = ArgInfo -> Hiding
    argInfoHiding (ArgInfo -> Hiding) -> (a -> ArgInfo) -> a -> Hiding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo

      default mapHiding :: LensArgInfo a => (Hiding -> Hiding) -> a -> a
      mapHiding Hiding -> Hiding
    f = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a) -> (ArgInfo -> ArgInfo) -> a -> a
    forall a b. (a -> b) -> a -> b
    $ \ ArgInfo
    ai -> ArgInfo
    ai { argInfoHiding = f $ argInfoHiding ai }

    instance LensHiding Hiding where
      getHiding :: Hiding -> Hiding
    getHiding = Hiding -> Hiding
    forall a. a -> a
    id
      setHiding :: Hiding -> Hiding -> Hiding
    setHiding = Hiding -> Hiding -> Hiding
    forall a b. a -> b -> a
    const
      mapHiding :: (Hiding -> Hiding) -> Hiding -> Hiding
    mapHiding = (Hiding -> Hiding) -> Hiding -> Hiding
    forall a. a -> a
    id

    instance LensHiding (WithHiding a) where
      getHiding :: WithHiding a -> Hiding
    getHiding   (WithHiding Hiding
    h a
    _) = Hiding
    h
      setHiding :: Hiding -> WithHiding a -> WithHiding a
    setHiding Hiding
    h (WithHiding Hiding
    _ a
    a) = Hiding -> a -> WithHiding a
    forall a. Hiding -> a -> WithHiding a
    WithHiding Hiding
    h a
    a
      mapHiding :: (Hiding -> Hiding) -> WithHiding a -> WithHiding a
    mapHiding Hiding -> Hiding
    f (WithHiding Hiding
    h a
    a) = Hiding -> a -> WithHiding a
    forall a. Hiding -> a -> WithHiding a
    WithHiding (Hiding -> Hiding
    f Hiding
    h) a
    a

    instance LensHiding a => LensHiding (Named nm a) where
      getHiding :: Named nm a -> Hiding
    getHiding = a -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding (a -> Hiding) -> (Named nm a -> a) -> Named nm a -> Hiding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Named nm a -> a
    forall name a. Named name a -> a
    namedThing
      setHiding :: Hiding -> Named nm a -> Named nm a
    setHiding = (a -> a) -> Named nm a -> Named nm a
    forall a b. (a -> b) -> Named nm a -> Named nm b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((a -> a) -> Named nm a -> Named nm a)
    -> (Hiding -> a -> a) -> Hiding -> Named nm a -> Named nm a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Hiding -> a -> a
    forall a. LensHiding a => Hiding -> a -> a
    setHiding
      mapHiding :: (Hiding -> Hiding) -> Named nm a -> Named nm a
    mapHiding = (a -> a) -> Named nm a -> Named nm a
    forall a b. (a -> b) -> Named nm a -> Named nm b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((a -> a) -> Named nm a -> Named nm a)
    -> ((Hiding -> Hiding) -> a -> a)
    -> (Hiding -> Hiding)
    -> Named nm a
    -> Named nm a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Hiding -> Hiding) -> a -> a
    forall a. LensHiding a => (Hiding -> Hiding) -> a -> a
    mapHiding

    -- | Monoidal composition of 'Hiding' information in some data.
    mergeHiding :: LensHiding a => WithHiding a -> a
    mergeHiding :: forall a. LensHiding a => WithHiding a -> a
    mergeHiding (WithHiding Hiding
    h a
    a) = (Hiding -> Hiding) -> a -> a
    forall a. LensHiding a => (Hiding -> Hiding) -> a -> a
    mapHiding (Hiding -> Hiding -> Hiding
    forall a. Monoid a => a -> a -> a
    mappend Hiding
    h) a
    a

    -- | 'NotHidden' arguments are @visible@.
    visible :: LensHiding a => a -> Bool
    visible :: forall a. LensHiding a => a -> Bool
    visible a
    a = a -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding a
    a Hiding -> Hiding -> Bool
    forall a. Eq a => a -> a -> Bool
    == Hiding
    NotHidden

    -- | 'Instance' and 'Hidden' arguments are @notVisible@.
    notVisible :: LensHiding a => a -> Bool
    notVisible :: forall a. LensHiding a => a -> Bool
    notVisible a
    a = a -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding a
    a Hiding -> Hiding -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Hiding
    NotHidden

    -- | 'Hidden' arguments are @hidden@.
    hidden :: LensHiding a => a -> Bool
    hidden :: forall a. LensHiding a => a -> Bool
    hidden a
    a = a -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding a
    a Hiding -> Hiding -> Bool
    forall a. Eq a => a -> a -> Bool
    == Hiding
    Hidden

    hide :: LensHiding a => a -> a
    hide :: forall a. LensHiding a => a -> a
    hide = Hiding -> a -> a
    forall a. LensHiding a => Hiding -> a -> a
    setHiding Hiding
    Hidden

    hideOrKeepInstance :: LensHiding a => a -> a
    hideOrKeepInstance :: forall a. LensHiding a => a -> a
    hideOrKeepInstance a
    x =
      case a -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding a
    x of
        Hiding
    Hidden     -> a
    x
        Instance{} -> a
    x
        Hiding
    NotHidden  -> Hiding -> a -> a
    forall a. LensHiding a => Hiding -> a -> a
    setHiding Hiding
    Hidden a
    x

    makeInstance :: LensHiding a => a -> a
    makeInstance :: forall a. LensHiding a => a -> a
    makeInstance = Overlappable -> a -> a
    forall a. LensHiding a => Overlappable -> a -> a
    makeInstance' Overlappable
    NoOverlap

    makeInstance' :: LensHiding a => Overlappable -> a -> a
    makeInstance' :: forall a. LensHiding a => Overlappable -> a -> a
    makeInstance' Overlappable
    o = Hiding -> a -> a
    forall a. LensHiding a => Hiding -> a -> a
    setHiding (Overlappable -> Hiding
    Instance Overlappable
    o)

    isYesOverlap :: LensHiding a => a -> Bool
    isYesOverlap :: forall a. LensHiding a => a -> Bool
    isYesOverlap a
    x =
      case a -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding a
    x of
        Instance Overlappable
    YesOverlap -> Bool
    True
        Hiding
    _ -> Bool
    False

    isInstance :: LensHiding a => a -> Bool
    isInstance :: forall a. LensHiding a => a -> Bool
    isInstance a
    x =
      case a -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding a
    x of
        Instance{} -> Bool
    True
        Hiding
    _          -> Bool
    False

    -- | Ignores 'Overlappable'.
    sameHiding :: (LensHiding a, LensHiding b) => a -> b -> Bool
    sameHiding :: forall a b. (LensHiding a, LensHiding b) => a -> b -> Bool
    sameHiding a
    x b
    y =
      case (a -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding a
    x, b -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding b
    y) of
        (Instance{}, Instance{}) -> Bool
    True
        (Hiding
    hx, Hiding
    hy)                 -> Hiding
    hx Hiding -> Hiding -> Bool
    forall a. Eq a => a -> a -> Bool
    == Hiding
    hy

    -- | @prettyHiding info visible doc@ puts the correct braces
    --   around @doc@ according to info @info@ and returns
    --   @visible doc@ if the we deal with a visible thing.
    prettyHiding :: LensHiding a => a -> (Doc -> Doc) -> Doc -> Doc
    prettyHiding :: forall a. LensHiding a => a -> (Doc -> Doc) -> Doc -> Doc
    prettyHiding a
    a Doc -> Doc
    parens =
      case a -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding a
    a of
        Hiding
    Hidden     -> Doc -> Doc
    braces'
        Instance{} -> Doc -> Doc
    dbraces
        Hiding
    NotHidden  -> Doc -> Doc
    parens

    instance Pretty a => Pretty (WithHiding a) where
      pretty :: WithHiding a -> Doc
    pretty WithHiding a
    w = WithHiding a -> (Doc -> Doc) -> Doc -> Doc
    forall a. LensHiding a => a -> (Doc -> Doc) -> Doc -> Doc
    prettyHiding WithHiding a
    w Doc -> Doc
    forall a. a -> a
    id (Doc -> Doc) -> Doc -> Doc
    forall a b. (a -> b) -> a -> b
    $ a -> Doc
    forall a. Pretty a => a -> Doc
    pretty (a -> Doc) -> a -> Doc
    forall a b. (a -> b) -> a -> b
    $ WithHiding a -> a
    forall (t :: * -> *) a. Decoration t => t a -> a
    dget WithHiding a
    w

    ---------------------------------------------------------------------------
    -- * Modalities
    ---------------------------------------------------------------------------

    -- | Type wrapper to indicate additive monoid/semigroup context.
    newtype UnderAddition t = UnderAddition t deriving (Int -> UnderAddition t -> ShowS
    [UnderAddition t] -> ShowS
    UnderAddition t -> ArgName
    (Int -> UnderAddition t -> ShowS)
    -> (UnderAddition t -> ArgName)
    -> ([UnderAddition t] -> ShowS)
    -> Show (UnderAddition t)
    forall t. Show t => Int -> UnderAddition t -> ShowS
    forall t. Show t => [UnderAddition t] -> ShowS
    forall t. Show t => UnderAddition t -> ArgName
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall t. Show t => Int -> UnderAddition t -> ShowS
    showsPrec :: Int -> UnderAddition t -> ShowS
    $cshow :: forall t. Show t => UnderAddition t -> ArgName
    show :: UnderAddition t -> ArgName
    $cshowList :: forall t. Show t => [UnderAddition t] -> ShowS
    showList :: [UnderAddition t] -> ShowS
    Show, (forall a b. (a -> b) -> UnderAddition a -> UnderAddition b)
    -> (forall a b. a -> UnderAddition b -> UnderAddition a)
    -> Functor UnderAddition
    forall a b. a -> UnderAddition b -> UnderAddition a
    forall a b. (a -> b) -> UnderAddition a -> UnderAddition b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> UnderAddition a -> UnderAddition b
    fmap :: forall a b. (a -> b) -> UnderAddition a -> UnderAddition b
    $c<$ :: forall a b. a -> UnderAddition b -> UnderAddition a
    <$ :: forall a b. a -> UnderAddition b -> UnderAddition a
    Functor, UnderAddition t -> UnderAddition t -> Bool
    (UnderAddition t -> UnderAddition t -> Bool)
    -> (UnderAddition t -> UnderAddition t -> Bool)
    -> Eq (UnderAddition t)
    forall t. Eq t => UnderAddition t -> UnderAddition t -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall t. Eq t => UnderAddition t -> UnderAddition t -> Bool
    == :: UnderAddition t -> UnderAddition t -> Bool
    $c/= :: forall t. Eq t => UnderAddition t -> UnderAddition t -> Bool
    /= :: UnderAddition t -> UnderAddition t -> Bool
    Eq, Eq (UnderAddition t)
    Eq (UnderAddition t) =>
    (UnderAddition t -> UnderAddition t -> Ordering)
    -> (UnderAddition t -> UnderAddition t -> Bool)
    -> (UnderAddition t -> UnderAddition t -> Bool)
    -> (UnderAddition t -> UnderAddition t -> Bool)
    -> (UnderAddition t -> UnderAddition t -> Bool)
    -> (UnderAddition t -> UnderAddition t -> UnderAddition t)
    -> (UnderAddition t -> UnderAddition t -> UnderAddition t)
    -> Ord (UnderAddition t)
    UnderAddition t -> UnderAddition t -> Bool
    UnderAddition t -> UnderAddition t -> Ordering
    UnderAddition t -> UnderAddition t -> UnderAddition t
    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 t. Ord t => Eq (UnderAddition t)
    forall t. Ord t => UnderAddition t -> UnderAddition t -> Bool
    forall t. Ord t => UnderAddition t -> UnderAddition t -> Ordering
    forall t.
    Ord t =>
    UnderAddition t -> UnderAddition t -> UnderAddition t
    $ccompare :: forall t. Ord t => UnderAddition t -> UnderAddition t -> Ordering
    compare :: UnderAddition t -> UnderAddition t -> Ordering
    $c< :: forall t. Ord t => UnderAddition t -> UnderAddition t -> Bool
    < :: UnderAddition t -> UnderAddition t -> Bool
    $c<= :: forall t. Ord t => UnderAddition t -> UnderAddition t -> Bool
    <= :: UnderAddition t -> UnderAddition t -> Bool
    $c> :: forall t. Ord t => UnderAddition t -> UnderAddition t -> Bool
    > :: UnderAddition t -> UnderAddition t -> Bool
    $c>= :: forall t. Ord t => UnderAddition t -> UnderAddition t -> Bool
    >= :: UnderAddition t -> UnderAddition t -> Bool
    $cmax :: forall t.
    Ord t =>
    UnderAddition t -> UnderAddition t -> UnderAddition t
    max :: UnderAddition t -> UnderAddition t -> UnderAddition t
    $cmin :: forall t.
    Ord t =>
    UnderAddition t -> UnderAddition t -> UnderAddition t
    min :: UnderAddition t -> UnderAddition t -> UnderAddition t
    Ord, Comparable (UnderAddition t)
    Comparable (UnderAddition t) -> PartialOrd (UnderAddition t)
    forall t. PartialOrd t => Comparable (UnderAddition t)
    forall a. Comparable a -> PartialOrd a
    $ccomparable :: forall t. PartialOrd t => Comparable (UnderAddition t)
    comparable :: Comparable (UnderAddition t)
    PartialOrd)

    instance Applicative UnderAddition where
      pure :: forall a. a -> UnderAddition a
    pure = a -> UnderAddition a
    forall a. a -> UnderAddition a
    UnderAddition
      <*> :: forall a b.
    UnderAddition (a -> b) -> UnderAddition a -> UnderAddition b
    (<*>) (UnderAddition a -> b
    f) (UnderAddition a
    a) = b -> UnderAddition b
    forall a. a -> UnderAddition a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (a -> b
    f a
    a)

    -- | Type wrapper to indicate composition or multiplicative monoid/semigroup context.
    newtype UnderComposition t = UnderComposition t deriving (Int -> UnderComposition t -> ShowS
    [UnderComposition t] -> ShowS
    UnderComposition t -> ArgName
    (Int -> UnderComposition t -> ShowS)
    -> (UnderComposition t -> ArgName)
    -> ([UnderComposition t] -> ShowS)
    -> Show (UnderComposition t)
    forall t. Show t => Int -> UnderComposition t -> ShowS
    forall t. Show t => [UnderComposition t] -> ShowS
    forall t. Show t => UnderComposition t -> ArgName
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall t. Show t => Int -> UnderComposition t -> ShowS
    showsPrec :: Int -> UnderComposition t -> ShowS
    $cshow :: forall t. Show t => UnderComposition t -> ArgName
    show :: UnderComposition t -> ArgName
    $cshowList :: forall t. Show t => [UnderComposition t] -> ShowS
    showList :: [UnderComposition t] -> ShowS
    Show, (forall a b. (a -> b) -> UnderComposition a -> UnderComposition b)
    -> (forall a b. a -> UnderComposition b -> UnderComposition a)
    -> Functor UnderComposition
    forall a b. a -> UnderComposition b -> UnderComposition a
    forall a b. (a -> b) -> UnderComposition a -> UnderComposition b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> UnderComposition a -> UnderComposition b
    fmap :: forall a b. (a -> b) -> UnderComposition a -> UnderComposition b
    $c<$ :: forall a b. a -> UnderComposition b -> UnderComposition a
    <$ :: forall a b. a -> UnderComposition b -> UnderComposition a
    Functor, UnderComposition t -> UnderComposition t -> Bool
    (UnderComposition t -> UnderComposition t -> Bool)
    -> (UnderComposition t -> UnderComposition t -> Bool)
    -> Eq (UnderComposition t)
    forall t. Eq t => UnderComposition t -> UnderComposition t -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall t. Eq t => UnderComposition t -> UnderComposition t -> Bool
    == :: UnderComposition t -> UnderComposition t -> Bool
    $c/= :: forall t. Eq t => UnderComposition t -> UnderComposition t -> Bool
    /= :: UnderComposition t -> UnderComposition t -> Bool
    Eq, Eq (UnderComposition t)
    Eq (UnderComposition t) =>
    (UnderComposition t -> UnderComposition t -> Ordering)
    -> (UnderComposition t -> UnderComposition t -> Bool)
    -> (UnderComposition t -> UnderComposition t -> Bool)
    -> (UnderComposition t -> UnderComposition t -> Bool)
    -> (UnderComposition t -> UnderComposition t -> Bool)
    -> (UnderComposition t -> UnderComposition t -> UnderComposition t)
    -> (UnderComposition t -> UnderComposition t -> UnderComposition t)
    -> Ord (UnderComposition t)
    UnderComposition t -> UnderComposition t -> Bool
    UnderComposition t -> UnderComposition t -> Ordering
    UnderComposition t -> UnderComposition t -> UnderComposition t
    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 t. Ord t => Eq (UnderComposition t)
    forall t. Ord t => UnderComposition t -> UnderComposition t -> Bool
    forall t.
    Ord t =>
    UnderComposition t -> UnderComposition t -> Ordering
    forall t.
    Ord t =>
    UnderComposition t -> UnderComposition t -> UnderComposition t
    $ccompare :: forall t.
    Ord t =>
    UnderComposition t -> UnderComposition t -> Ordering
    compare :: UnderComposition t -> UnderComposition t -> Ordering
    $c< :: forall t. Ord t => UnderComposition t -> UnderComposition t -> Bool
    < :: UnderComposition t -> UnderComposition t -> Bool
    $c<= :: forall t. Ord t => UnderComposition t -> UnderComposition t -> Bool
    <= :: UnderComposition t -> UnderComposition t -> Bool
    $c> :: forall t. Ord t => UnderComposition t -> UnderComposition t -> Bool
    > :: UnderComposition t -> UnderComposition t -> Bool
    $c>= :: forall t. Ord t => UnderComposition t -> UnderComposition t -> Bool
    >= :: UnderComposition t -> UnderComposition t -> Bool
    $cmax :: forall t.
    Ord t =>
    UnderComposition t -> UnderComposition t -> UnderComposition t
    max :: UnderComposition t -> UnderComposition t -> UnderComposition t
    $cmin :: forall t.
    Ord t =>
    UnderComposition t -> UnderComposition t -> UnderComposition t
    min :: UnderComposition t -> UnderComposition t -> UnderComposition t
    Ord, Comparable (UnderComposition t)
    Comparable (UnderComposition t) -> PartialOrd (UnderComposition t)
    forall t. PartialOrd t => Comparable (UnderComposition t)
    forall a. Comparable a -> PartialOrd a
    $ccomparable :: forall t. PartialOrd t => Comparable (UnderComposition t)
    comparable :: Comparable (UnderComposition t)
    PartialOrd)

    instance Applicative UnderComposition where
      pure :: forall a. a -> UnderComposition a
    pure = a -> UnderComposition a
    forall a. a -> UnderComposition a
    UnderComposition
      <*> :: forall a b.
    UnderComposition (a -> b)
    -> UnderComposition a -> UnderComposition b
    (<*>) (UnderComposition a -> b
    f) (UnderComposition a
    a) = b -> UnderComposition b
    forall a. a -> UnderComposition a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (a -> b
    f a
    a)

    -- | We have a tuple of modalities, which might not be fully orthogonal.
    --   For example, irrelevant stuff is also run-time irrelevant.
    data Modality = Modality
      { Modality -> Relevance
    modRelevance :: Relevance
          -- ^ Legacy irrelevance.
          --   See Pfenning, LiCS 2001; Abel, Vezzosi and Winterhalter, ICFP 2017.
      , Modality -> Quantity
    modQuantity  :: Quantity
          -- ^ Cardinality / runtime erasure.
          --   See Conor McBride, I got plenty o' nutting, Wadlerfest 2016.
          --   See Bob Atkey, Syntax and Semantics of Quantitative Type Theory, LiCS 2018.
      , Modality -> Cohesion
    modCohesion :: Cohesion
          -- ^ Cohesion/what was in Agda-flat.
          --   see "Brouwer's fixed-point theorem in real-cohesive homotopy type theory" (arXiv:1509.07584)
          --   Currently only the comonad is implemented.
      , Modality -> PolarityModality
    modPolarity :: PolarityModality
          -- ^ Polarity annotations (strictly positive, ...)
      } deriving (Modality -> Modality -> Bool
    (Modality -> Modality -> Bool)
    -> (Modality -> Modality -> Bool) -> Eq Modality
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Modality -> Modality -> Bool
    == :: Modality -> Modality -> Bool
    $c/= :: Modality -> Modality -> Bool
    /= :: Modality -> Modality -> Bool
    Eq, Eq Modality
    Eq Modality =>
    (Modality -> Modality -> Ordering)
    -> (Modality -> Modality -> Bool)
    -> (Modality -> Modality -> Bool)
    -> (Modality -> Modality -> Bool)
    -> (Modality -> Modality -> Bool)
    -> (Modality -> Modality -> Modality)
    -> (Modality -> Modality -> Modality)
    -> Ord Modality
    Modality -> Modality -> Bool
    Modality -> Modality -> Ordering
    Modality -> Modality -> Modality
    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
    $ccompare :: Modality -> Modality -> Ordering
    compare :: Modality -> Modality -> Ordering
    $c< :: Modality -> Modality -> Bool
    < :: Modality -> Modality -> Bool
    $c<= :: Modality -> Modality -> Bool
    <= :: Modality -> Modality -> Bool
    $c> :: Modality -> Modality -> Bool
    > :: Modality -> Modality -> Bool
    $c>= :: Modality -> Modality -> Bool
    >= :: Modality -> Modality -> Bool
    $cmax :: Modality -> Modality -> Modality
    max :: Modality -> Modality -> Modality
    $cmin :: Modality -> Modality -> Modality
    min :: Modality -> Modality -> Modality
    Ord, Int -> Modality -> ShowS
    [Modality] -> ShowS
    Modality -> ArgName
    (Int -> Modality -> ShowS)
    -> (Modality -> ArgName) -> ([Modality] -> ShowS) -> Show Modality
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Modality -> ShowS
    showsPrec :: Int -> Modality -> ShowS
    $cshow :: Modality -> ArgName
    show :: Modality -> ArgName
    $cshowList :: [Modality] -> ShowS
    showList :: [Modality] -> ShowS
    Show, (forall x. Modality -> Rep Modality x)
    -> (forall x. Rep Modality x -> Modality) -> Generic Modality
    forall x. Rep Modality x -> Modality
    forall x. Modality -> Rep Modality x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Modality -> Rep Modality x
    from :: forall x. Modality -> Rep Modality x
    $cto :: forall x. Rep Modality x -> Modality
    to :: forall x. Rep Modality x -> Modality
    Generic)

    -- | Dominance ordering.
    instance PartialOrd Modality where
      comparable :: Comparable Modality
    comparable (Modality Relevance
    r Quantity
    q Cohesion
    c PolarityModality
    p) (Modality Relevance
    r' Quantity
    q' Cohesion
    c' PolarityModality
    p') = Comparable (Relevance, (Quantity, (Cohesion, PolarityModality)))
    forall a. PartialOrd a => Comparable a
    comparable (Relevance
    r, (Quantity
    q, (Cohesion
    c, PolarityModality
    p))) (Relevance
    r', (Quantity
    q', (Cohesion
    c', PolarityModality
    p')))

    -- | Pointwise composition.
    instance Semigroup (UnderComposition Modality) where
      <> :: UnderComposition Modality
    -> UnderComposition Modality -> UnderComposition Modality
    (<>) = (Modality -> Modality -> Modality)
    -> UnderComposition Modality
    -> UnderComposition Modality
    -> UnderComposition Modality
    forall a b c.
    (a -> b -> c)
    -> UnderComposition a -> UnderComposition b -> UnderComposition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Modality -> Modality -> Modality
    composeModality

    -- | Pointwise composition unit.
    instance Monoid (UnderComposition Modality) where
      mempty :: UnderComposition Modality
    mempty  = Modality -> UnderComposition Modality
    forall a. a -> UnderComposition a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Modality
    unitModality
      mappend :: UnderComposition Modality
    -> UnderComposition Modality -> UnderComposition Modality
    mappend = UnderComposition Modality
    -> UnderComposition Modality -> UnderComposition Modality
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance POSemigroup (UnderComposition Modality) where
    instance POMonoid (UnderComposition Modality) where

    instance LeftClosedPOMonoid (UnderComposition Modality) where
      inverseCompose :: UnderComposition Modality
    -> UnderComposition Modality -> UnderComposition Modality
    inverseCompose = (Modality -> Modality -> Modality)
    -> UnderComposition Modality
    -> UnderComposition Modality
    -> UnderComposition Modality
    forall a b c.
    (a -> b -> c)
    -> UnderComposition a -> UnderComposition b -> UnderComposition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Modality -> Modality -> Modality
    inverseComposeModality

    -- | Pointwise addition.
    instance Semigroup (UnderAddition Modality) where
      <> :: UnderAddition Modality
    -> UnderAddition Modality -> UnderAddition Modality
    (<>) = (Modality -> Modality -> Modality)
    -> UnderAddition Modality
    -> UnderAddition Modality
    -> UnderAddition Modality
    forall a b c.
    (a -> b -> c)
    -> UnderAddition a -> UnderAddition b -> UnderAddition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Modality -> Modality -> Modality
    addModality

    -- | Pointwise additive unit.
    instance Monoid (UnderAddition Modality) where
      mempty :: UnderAddition Modality
    mempty  = Modality -> UnderAddition Modality
    forall a. a -> UnderAddition a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Modality
    zeroModality
      mappend :: UnderAddition Modality
    -> UnderAddition Modality -> UnderAddition Modality
    mappend = UnderAddition Modality
    -> UnderAddition Modality -> UnderAddition Modality
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance POSemigroup (UnderAddition Modality) where
    instance POMonoid (UnderAddition Modality) where

    instance Pretty Modality where
      pretty :: Modality -> Doc
    pretty (Modality Relevance
    r Quantity
    q Cohesion
    c PolarityModality
    p) = [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    hsep
        [ Relevance -> Doc
    forall a. Pretty a => a -> Doc
    pretty Relevance
    r
        , Quantity -> Doc
    forall a. Pretty a => a -> Doc
    pretty Quantity
    q
        , Cohesion -> Doc
    forall a. Pretty a => a -> Doc
    pretty Cohesion
    c
        , PolarityModality -> Doc
    forall a. Pretty a => a -> Doc
    pretty PolarityModality
    p
        ]

    -- | @m `moreUsableModality` m'@ means that an @m@ can be used
    --   where ever an @m'@ is required.

    moreUsableModality :: Modality -> Modality -> Bool
    moreUsableModality :: Modality -> Modality -> Bool
    moreUsableModality Modality
    m Modality
    m' = Modality -> PartialOrdering -> Modality -> Bool
    forall a. PartialOrd a => a -> PartialOrdering -> a -> Bool
    related Modality
    m PartialOrdering
    POLE Modality
    m'

    usableModality :: LensModality a => a -> Bool
    usableModality :: forall a. LensModality a => a -> Bool
    usableModality a
    a = Modality -> Bool
    forall a. LensRelevance a => a -> Bool
    usableRelevance Modality
    m Bool -> Bool -> Bool
    && Modality -> Bool
    forall a. LensQuantity a => a -> Bool
    usableQuantity Modality
    m Bool -> Bool -> Bool
    && Modality -> Bool
    forall a. LensCohesion a => a -> Bool
    usableCohesion Modality
    m Bool -> Bool -> Bool
    && Modality -> Bool
    forall a. LensModalPolarity a => a -> Bool
    usablePolarity Modality
    m
      where m :: Modality
    m = a -> Modality
    forall a. LensModality a => a -> Modality
    getModality a
    a

    -- | Multiplicative monoid (standard monoid).
    composeModality :: Modality -> Modality -> Modality
    composeModality :: Modality -> Modality -> Modality
    composeModality (Modality Relevance
    r Quantity
    q Cohesion
    c PolarityModality
    p) (Modality Relevance
    r' Quantity
    q' Cohesion
    c' PolarityModality
    p') =
        Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality
    Modality (Relevance
    r Relevance -> Relevance -> Relevance
    `composeRelevance` Relevance
    r')
                 (Quantity
    q Quantity -> Quantity -> Quantity
    `composeQuantity` Quantity
    q')
                 (Cohesion
    c Cohesion -> Cohesion -> Cohesion
    `composeCohesion` Cohesion
    c')
                 (PolarityModality
    p PolarityModality -> PolarityModality -> PolarityModality
    `composePolarity` PolarityModality
    p')

    -- | Compose with modality flag from the left.
    --   This function is e.g. used to update the modality information
    --   on pattern variables @a@ after a match against something of modality @q@.
    applyModality :: LensModality a => Modality -> a -> a
    applyModality :: forall a. LensModality a => Modality -> a -> a
    applyModality Modality
    m = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality (Modality
    m Modality -> Modality -> Modality
    `composeModality`)

    -- | @inverseComposeModality r x@ returns the least modality @y@
    --   such that forall @x@, @y@ we have
    --   @x \`moreUsableModality\` (r \`composeModality\` y)@
    --   iff
    --   @(r \`inverseComposeModality\` x) \`moreUsableModality\` y@ (Galois connection).
    inverseComposeModality :: Modality -> Modality -> Modality
    inverseComposeModality :: Modality -> Modality -> Modality
    inverseComposeModality (Modality Relevance
    r Quantity
    q Cohesion
    c PolarityModality
    p) (Modality Relevance
    r' Quantity
    q' Cohesion
    c' PolarityModality
    p') =
      Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality
    Modality (Relevance
    r Relevance -> Relevance -> Relevance
    `inverseComposeRelevance` Relevance
    r')
               (Quantity
    q Quantity -> Quantity -> Quantity
    `inverseComposeQuantity`  Quantity
    q')
               (Cohesion
    c Cohesion -> Cohesion -> Cohesion
    `inverseComposeCohesion`  Cohesion
    c')
               (PolarityModality
    p PolarityModality -> PolarityModality -> PolarityModality
    `inverseComposePolarity`  PolarityModality
    p')

    -- | Left division by a 'Modality'.
    --   Used e.g. to modify context when going into a @m@ argument.
    --
    -- Note that this function does not change quantities.
    inverseApplyModalityButNotQuantity :: LensModality a => Modality -> a -> a
    inverseApplyModalityButNotQuantity :: forall a. LensModality a => Modality -> a -> a
    inverseApplyModalityButNotQuantity Modality
    m =
      (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality (Modality
    m' Modality -> Modality -> Modality
    `inverseComposeModality`)
      where
      m' :: Modality
    m' = Quantity -> Modality -> Modality
    forall a. LensQuantity a => Quantity -> a -> a
    setQuantity (Q1Origin -> Quantity
    Quantity1 Q1Origin
    Q1Inferred) Modality
    m

    -- | 'Modality' forms a pointwise additive monoid.
    addModality :: Modality -> Modality -> Modality
    addModality :: Modality -> Modality -> Modality
    addModality (Modality Relevance
    r Quantity
    q Cohesion
    c PolarityModality
    p) (Modality Relevance
    r' Quantity
    q' Cohesion
    c' PolarityModality
    p') =
      Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality
    Modality (Relevance -> Relevance -> Relevance
    addRelevance Relevance
    r Relevance
    r')
               (Quantity -> Quantity -> Quantity
    addQuantity  Quantity
    q Quantity
    q')
               (Cohesion -> Cohesion -> Cohesion
    addCohesion  Cohesion
    c Cohesion
    c')
               (PolarityModality -> PolarityModality -> PolarityModality
    addPolarity  PolarityModality
    p PolarityModality
    p')

    -- | Identity under addition
    zeroModality :: Modality
    zeroModality :: Modality
    zeroModality = Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality
    Modality Relevance
    zeroRelevance Quantity
    zeroQuantity Cohesion
    zeroCohesion PolarityModality
    zeroPolarity

    -- | Identity under composition
    unitModality :: Modality
    unitModality :: Modality
    unitModality = Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality
    Modality Relevance
    unitRelevance Quantity
    unitQuantity Cohesion
    unitCohesion PolarityModality
    unitPolarity

    -- | Absorptive element under addition.
    topModality :: Modality
    topModality :: Modality
    topModality = Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality
    Modality Relevance
    topRelevance Quantity
    topQuantity Cohesion
    topCohesion PolarityModality
    topPolarity

    -- | The default Modality
    --   Beware that this is neither the additive unit nor the unit under
    --   composition, because the default quantity is ω.
    defaultModality :: Modality
    defaultModality :: Modality
    defaultModality = Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality
    Modality Relevance
    defaultRelevance Quantity
    defaultQuantity Cohesion
    defaultCohesion PolarityModality
    defaultPolarity

    -- | The default Modality terms are checked against.
    defaultCheckModality :: Modality
    defaultCheckModality :: Modality
    defaultCheckModality = Modality
    defaultModality { modPolarity = withStandardLock StrictlyPositive }

    -- | Extract the positional modality component for checks regarding only them.
    positionalModalityComponent :: Modality -> Modality
    positionalModalityComponent :: Modality -> Modality
    positionalModalityComponent Modality
    m =
      Modality
    defaultModality {modCohesion = modCohesion m}

    -- | Equality ignoring origin.

    sameModality :: (LensModality a, LensModality b) => a -> b -> Bool
    sameModality :: forall a b. (LensModality a, LensModality b) => a -> b -> Bool
    sameModality a
    x b
    y = case (a -> Modality
    forall a. LensModality a => a -> Modality
    getModality a
    x , b -> Modality
    forall a. LensModality a => a -> Modality
    getModality b
    y) of
      (Modality Relevance
    r Quantity
    q Cohesion
    c PolarityModality
    p , Modality Relevance
    r' Quantity
    q' Cohesion
    c' PolarityModality
    p') -> Relevance -> Relevance -> Bool
    sameRelevance Relevance
    r Relevance
    r' Bool -> Bool -> Bool
    && Quantity -> Quantity -> Bool
    sameQuantity Quantity
    q Quantity
    q' Bool -> Bool -> Bool
    && Cohesion -> Cohesion -> Bool
    sameCohesion Cohesion
    c Cohesion
    c' Bool -> Bool -> Bool
    && PolarityModality -> PolarityModality -> Bool
    samePolarity PolarityModality
    p PolarityModality
    p'

    instance Null Modality where
      empty :: Modality
    empty = Modality
    defaultModality
      null :: Modality -> Bool
    null (Modality Relevance
    r Quantity
    q Cohesion
    c PolarityModality
    p) = [Bool] -> Bool
    forall (t :: * -> *). Foldable t => t Bool -> Bool
    and [ Relevance -> Bool
    forall a. Null a => a -> Bool
    null Relevance
    r, Quantity -> Bool
    forall a. Null a => a -> Bool
    null Quantity
    q, Cohesion -> Bool
    forall a. Null a => a -> Bool
    null Cohesion
    c, PolarityModality -> Bool
    forall a. Null a => a -> Bool
    null PolarityModality
    p ]

    -- boilerplate instances

    instance HasRange Modality where
      getRange :: Modality -> Range
    getRange (Modality Relevance
    r Quantity
    q Cohesion
    c PolarityModality
    p) = (Relevance, Quantity, Cohesion, PolarityModality) -> Range
    forall a. HasRange a => a -> Range
    getRange (Relevance
    r, Quantity
    q, Cohesion
    c, PolarityModality
    p)

    instance KillRange Modality where
      killRange :: Modality -> Modality
    killRange (Modality Relevance
    r Quantity
    q Cohesion
    c PolarityModality
    p) = (Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality)
    -> Relevance
    -> Quantity
    -> Cohesion
    -> PolarityModality
    -> Modality
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality
    Modality Relevance
    r Quantity
    q Cohesion
    c PolarityModality
    p

    instance NFData Modality where

    -- Lens stuff

    lModRelevance :: Lens' Modality Relevance
    lModRelevance :: Lens' Modality Relevance
    lModRelevance Relevance -> f Relevance
    f Modality
    m = Relevance -> f Relevance
    f (Modality -> Relevance
    modRelevance Modality
    m) f Relevance -> (Relevance -> Modality) -> f Modality
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \ Relevance
    r -> Modality
    m { modRelevance = r }

    lModQuantity :: Lens' Modality Quantity
    lModQuantity :: Lens' Modality Quantity
    lModQuantity Quantity -> f Quantity
    f Modality
    m = Quantity -> f Quantity
    f (Modality -> Quantity
    modQuantity Modality
    m) f Quantity -> (Quantity -> Modality) -> f Modality
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \ Quantity
    q -> Modality
    m { modQuantity = q }

    lModCohesion :: Lens' Modality Cohesion
    lModCohesion :: Lens' Modality Cohesion
    lModCohesion Cohesion -> f Cohesion
    f Modality
    m = Cohesion -> f Cohesion
    f (Modality -> Cohesion
    modCohesion Modality
    m) f Cohesion -> (Cohesion -> Modality) -> f Modality
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \ Cohesion
    q -> Modality
    m { modCohesion = q }

    lModPolarity :: Lens' Modality PolarityModality
    lModPolarity :: Lens' Modality PolarityModality
    lModPolarity PolarityModality -> f PolarityModality
    f Modality
    m = PolarityModality -> f PolarityModality
    f (Modality -> PolarityModality
    modPolarity Modality
    m) f PolarityModality -> (PolarityModality -> Modality) -> f Modality
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \ PolarityModality
    p -> Modality
    m { modPolarity = p }

    class LensModality a where

      getModality :: a -> Modality

      setModality :: Modality -> a -> a
      setModality = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> (Modality -> Modality -> Modality) -> Modality -> a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Modality -> Modality -> Modality
    forall a b. a -> b -> a
    const

      mapModality :: (Modality -> Modality) -> a -> a

      default getModality :: LensArgInfo a => a -> Modality
      getModality = ArgInfo -> Modality
    argInfoModality (ArgInfo -> Modality) -> (a -> ArgInfo) -> a -> Modality
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo

      default mapModality :: LensArgInfo a => (Modality -> Modality) -> a -> a
      mapModality Modality -> Modality
    f = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a) -> (ArgInfo -> ArgInfo) -> a -> a
    forall a b. (a -> b) -> a -> b
    $ \ ArgInfo
    ai -> ArgInfo
    ai { argInfoModality = f $ argInfoModality ai }

    instance LensModality Modality where
      getModality :: Modality -> Modality
    getModality = Modality -> Modality
    forall a. a -> a
    id
      setModality :: Modality -> Modality -> Modality
    setModality = Modality -> Modality -> Modality
    forall a b. a -> b -> a
    const
      mapModality :: (Modality -> Modality) -> Modality -> Modality
    mapModality = (Modality -> Modality) -> Modality -> Modality
    forall a. a -> a
    id

    instance LensRelevance Modality where
      getRelevance :: Modality -> Relevance
    getRelevance = Modality -> Relevance
    modRelevance
      setRelevance :: Relevance -> Modality -> Modality
    setRelevance Relevance
    h Modality
    m = Modality
    m { modRelevance = h }
      mapRelevance :: (Relevance -> Relevance) -> Modality -> Modality
    mapRelevance Relevance -> Relevance
    f Modality
    m = Modality
    m { modRelevance = f (modRelevance m) }

    instance LensQuantity Modality where
      getQuantity :: Modality -> Quantity
    getQuantity = Modality -> Quantity
    modQuantity
      setQuantity :: Quantity -> Modality -> Modality
    setQuantity Quantity
    h Modality
    m = Modality
    m { modQuantity = h }
      mapQuantity :: (Quantity -> Quantity) -> Modality -> Modality
    mapQuantity Quantity -> Quantity
    f Modality
    m = Modality
    m { modQuantity = f (modQuantity m) }

    instance LensCohesion Modality where
      getCohesion :: Modality -> Cohesion
    getCohesion = Modality -> Cohesion
    modCohesion
      setCohesion :: Cohesion -> Modality -> Modality
    setCohesion Cohesion
    h Modality
    m = Modality
    m { modCohesion = h }
      mapCohesion :: (Cohesion -> Cohesion) -> Modality -> Modality
    mapCohesion Cohesion -> Cohesion
    f Modality
    m = Modality
    m { modCohesion = f (modCohesion m) }

    instance LensModalPolarity Modality where
      getModalPolarity :: Modality -> PolarityModality
    getModalPolarity = Modality -> PolarityModality
    modPolarity
      setModalPolarity :: PolarityModality -> Modality -> Modality
    setModalPolarity PolarityModality
    h Modality
    m = Modality
    m { modPolarity = h }
      mapModalPolarity :: (PolarityModality -> PolarityModality) -> Modality -> Modality
    mapModalPolarity PolarityModality -> PolarityModality
    f Modality
    m = Modality
    m { modPolarity = f (modPolarity m) }

    -- default accessors for Relevance

    getRelevanceMod :: LensModality a => LensGet a Relevance
    getRelevanceMod :: forall a. LensModality a => LensGet a Relevance
    getRelevanceMod = Modality -> Relevance
    forall a. LensRelevance a => a -> Relevance
    getRelevance (Modality -> Relevance) -> (a -> Modality) -> a -> Relevance
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Modality
    forall a. LensModality a => a -> Modality
    getModality

    setRelevanceMod :: LensModality a => LensSet a Relevance
    setRelevanceMod :: forall a. LensModality a => LensSet a Relevance
    setRelevanceMod = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> (Relevance -> Modality -> Modality) -> Relevance -> a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Relevance -> Modality -> Modality
    forall a. LensRelevance a => Relevance -> a -> a
    setRelevance

    mapRelevanceMod :: LensModality a => LensMap a Relevance
    mapRelevanceMod :: forall a. LensModality a => LensMap a Relevance
    mapRelevanceMod = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> ((Relevance -> Relevance) -> Modality -> Modality)
    -> (Relevance -> Relevance)
    -> a
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Relevance -> Relevance) -> Modality -> Modality
    forall a. LensRelevance a => (Relevance -> Relevance) -> a -> a
    mapRelevance

    -- default accessors for Quantity

    getQuantityMod :: LensModality a => LensGet a Quantity
    getQuantityMod :: forall a. LensModality a => LensGet a Quantity
    getQuantityMod = Modality -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity (Modality -> Quantity) -> (a -> Modality) -> a -> Quantity
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Modality
    forall a. LensModality a => a -> Modality
    getModality

    setQuantityMod :: LensModality a => LensSet a Quantity
    setQuantityMod :: forall a. LensModality a => LensSet a Quantity
    setQuantityMod = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> (Quantity -> Modality -> Modality) -> Quantity -> a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Quantity -> Modality -> Modality
    forall a. LensQuantity a => Quantity -> a -> a
    setQuantity

    mapQuantityMod :: LensModality a => LensMap a Quantity
    mapQuantityMod :: forall a. LensModality a => LensMap a Quantity
    mapQuantityMod = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> ((Quantity -> Quantity) -> Modality -> Modality)
    -> (Quantity -> Quantity)
    -> a
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Quantity -> Quantity) -> Modality -> Modality
    forall a. LensQuantity a => (Quantity -> Quantity) -> a -> a
    mapQuantity

    -- default accessors for Cohesion

    getCohesionMod :: LensModality a => LensGet a Cohesion
    getCohesionMod :: forall a. LensModality a => LensGet a Cohesion
    getCohesionMod = Modality -> Cohesion
    forall a. LensCohesion a => a -> Cohesion
    getCohesion (Modality -> Cohesion) -> (a -> Modality) -> a -> Cohesion
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Modality
    forall a. LensModality a => a -> Modality
    getModality

    setCohesionMod :: LensModality a => LensSet a Cohesion
    setCohesionMod :: forall a. LensModality a => LensSet a Cohesion
    setCohesionMod = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> (Cohesion -> Modality -> Modality) -> Cohesion -> a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Cohesion -> Modality -> Modality
    forall a. LensCohesion a => Cohesion -> a -> a
    setCohesion

    mapCohesionMod :: LensModality a => LensMap a Cohesion
    mapCohesionMod :: forall a. LensModality a => LensMap a Cohesion
    mapCohesionMod = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> ((Cohesion -> Cohesion) -> Modality -> Modality)
    -> (Cohesion -> Cohesion)
    -> a
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Cohesion -> Cohesion) -> Modality -> Modality
    forall a. LensCohesion a => (Cohesion -> Cohesion) -> a -> a
    mapCohesion

    -- default accessors for Polarity

    getPolarityMod :: LensModality a => LensGet a PolarityModality
    getPolarityMod :: forall a. LensModality a => LensGet a PolarityModality
    getPolarityMod = Modality -> PolarityModality
    forall a. LensModalPolarity a => a -> PolarityModality
    getModalPolarity (Modality -> PolarityModality)
    -> (a -> Modality) -> a -> PolarityModality
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Modality
    forall a. LensModality a => a -> Modality
    getModality

    setPolarityMod :: LensModality a => LensSet a PolarityModality
    setPolarityMod :: forall a. LensModality a => LensSet a PolarityModality
    setPolarityMod = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> (PolarityModality -> Modality -> Modality)
    -> PolarityModality
    -> a
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PolarityModality -> Modality -> Modality
    forall a. LensModalPolarity a => PolarityModality -> a -> a
    setModalPolarity

    mapPolarityMod :: LensModality a => LensMap a PolarityModality
    mapPolarityMod :: forall a. LensModality a => LensMap a PolarityModality
    mapPolarityMod = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> ((PolarityModality -> PolarityModality) -> Modality -> Modality)
    -> (PolarityModality -> PolarityModality)
    -> a
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (PolarityModality -> PolarityModality) -> Modality -> Modality
    forall a.
    LensModalPolarity a =>
    (PolarityModality -> PolarityModality) -> a -> a
    mapModalPolarity

    ---------------------------------------------------------------------------
    -- * Quantities
    ---------------------------------------------------------------------------

    -- ** Quantity origin.

    -- | Origin of 'Quantity0'.
    data Q0Origin
      = Q0Inferred       -- ^ User wrote nothing.
      | Q0       Range   -- ^ User wrote "@0".
      | Q0Erased Range   -- ^ User wrote "@erased".
      deriving (Int -> Q0Origin -> ShowS
    [Q0Origin] -> ShowS
    Q0Origin -> ArgName
    (Int -> Q0Origin -> ShowS)
    -> (Q0Origin -> ArgName) -> ([Q0Origin] -> ShowS) -> Show Q0Origin
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Q0Origin -> ShowS
    showsPrec :: Int -> Q0Origin -> ShowS
    $cshow :: Q0Origin -> ArgName
    show :: Q0Origin -> ArgName
    $cshowList :: [Q0Origin] -> ShowS
    showList :: [Q0Origin] -> ShowS
    Show, (forall x. Q0Origin -> Rep Q0Origin x)
    -> (forall x. Rep Q0Origin x -> Q0Origin) -> Generic Q0Origin
    forall x. Rep Q0Origin x -> Q0Origin
    forall x. Q0Origin -> Rep Q0Origin x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Q0Origin -> Rep Q0Origin x
    from :: forall x. Q0Origin -> Rep Q0Origin x
    $cto :: forall x. Rep Q0Origin x -> Q0Origin
    to :: forall x. Rep Q0Origin x -> Q0Origin
    Generic, Q0Origin -> Q0Origin -> Bool
    (Q0Origin -> Q0Origin -> Bool)
    -> (Q0Origin -> Q0Origin -> Bool) -> Eq Q0Origin
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Q0Origin -> Q0Origin -> Bool
    == :: Q0Origin -> Q0Origin -> Bool
    $c/= :: Q0Origin -> Q0Origin -> Bool
    /= :: Q0Origin -> Q0Origin -> Bool
    Eq, Eq Q0Origin
    Eq Q0Origin =>
    (Q0Origin -> Q0Origin -> Ordering)
    -> (Q0Origin -> Q0Origin -> Bool)
    -> (Q0Origin -> Q0Origin -> Bool)
    -> (Q0Origin -> Q0Origin -> Bool)
    -> (Q0Origin -> Q0Origin -> Bool)
    -> (Q0Origin -> Q0Origin -> Q0Origin)
    -> (Q0Origin -> Q0Origin -> Q0Origin)
    -> Ord Q0Origin
    Q0Origin -> Q0Origin -> Bool
    Q0Origin -> Q0Origin -> Ordering
    Q0Origin -> Q0Origin -> Q0Origin
    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
    $ccompare :: Q0Origin -> Q0Origin -> Ordering
    compare :: Q0Origin -> Q0Origin -> Ordering
    $c< :: Q0Origin -> Q0Origin -> Bool
    < :: Q0Origin -> Q0Origin -> Bool
    $c<= :: Q0Origin -> Q0Origin -> Bool
    <= :: Q0Origin -> Q0Origin -> Bool
    $c> :: Q0Origin -> Q0Origin -> Bool
    > :: Q0Origin -> Q0Origin -> Bool
    $c>= :: Q0Origin -> Q0Origin -> Bool
    >= :: Q0Origin -> Q0Origin -> Bool
    $cmax :: Q0Origin -> Q0Origin -> Q0Origin
    max :: Q0Origin -> Q0Origin -> Q0Origin
    $cmin :: Q0Origin -> Q0Origin -> Q0Origin
    min :: Q0Origin -> Q0Origin -> Q0Origin
    Ord)

    -- | Origin of 'Quantity1'.
    data Q1Origin
      = Q1Inferred       -- ^ User wrote nothing.
      | Q1       Range   -- ^ User wrote "@1".
      | Q1Linear Range   -- ^ User wrote "@linear".
      deriving (Int -> Q1Origin -> ShowS
    [Q1Origin] -> ShowS
    Q1Origin -> ArgName
    (Int -> Q1Origin -> ShowS)
    -> (Q1Origin -> ArgName) -> ([Q1Origin] -> ShowS) -> Show Q1Origin
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Q1Origin -> ShowS
    showsPrec :: Int -> Q1Origin -> ShowS
    $cshow :: Q1Origin -> ArgName
    show :: Q1Origin -> ArgName
    $cshowList :: [Q1Origin] -> ShowS
    showList :: [Q1Origin] -> ShowS
    Show, (forall x. Q1Origin -> Rep Q1Origin x)
    -> (forall x. Rep Q1Origin x -> Q1Origin) -> Generic Q1Origin
    forall x. Rep Q1Origin x -> Q1Origin
    forall x. Q1Origin -> Rep Q1Origin x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Q1Origin -> Rep Q1Origin x
    from :: forall x. Q1Origin -> Rep Q1Origin x
    $cto :: forall x. Rep Q1Origin x -> Q1Origin
    to :: forall x. Rep Q1Origin x -> Q1Origin
    Generic, Q1Origin -> Q1Origin -> Bool
    (Q1Origin -> Q1Origin -> Bool)
    -> (Q1Origin -> Q1Origin -> Bool) -> Eq Q1Origin
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Q1Origin -> Q1Origin -> Bool
    == :: Q1Origin -> Q1Origin -> Bool
    $c/= :: Q1Origin -> Q1Origin -> Bool
    /= :: Q1Origin -> Q1Origin -> Bool
    Eq, Eq Q1Origin
    Eq Q1Origin =>
    (Q1Origin -> Q1Origin -> Ordering)
    -> (Q1Origin -> Q1Origin -> Bool)
    -> (Q1Origin -> Q1Origin -> Bool)
    -> (Q1Origin -> Q1Origin -> Bool)
    -> (Q1Origin -> Q1Origin -> Bool)
    -> (Q1Origin -> Q1Origin -> Q1Origin)
    -> (Q1Origin -> Q1Origin -> Q1Origin)
    -> Ord Q1Origin
    Q1Origin -> Q1Origin -> Bool
    Q1Origin -> Q1Origin -> Ordering
    Q1Origin -> Q1Origin -> Q1Origin
    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
    $ccompare :: Q1Origin -> Q1Origin -> Ordering
    compare :: Q1Origin -> Q1Origin -> Ordering
    $c< :: Q1Origin -> Q1Origin -> Bool
    < :: Q1Origin -> Q1Origin -> Bool
    $c<= :: Q1Origin -> Q1Origin -> Bool
    <= :: Q1Origin -> Q1Origin -> Bool
    $c> :: Q1Origin -> Q1Origin -> Bool
    > :: Q1Origin -> Q1Origin -> Bool
    $c>= :: Q1Origin -> Q1Origin -> Bool
    >= :: Q1Origin -> Q1Origin -> Bool
    $cmax :: Q1Origin -> Q1Origin -> Q1Origin
    max :: Q1Origin -> Q1Origin -> Q1Origin
    $cmin :: Q1Origin -> Q1Origin -> Q1Origin
    min :: Q1Origin -> Q1Origin -> Q1Origin
    Ord)

    -- | Origin of 'Quantityω'.
    data QωOrigin
      = QωInferred       -- ^ User wrote nothing.
      | Qω       Range   -- ^ User wrote "@ω".
      | QωPlenty Range   -- ^ User wrote "@plenty".
      deriving (Int -> QωOrigin -> ShowS
    [QωOrigin] -> ShowS
    QωOrigin -> ArgName
    (Int -> QωOrigin -> ShowS)
    -> (QωOrigin -> ArgName) -> ([QωOrigin] -> ShowS) -> Show QωOrigin
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> QωOrigin -> ShowS
    showsPrec :: Int -> QωOrigin -> ShowS
    $cshow :: QωOrigin -> ArgName
    show :: QωOrigin -> ArgName
    $cshowList :: [QωOrigin] -> ShowS
    showList :: [QωOrigin] -> ShowS
    Show, (forall x. QωOrigin -> Rep QωOrigin x)
    -> (forall x. Rep QωOrigin x -> QωOrigin) -> Generic QωOrigin
    forall x. Rep QωOrigin x -> QωOrigin
    forall x. QωOrigin -> Rep QωOrigin x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. QωOrigin -> Rep QωOrigin x
    from :: forall x. QωOrigin -> Rep QωOrigin x
    $cto :: forall x. Rep QωOrigin x -> QωOrigin
    to :: forall x. Rep QωOrigin x -> QωOrigin
    Generic, QωOrigin -> QωOrigin -> Bool
    (QωOrigin -> QωOrigin -> Bool)
    -> (QωOrigin -> QωOrigin -> Bool) -> Eq QωOrigin
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: QωOrigin -> QωOrigin -> Bool
    == :: QωOrigin -> QωOrigin -> Bool
    $c/= :: QωOrigin -> QωOrigin -> Bool
    /= :: QωOrigin -> QωOrigin -> Bool
    Eq, Eq QωOrigin
    Eq QωOrigin =>
    (QωOrigin -> QωOrigin -> Ordering)
    -> (QωOrigin -> QωOrigin -> Bool)
    -> (QωOrigin -> QωOrigin -> Bool)
    -> (QωOrigin -> QωOrigin -> Bool)
    -> (QωOrigin -> QωOrigin -> Bool)
    -> (QωOrigin -> QωOrigin -> QωOrigin)
    -> (QωOrigin -> QωOrigin -> QωOrigin)
    -> Ord QωOrigin
    QωOrigin -> QωOrigin -> Bool
    QωOrigin -> QωOrigin -> Ordering
    QωOrigin -> QωOrigin -> QωOrigin
    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
    $ccompare :: QωOrigin -> QωOrigin -> Ordering
    compare :: QωOrigin -> QωOrigin -> Ordering
    $c< :: QωOrigin -> QωOrigin -> Bool
    < :: QωOrigin -> QωOrigin -> Bool
    $c<= :: QωOrigin -> QωOrigin -> Bool
    <= :: QωOrigin -> QωOrigin -> Bool
    $c> :: QωOrigin -> QωOrigin -> Bool
    > :: QωOrigin -> QωOrigin -> Bool
    $c>= :: QωOrigin -> QωOrigin -> Bool
    >= :: QωOrigin -> QωOrigin -> Bool
    $cmax :: QωOrigin -> QωOrigin -> QωOrigin
    max :: QωOrigin -> QωOrigin -> QωOrigin
    $cmin :: QωOrigin -> QωOrigin -> QωOrigin
    min :: QωOrigin -> QωOrigin -> QωOrigin
    Ord)

    -- *** Instances for 'Q0Origin'.

    -- | Right-biased composition, because the left quantity
    --   acts as context, and the right one as occurrence.
    instance Semigroup Q0Origin where
      <> :: Q0Origin -> Q0Origin -> Q0Origin
    (<>) = ((Q0Origin, Q0Origin) -> Q0Origin)
    -> Q0Origin -> Q0Origin -> Q0Origin
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry (((Q0Origin, Q0Origin) -> Q0Origin)
     -> Q0Origin -> Q0Origin -> Q0Origin)
    -> ((Q0Origin, Q0Origin) -> Q0Origin)
    -> Q0Origin
    -> Q0Origin
    -> Q0Origin
    forall a b. (a -> b) -> a -> b
    $ \case
        (Q0Origin
    Q0Inferred, Q0Origin
    o) -> Q0Origin
    o
        (Q0Origin
    o, Q0Origin
    Q0Inferred) -> Q0Origin
    o
        (Q0Origin
    o, Q0       Range
    r) -> Range -> Q0Origin
    Q0 (Range -> Q0Origin) -> Range -> Q0Origin
    forall a b. (a -> b) -> a -> b
    $ Q0Origin -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange Q0Origin
    o Range
    r
        (Q0Origin
    o, Q0Erased Range
    r) -> Range -> Q0Origin
    Q0 (Range -> Q0Origin) -> Range -> Q0Origin
    forall a b. (a -> b) -> a -> b
    $ Q0Origin -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange Q0Origin
    o Range
    r

    instance Monoid Q0Origin where
      mempty :: Q0Origin
    mempty = Q0Origin
    Q0Inferred
      mappend :: Q0Origin -> Q0Origin -> Q0Origin
    mappend = Q0Origin -> Q0Origin -> Q0Origin
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance Null Q0Origin where
      empty :: Q0Origin
    empty = Q0Origin
    forall a. Monoid a => a
    mempty

    instance HasRange Q0Origin where
      getRange :: Q0Origin -> Range
    getRange = \case
        Q0Origin
    Q0Inferred -> Range
    forall a. Range' a
    noRange
        Q0       Range
    r -> Range
    r
        Q0Erased Range
    r -> Range
    r

    instance SetRange Q0Origin where
      setRange :: Range -> Q0Origin -> Q0Origin
    setRange Range
    r = \case
        Q0Origin
    Q0Inferred -> Q0Origin
    Q0Inferred
        Q0       Range
    _ -> Range -> Q0Origin
    Q0       Range
    r
        Q0Erased Range
    _ -> Range -> Q0Origin
    Q0Erased Range
    r

    instance KillRange Q0Origin where
      killRange :: Q0Origin -> Q0Origin
    killRange = \case
        Q0Origin
    Q0Inferred -> Q0Origin
    Q0Inferred
        Q0       Range
    _ -> Range -> Q0Origin
    Q0       Range
    forall a. Range' a
    noRange
        Q0Erased Range
    _ -> Range -> Q0Origin
    Q0Erased Range
    forall a. Range' a
    noRange

    instance NFData Q0Origin where
      rnf :: Q0Origin -> ()
    rnf = \case
        Q0Origin
    Q0Inferred -> ()
        Q0       Range
    _ -> ()
        Q0Erased Range
    _ -> ()

    instance Pretty Q0Origin where
      pretty :: Q0Origin -> Doc
    pretty = \case
        Q0Origin
    Q0Inferred -> Doc
    forall a. Null a => a
    empty
        Q0{}       -> Doc
    "@0"
        Q0Erased{} -> Doc
    "@erased"
    -- *** Instances for 'Q1Origin'.

    -- | Right-biased composition, because the left quantity
    --   acts as context, and the right one as occurrence.
    instance Semigroup Q1Origin where
      <> :: Q1Origin -> Q1Origin -> Q1Origin
    (<>) = ((Q1Origin, Q1Origin) -> Q1Origin)
    -> Q1Origin -> Q1Origin -> Q1Origin
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry (((Q1Origin, Q1Origin) -> Q1Origin)
     -> Q1Origin -> Q1Origin -> Q1Origin)
    -> ((Q1Origin, Q1Origin) -> Q1Origin)
    -> Q1Origin
    -> Q1Origin
    -> Q1Origin
    forall a b. (a -> b) -> a -> b
    $ \case
        (Q1Origin
    Q1Inferred, Q1Origin
    o) -> Q1Origin
    o
        (Q1Origin
    o, Q1Origin
    Q1Inferred) -> Q1Origin
    o
        (Q1Origin
    o, Q1       Range
    r) -> Range -> Q1Origin
    Q1 (Range -> Q1Origin) -> Range -> Q1Origin
    forall a b. (a -> b) -> a -> b
    $ Q1Origin -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange Q1Origin
    o Range
    r
        (Q1Origin
    o, Q1Linear Range
    r) -> Range -> Q1Origin
    Q1 (Range -> Q1Origin) -> Range -> Q1Origin
    forall a b. (a -> b) -> a -> b
    $ Q1Origin -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange Q1Origin
    o Range
    r

    instance Monoid Q1Origin where
      mempty :: Q1Origin
    mempty = Q1Origin
    Q1Inferred
      mappend :: Q1Origin -> Q1Origin -> Q1Origin
    mappend = Q1Origin -> Q1Origin -> Q1Origin
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance Null Q1Origin where
      empty :: Q1Origin
    empty = Q1Origin
    forall a. Monoid a => a
    mempty

    instance HasRange Q1Origin where
      getRange :: Q1Origin -> Range
    getRange = \case
        Q1Origin
    Q1Inferred -> Range
    forall a. Range' a
    noRange
        Q1       Range
    r -> Range
    r
        Q1Linear Range
    r -> Range
    r

    instance SetRange Q1Origin where
      setRange :: Range -> Q1Origin -> Q1Origin
    setRange Range
    r = \case
        Q1Origin
    Q1Inferred -> Q1Origin
    Q1Inferred
        Q1       Range
    _ -> Range -> Q1Origin
    Q1       Range
    r
        Q1Linear Range
    _ -> Range -> Q1Origin
    Q1Linear Range
    r

    instance KillRange Q1Origin where
      killRange :: Q1Origin -> Q1Origin
    killRange = \case
        Q1Origin
    Q1Inferred -> Q1Origin
    Q1Inferred
        Q1       Range
    _ -> Range -> Q1Origin
    Q1       Range
    forall a. Range' a
    noRange
        Q1Linear Range
    _ -> Range -> Q1Origin
    Q1Linear Range
    forall a. Range' a
    noRange

    instance NFData Q1Origin where
      rnf :: Q1Origin -> ()
    rnf = \case
        Q1Origin
    Q1Inferred -> ()
        Q1       Range
    _ -> ()
        Q1Linear Range
    _ -> ()

    instance Pretty Q1Origin where
      pretty :: Q1Origin -> Doc
    pretty = \case
        Q1Origin
    Q1Inferred -> Doc
    forall a. Null a => a
    empty
        Q1{}       -> Doc
    "@1"
        Q1Linear{} -> Doc
    "@linear"

    -- *** Instances for 'QωOrigin'.

    -- | Right-biased composition, because the left quantity
    --   acts as context, and the right one as occurrence.
    instance Semigroup QωOrigin where
      <> :: QωOrigin -> QωOrigin -> QωOrigin
    (<>) = ((QωOrigin, QωOrigin) -> QωOrigin)
    -> QωOrigin -> QωOrigin -> QωOrigin
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry (((QωOrigin, QωOrigin) -> QωOrigin)
     -> QωOrigin -> QωOrigin -> QωOrigin)
    -> ((QωOrigin, QωOrigin) -> QωOrigin)
    -> QωOrigin
    -> QωOrigin
    -> QωOrigin
    forall a b. (a -> b) -> a -> b
    $ \case
        (QωOrigin
    QωInferred, QωOrigin
    o) -> QωOrigin
    o
        (QωOrigin
    o, QωOrigin
    QωInferred) -> QωOrigin
    o
        (QωOrigin
    o, Qω       Range
    r) -> Range -> QωOrigin
    Qω (Range -> QωOrigin) -> Range -> QωOrigin
    forall a b. (a -> b) -> a -> b
    $ QωOrigin -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange QωOrigin
    o Range
    r
        (QωOrigin
    o, QωPlenty Range
    r) -> Range -> QωOrigin
    Qω (Range -> QωOrigin) -> Range -> QωOrigin
    forall a b. (a -> b) -> a -> b
    $ QωOrigin -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange QωOrigin
    o Range
    r

    instance Monoid QωOrigin where
      mempty :: QωOrigin
    mempty = QωOrigin
    QωInferred
      mappend :: QωOrigin -> QωOrigin -> QωOrigin
    mappend = QωOrigin -> QωOrigin -> QωOrigin
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance Null QωOrigin where
      empty :: QωOrigin
    empty = QωOrigin
    forall a. Monoid a => a
    mempty

    instance HasRange QωOrigin where
      getRange :: QωOrigin -> Range
    getRange = \case
        QωOrigin
    QωInferred -> Range
    forall a. Range' a
    noRange
        Qω       Range
    r -> Range
    r
        QωPlenty Range
    r -> Range
    r

    instance SetRange QωOrigin where
      setRange :: Range -> QωOrigin -> QωOrigin
    setRange Range
    r = \case
        QωOrigin
    QωInferred -> QωOrigin
    QωInferred
        Qω       Range
    _ -> Range -> QωOrigin
    Qω       Range
    r
        QωPlenty Range
    _ -> Range -> QωOrigin
    QωPlenty Range
    r

    instance KillRange QωOrigin where
      killRange :: QωOrigin -> QωOrigin
    killRange = \case
        QωOrigin
    QωInferred -> QωOrigin
    QωInferred
        Qω       Range
    _ -> Range -> QωOrigin
    Qω       Range
    forall a. Range' a
    noRange
        QωPlenty Range
    _ -> Range -> QωOrigin
    QωPlenty Range
    forall a. Range' a
    noRange

    instance NFData QωOrigin where
      rnf :: QωOrigin -> ()
    rnf = \case
        QωOrigin
    QωInferred -> ()
        Qω       Range
    _ -> ()
        QωPlenty Range
    _ -> ()

    instance Pretty QωOrigin where
      pretty :: QωOrigin -> Doc
    pretty = \case
        QωOrigin
    QωInferred -> Doc
    forall a. Null a => a
    empty
        Qω{}       -> Doc
    "@ω"
        QωPlenty{} -> Doc
    "@plenty"

    -- ** Quantity.

    -- | Quantity for linearity.
    --
    --   A quantity is a set of natural numbers, indicating possible semantic
    --   uses of a variable.  A singleton set @{n}@ requires that the
    --   corresponding variable is used exactly @n@ times.
    --
    data Quantity
      = Quantity0 Q0Origin -- ^ Zero uses @{0}@, erased at runtime.
      | Quantity1 Q1Origin -- ^ Linear use @{1}@ (could be updated destructively).
        -- Mostly TODO (needs postponable constraints between quantities to compute uses).
      | Quantityω QωOrigin -- ^ Unrestricted use @ℕ@.
      deriving (Int -> Quantity -> ShowS
    [Quantity] -> ShowS
    Quantity -> ArgName
    (Int -> Quantity -> ShowS)
    -> (Quantity -> ArgName) -> ([Quantity] -> ShowS) -> Show Quantity
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Quantity -> ShowS
    showsPrec :: Int -> Quantity -> ShowS
    $cshow :: Quantity -> ArgName
    show :: Quantity -> ArgName
    $cshowList :: [Quantity] -> ShowS
    showList :: [Quantity] -> ShowS
    Show, (forall x. Quantity -> Rep Quantity x)
    -> (forall x. Rep Quantity x -> Quantity) -> Generic Quantity
    forall x. Rep Quantity x -> Quantity
    forall x. Quantity -> Rep Quantity x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Quantity -> Rep Quantity x
    from :: forall x. Quantity -> Rep Quantity x
    $cto :: forall x. Rep Quantity x -> Quantity
    to :: forall x. Rep Quantity x -> Quantity
    Generic, Quantity -> Quantity -> Bool
    (Quantity -> Quantity -> Bool)
    -> (Quantity -> Quantity -> Bool) -> Eq Quantity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Quantity -> Quantity -> Bool
    == :: Quantity -> Quantity -> Bool
    $c/= :: Quantity -> Quantity -> Bool
    /= :: Quantity -> Quantity -> Bool
    Eq, Eq Quantity
    Eq Quantity =>
    (Quantity -> Quantity -> Ordering)
    -> (Quantity -> Quantity -> Bool)
    -> (Quantity -> Quantity -> Bool)
    -> (Quantity -> Quantity -> Bool)
    -> (Quantity -> Quantity -> Bool)
    -> (Quantity -> Quantity -> Quantity)
    -> (Quantity -> Quantity -> Quantity)
    -> Ord Quantity
    Quantity -> Quantity -> Bool
    Quantity -> Quantity -> Ordering
    Quantity -> Quantity -> Quantity
    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
    $ccompare :: Quantity -> Quantity -> Ordering
    compare :: Quantity -> Quantity -> Ordering
    $c< :: Quantity -> Quantity -> Bool
    < :: Quantity -> Quantity -> Bool
    $c<= :: Quantity -> Quantity -> Bool
    <= :: Quantity -> Quantity -> Bool
    $c> :: Quantity -> Quantity -> Bool
    > :: Quantity -> Quantity -> Bool
    $c>= :: Quantity -> Quantity -> Bool
    >= :: Quantity -> Quantity -> Bool
    $cmax :: Quantity -> Quantity -> Quantity
    max :: Quantity -> Quantity -> Quantity
    $cmin :: Quantity -> Quantity -> Quantity
    min :: Quantity -> Quantity -> Quantity
    Ord)
        -- @Ord@ instance in case @Quantity@ is used in keys for maps etc.

    -- | Equality ignoring origin.

    sameQuantity :: Quantity -> Quantity -> Bool
    sameQuantity :: Quantity -> Quantity -> Bool
    sameQuantity = ((Quantity, Quantity) -> Bool) -> Quantity -> Quantity -> Bool
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry (((Quantity, Quantity) -> Bool) -> Quantity -> Quantity -> Bool)
    -> ((Quantity, Quantity) -> Bool) -> Quantity -> Quantity -> Bool
    forall a b. (a -> b) -> a -> b
    $ \case
      (Quantity0{}, Quantity0{}) -> Bool
    True
      (Quantity1{}, Quantity1{}) -> Bool
    True
      (Quantityω{}, Quantityω{}) -> Bool
    True
      (Quantity, Quantity)
    _ -> Bool
    False

    -- | Composition of quantities (multiplication).
    --
    -- 'Quantity0' is dominant.
    -- 'Quantity1' is neutral.
    --
    -- Right-biased for origin.
    --
    instance Semigroup (UnderComposition Quantity) where
      <> :: UnderComposition Quantity
    -> UnderComposition Quantity -> UnderComposition Quantity
    (<>) = (Quantity -> Quantity -> Quantity)
    -> UnderComposition Quantity
    -> UnderComposition Quantity
    -> UnderComposition Quantity
    forall a b c.
    (a -> b -> c)
    -> UnderComposition a -> UnderComposition b -> UnderComposition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Quantity -> Quantity -> Quantity
    composeQuantity

    -- | In the absense of finite quantities besides 0, ω is the unit.
    --   Otherwise, 1 is the unit.
    instance Monoid (UnderComposition Quantity) where
      mempty :: UnderComposition Quantity
    mempty  = Quantity -> UnderComposition Quantity
    forall a. a -> UnderComposition a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Quantity
    unitQuantity
      mappend :: UnderComposition Quantity
    -> UnderComposition Quantity -> UnderComposition Quantity
    mappend = UnderComposition Quantity
    -> UnderComposition Quantity -> UnderComposition Quantity
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance POSemigroup (UnderComposition Quantity) where
    instance POMonoid (UnderComposition Quantity) where

    instance LeftClosedPOMonoid (UnderComposition Quantity) where
      inverseCompose :: UnderComposition Quantity
    -> UnderComposition Quantity -> UnderComposition Quantity
    inverseCompose = (Quantity -> Quantity -> Quantity)
    -> UnderComposition Quantity
    -> UnderComposition Quantity
    -> UnderComposition Quantity
    forall a b c.
    (a -> b -> c)
    -> UnderComposition a -> UnderComposition b -> UnderComposition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Quantity -> Quantity -> Quantity
    inverseComposeQuantity

    instance Semigroup (UnderAddition Quantity) where
      <> :: UnderAddition Quantity
    -> UnderAddition Quantity -> UnderAddition Quantity
    (<>) = (Quantity -> Quantity -> Quantity)
    -> UnderAddition Quantity
    -> UnderAddition Quantity
    -> UnderAddition Quantity
    forall a b c.
    (a -> b -> c)
    -> UnderAddition a -> UnderAddition b -> UnderAddition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Quantity -> Quantity -> Quantity
    addQuantity

    instance Monoid (UnderAddition Quantity) where
      mempty :: UnderAddition Quantity
    mempty  = Quantity -> UnderAddition Quantity
    forall a. a -> UnderAddition a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Quantity
    zeroQuantity
      mappend :: UnderAddition Quantity
    -> UnderAddition Quantity -> UnderAddition Quantity
    mappend = UnderAddition Quantity
    -> UnderAddition Quantity -> UnderAddition Quantity
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance POSemigroup (UnderAddition Quantity) where
    instance POMonoid (UnderAddition Quantity) where

    -- | Note that the order is @ω ≤ 0,1@, more options is smaller.
    instance PartialOrd Quantity where
      comparable :: Comparable Quantity
    comparable = ((Quantity, Quantity) -> PartialOrdering) -> Comparable Quantity
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry (((Quantity, Quantity) -> PartialOrdering) -> Comparable Quantity)
    -> ((Quantity, Quantity) -> PartialOrdering) -> Comparable Quantity
    forall a b. (a -> b) -> a -> b
    $ \case
        (Quantity
    q, Quantity
    q') | Quantity -> Quantity -> Bool
    sameQuantity Quantity
    q Quantity
    q' -> PartialOrdering
    POEQ
        -- ω is least
        (Quantityω{}, Quantity
    _)  -> PartialOrdering
    POLT
        (Quantity
    _, Quantityω{})  -> PartialOrdering
    POGT
        -- others are uncomparable
        (Quantity, Quantity)
    _ -> PartialOrdering
    POAny

    instance Pretty Quantity where
      pretty :: Quantity -> Doc
    pretty = \case
        Quantity0 Q0Origin
    o -> Doc -> Doc -> (Doc -> Doc) -> Doc
    forall a b. Null a => a -> b -> (a -> b) -> b
    ifNull (Q0Origin -> Doc
    forall a. Pretty a => a -> Doc
    pretty Q0Origin
    o) Doc
    "@0" Doc -> Doc
    forall a. a -> a
    id
        Quantity1 Q1Origin
    o -> Doc -> Doc -> (Doc -> Doc) -> Doc
    forall a b. Null a => a -> b -> (a -> b) -> b
    ifNull (Q1Origin -> Doc
    forall a. Pretty a => a -> Doc
    pretty Q1Origin
    o) Doc
    "@1" Doc -> Doc
    forall a. a -> a
    id
        Quantityω QωOrigin
    o -> QωOrigin -> Doc
    forall a. Pretty a => a -> Doc
    pretty QωOrigin
    o

    -- | 'Quantity' forms an additive monoid with zero Quantity0.
    addQuantity :: Quantity -> Quantity -> Quantity
    addQuantity :: Quantity -> Quantity -> Quantity
    addQuantity = ((Quantity, Quantity) -> Quantity)
    -> Quantity -> Quantity -> Quantity
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry (((Quantity, Quantity) -> Quantity)
     -> Quantity -> Quantity -> Quantity)
    -> ((Quantity, Quantity) -> Quantity)
    -> Quantity
    -> Quantity
    -> Quantity
    forall a b. (a -> b) -> a -> b
    $ \case
      -- ω is absorptive
      (q :: Quantity
    q@Quantityω{}, Quantity
    _) -> Quantity
    q
      (Quantity
    _, q :: Quantity
    q@Quantityω{}) -> Quantity
    q
      -- 0 is neutral
      (Quantity0{}, Quantity
    q) -> Quantity
    q
      (Quantity
    q, Quantity0{}) -> Quantity
    q
      -- 1 + 1 = ω
      (Quantity1 Q1Origin
    _, Quantity1 Q1Origin
    _) -> Quantity
    topQuantity

    -- | Identity element under addition
    zeroQuantity :: Quantity
    zeroQuantity :: Quantity
    zeroQuantity = Q0Origin -> Quantity
    Quantity0 Q0Origin
    forall a. Monoid a => a
    mempty

    -- | Absorptive element!
    --   This differs from Relevance and Cohesion whose default
    --   is the multiplicative unit.
    defaultQuantity :: Quantity
    defaultQuantity :: Quantity
    defaultQuantity = Quantity
    topQuantity

    -- | Identity element under composition
    unitQuantity :: Quantity
    unitQuantity :: Quantity
    unitQuantity = QωOrigin -> Quantity
    Quantityω QωOrigin
    forall a. Monoid a => a
    mempty

    -- | Absorptive element is ω.
    topQuantity :: Quantity
    topQuantity :: Quantity
    topQuantity = QωOrigin -> Quantity
    Quantityω QωOrigin
    forall a. Monoid a => a
    mempty

    -- | 'null' means no information, not even origin or range.
    instance Null Quantity where
      empty :: Quantity
    empty = Quantity
    defaultQuantity
      null :: Quantity -> Bool
    null = \case
        Quantityω QωOrigin
    o -> QωOrigin -> Bool
    forall a. Null a => a -> Bool
    null QωOrigin
    o
        Quantity
    _ -> Bool
    False

    -- | @m `moreUsableQuantity` m'@ means that an @m@ can be used
    --   where ever an @m'@ is required.

    moreQuantity :: Quantity -> Quantity -> Bool
    moreQuantity :: Quantity -> Quantity -> Bool
    moreQuantity Quantity
    m Quantity
    m' = Quantity -> PartialOrdering -> Quantity -> Bool
    forall a. PartialOrd a => a -> PartialOrdering -> a -> Bool
    related Quantity
    m PartialOrdering
    POLE Quantity
    m'

    -- | Composition of quantities (multiplication).
    --
    -- 'Quantity0' is dominant.
    -- 'Quantity1' is neutral.
    --
    -- Right-biased for origin.
    --
    composeQuantity :: Quantity -> Quantity -> Quantity
    composeQuantity :: Quantity -> Quantity -> Quantity
    composeQuantity = ((Quantity, Quantity) -> Quantity)
    -> Quantity -> Quantity -> Quantity
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry (((Quantity, Quantity) -> Quantity)
     -> Quantity -> Quantity -> Quantity)
    -> ((Quantity, Quantity) -> Quantity)
    -> Quantity
    -> Quantity
    -> Quantity
    forall a b. (a -> b) -> a -> b
    $ \case
      (Quantity1 Q1Origin
    o, Quantity1 Q1Origin
    o') -> Q1Origin -> Quantity
    Quantity1 (Q1Origin
    o Q1Origin -> Q1Origin -> Q1Origin
    forall a. Semigroup a => a -> a -> a
    <> Q1Origin
    o')
      (Quantity1{}, Quantity
    q           ) -> Quantity
    q
      (Quantity
    q          , Quantity1{} ) -> Quantity
    q
      (Quantity0 Q0Origin
    o, Quantity0 Q0Origin
    o') -> Q0Origin -> Quantity
    Quantity0 (Q0Origin
    o Q0Origin -> Q0Origin -> Q0Origin
    forall a. Semigroup a => a -> a -> a
    <> Q0Origin
    o')
      (Quantity
    _          , Quantity0 Q0Origin
    o ) -> Q0Origin -> Quantity
    Quantity0 Q0Origin
    o
      (Quantity0 Q0Origin
    o, Quantity
    _           ) -> Q0Origin -> Quantity
    Quantity0 Q0Origin
    o
      (Quantityω QωOrigin
    o, Quantityω QωOrigin
    o') -> QωOrigin -> Quantity
    Quantityω (QωOrigin
    o QωOrigin -> QωOrigin -> QωOrigin
    forall a. Semigroup a => a -> a -> a
    <> QωOrigin
    o')

    -- | Compose with quantity flag from the left.
    --   This function is e.g. used to update the quantity information
    --   on pattern variables @a@ after a match against something of quantity @q@.

    applyQuantity :: LensQuantity a => Quantity -> a -> a
    applyQuantity :: forall a. LensQuantity a => Quantity -> a -> a
    applyQuantity Quantity
    q = (Quantity -> Quantity) -> a -> a
    forall a. LensQuantity a => (Quantity -> Quantity) -> a -> a
    mapQuantity (Quantity
    q Quantity -> Quantity -> Quantity
    `composeQuantity`)

    -- | @inverseComposeQuantity r x@ returns the least quantity @y@
    --   such that forall @x@, @y@ we have
    --   @x \`moreQuantity\` (r \`composeQuantity\` y)@
    --   iff
    --   @(r \`inverseComposeQuantity\` x) \`moreQuantity\` y@ (Galois connection).

    inverseComposeQuantity :: Quantity -> Quantity -> Quantity
    inverseComposeQuantity :: Quantity -> Quantity -> Quantity
    inverseComposeQuantity = ((Quantity, Quantity) -> Quantity)
    -> Quantity -> Quantity -> Quantity
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry (((Quantity, Quantity) -> Quantity)
     -> Quantity -> Quantity -> Quantity)
    -> ((Quantity, Quantity) -> Quantity)
    -> Quantity
    -> Quantity
    -> Quantity
    forall a b. (a -> b) -> a -> b
    $ \case
        (Quantity1{} , Quantity
    x)              -> Quantity
    x             -- going to linear arg: nothing changes
        (Quantity0{} , Quantity
    x)              -> Quantity
    topQuantity   -- going to erased arg: every thing usable
        (Quantityω{} , x :: Quantity
    x@Quantityω{})  -> Quantity
    x
        (Quantityω{} , Quantity
    _)              -> Quantity
    zeroQuantity  -- linear resources are unusable as arguments to unrestricted functions

    -- | Left division by a 'Quantity'.
    --   Used e.g. to modify context when going into a @q@ argument.

    inverseApplyQuantity :: LensQuantity a => Quantity -> a -> a
    inverseApplyQuantity :: forall a. LensQuantity a => Quantity -> a -> a
    inverseApplyQuantity Quantity
    q = (Quantity -> Quantity) -> a -> a
    forall a. LensQuantity a => (Quantity -> Quantity) -> a -> a
    mapQuantity (Quantity
    q Quantity -> Quantity -> Quantity
    `inverseComposeQuantity`)

    -- | Check for 'Quantity0'.

    hasQuantity0 :: LensQuantity a => a -> Bool
    hasQuantity0 :: forall a. LensQuantity a => a -> Bool
    hasQuantity0 a
    a
      | Quantity0{} <- a -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity a
    a = Bool
    True
      | Bool
    otherwise = Bool
    False

    -- | Check for 'Quantity1'.

    hasQuantity1 :: LensQuantity a => a -> Bool
    hasQuantity1 :: forall a. LensQuantity a => a -> Bool
    hasQuantity1 a
    a
      | Quantity1{} <- a -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity a
    a = Bool
    True
      | Bool
    otherwise = Bool
    False

    -- | Check for 'Quantityω'.

    hasQuantityω :: LensQuantity a => a -> Bool
    hasQuantityω :: forall a. LensQuantity a => a -> Bool
    hasQuantityω a
    a
      | Quantityω{} <- a -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity a
    a = Bool
    True
      | Bool
    otherwise = Bool
    False

    -- | Did the user supply a quantity annotation?

    noUserQuantity :: LensQuantity a => a -> Bool
    noUserQuantity :: forall a. LensQuantity a => a -> Bool
    noUserQuantity a
    a = case a -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity a
    a of
      Quantity0 Q0Origin
    o -> Q0Origin -> Bool
    forall a. Null a => a -> Bool
    null Q0Origin
    o
      Quantity1 Q1Origin
    o -> Q1Origin -> Bool
    forall a. Null a => a -> Bool
    null Q1Origin
    o
      Quantityω QωOrigin
    o -> QωOrigin -> Bool
    forall a. Null a => a -> Bool
    null QωOrigin
    o

    -- | A thing of quantity 0 is unusable, all others are usable.

    usableQuantity :: LensQuantity a => a -> Bool
    usableQuantity :: forall a. LensQuantity a => a -> Bool
    usableQuantity = Bool -> Bool
    not (Bool -> Bool) -> (a -> Bool) -> a -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Bool
    forall a. LensQuantity a => a -> Bool
    hasQuantity0

    -- boilerplate instances

    class LensQuantity a where

      getQuantity :: a -> Quantity

      setQuantity :: Quantity -> a -> a
      setQuantity = (Quantity -> Quantity) -> a -> a
    forall a. LensQuantity a => (Quantity -> Quantity) -> a -> a
    mapQuantity ((Quantity -> Quantity) -> a -> a)
    -> (Quantity -> Quantity -> Quantity) -> Quantity -> a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Quantity -> Quantity -> Quantity
    forall a b. a -> b -> a
    const

      mapQuantity :: (Quantity -> Quantity) -> a -> a

      default getQuantity :: LensModality a => a -> Quantity
      getQuantity = Modality -> Quantity
    modQuantity (Modality -> Quantity) -> (a -> Modality) -> a -> Quantity
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Modality
    forall a. LensModality a => a -> Modality
    getModality

      default mapQuantity :: LensModality a => (Quantity -> Quantity) -> a -> a
      mapQuantity Quantity -> Quantity
    f = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> (Modality -> Modality) -> a -> a
    forall a b. (a -> b) -> a -> b
    $ \ Modality
    ai -> Modality
    ai { modQuantity = f $ modQuantity ai }

    instance LensQuantity Quantity where
      getQuantity :: Quantity -> Quantity
    getQuantity = Quantity -> Quantity
    forall a. a -> a
    id
      setQuantity :: Quantity -> Quantity -> Quantity
    setQuantity = Quantity -> Quantity -> Quantity
    forall a b. a -> b -> a
    const
      mapQuantity :: (Quantity -> Quantity) -> Quantity -> Quantity
    mapQuantity = (Quantity -> Quantity) -> Quantity -> Quantity
    forall a. a -> a
    id

    instance HasRange Quantity where
      getRange :: Quantity -> Range
    getRange = \case
        Quantity0 Q0Origin
    o -> Q0Origin -> Range
    forall a. HasRange a => a -> Range
    getRange Q0Origin
    o
        Quantity1 Q1Origin
    o -> Q1Origin -> Range
    forall a. HasRange a => a -> Range
    getRange Q1Origin
    o
        Quantityω QωOrigin
    o -> QωOrigin -> Range
    forall a. HasRange a => a -> Range
    getRange QωOrigin
    o

    instance SetRange Quantity where
      setRange :: Range -> Quantity -> Quantity
    setRange Range
    r = \case
        Quantity0 Q0Origin
    o -> Q0Origin -> Quantity
    Quantity0 (Q0Origin -> Quantity) -> Q0Origin -> Quantity
    forall a b. (a -> b) -> a -> b
    $ Range -> Q0Origin -> Q0Origin
    forall a. SetRange a => Range -> a -> a
    setRange Range
    r Q0Origin
    o
        Quantity1 Q1Origin
    o -> Q1Origin -> Quantity
    Quantity1 (Q1Origin -> Quantity) -> Q1Origin -> Quantity
    forall a b. (a -> b) -> a -> b
    $ Range -> Q1Origin -> Q1Origin
    forall a. SetRange a => Range -> a -> a
    setRange Range
    r Q1Origin
    o
        Quantityω QωOrigin
    o -> QωOrigin -> Quantity
    Quantityω (QωOrigin -> Quantity) -> QωOrigin -> Quantity
    forall a b. (a -> b) -> a -> b
    $ Range -> QωOrigin -> QωOrigin
    forall a. SetRange a => Range -> a -> a
    setRange Range
    r QωOrigin
    o

    instance KillRange Quantity where
      killRange :: Quantity -> Quantity
    killRange = \case
        Quantity0 Q0Origin
    o -> Q0Origin -> Quantity
    Quantity0 (Q0Origin -> Quantity) -> Q0Origin -> Quantity
    forall a b. (a -> b) -> a -> b
    $ Q0Origin -> Q0Origin
    forall a. KillRange a => KillRangeT a
    killRange Q0Origin
    o
        Quantity1 Q1Origin
    o -> Q1Origin -> Quantity
    Quantity1 (Q1Origin -> Quantity) -> Q1Origin -> Quantity
    forall a b. (a -> b) -> a -> b
    $ Q1Origin -> Q1Origin
    forall a. KillRange a => KillRangeT a
    killRange Q1Origin
    o
        Quantityω QωOrigin
    o -> QωOrigin -> Quantity
    Quantityω (QωOrigin -> Quantity) -> QωOrigin -> Quantity
    forall a b. (a -> b) -> a -> b
    $ QωOrigin -> QωOrigin
    forall a. KillRange a => KillRangeT a
    killRange QωOrigin
    o

    instance NFData Quantity where
      rnf :: Quantity -> ()
    rnf (Quantity0 Q0Origin
    o) = Q0Origin -> ()
    forall a. NFData a => a -> ()
    rnf Q0Origin
    o
      rnf (Quantity1 Q1Origin
    o) = Q1Origin -> ()
    forall a. NFData a => a -> ()
    rnf Q1Origin
    o
      rnf (Quantityω QωOrigin
    o) = QωOrigin -> ()
    forall a. NFData a => a -> ()
    rnf QωOrigin
    o

    isQuantity0 :: LensQuantity a => a -> Bool
    isQuantity0 :: forall a. LensQuantity a => a -> Bool
    isQuantity0 a
    a = case a -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity a
    a of
      Quantity0{} -> Bool
    True
      Quantity
    _ -> Bool
    False

    isQuantityω :: LensQuantity a => a -> Bool
    isQuantityω :: forall a. LensQuantity a => a -> Bool
    isQuantityω a
    a = case a -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity a
    a of
      Quantityω{} -> Bool
    True
      Quantity
    _ -> Bool
    False

    prettyQuantity :: LensQuantity a => a -> Doc -> Doc
    prettyQuantity :: forall a. LensQuantity a => a -> Doc -> Doc
    prettyQuantity a
    a = (Quantity -> Doc
    forall a. Pretty a => a -> Doc
    pretty (a -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity a
    a) Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+>)

    -- ** Erased.

    -- | A special case of 'Quantity': erased or not.
    --
    -- Note that the 'Ord' instance does *not* ignore the origin
    -- arguments.

    data Erased
      = Erased Q0Origin
      | NotErased QωOrigin
      deriving (Int -> Erased -> ShowS
    [Erased] -> ShowS
    Erased -> ArgName
    (Int -> Erased -> ShowS)
    -> (Erased -> ArgName) -> ([Erased] -> ShowS) -> Show Erased
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Erased -> ShowS
    showsPrec :: Int -> Erased -> ShowS
    $cshow :: Erased -> ArgName
    show :: Erased -> ArgName
    $cshowList :: [Erased] -> ShowS
    showList :: [Erased] -> ShowS
    Show, Erased -> Erased -> Bool
    (Erased -> Erased -> Bool)
    -> (Erased -> Erased -> Bool) -> Eq Erased
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Erased -> Erased -> Bool
    == :: Erased -> Erased -> Bool
    $c/= :: Erased -> Erased -> Bool
    /= :: Erased -> Erased -> Bool
    Eq, Eq Erased
    Eq Erased =>
    (Erased -> Erased -> Ordering)
    -> (Erased -> Erased -> Bool)
    -> (Erased -> Erased -> Bool)
    -> (Erased -> Erased -> Bool)
    -> (Erased -> Erased -> Bool)
    -> (Erased -> Erased -> Erased)
    -> (Erased -> Erased -> Erased)
    -> Ord Erased
    Erased -> Erased -> Bool
    Erased -> Erased -> Ordering
    Erased -> Erased -> Erased
    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
    $ccompare :: Erased -> Erased -> Ordering
    compare :: Erased -> Erased -> Ordering
    $c< :: Erased -> Erased -> Bool
    < :: Erased -> Erased -> Bool
    $c<= :: Erased -> Erased -> Bool
    <= :: Erased -> Erased -> Bool
    $c> :: Erased -> Erased -> Bool
    > :: Erased -> Erased -> Bool
    $c>= :: Erased -> Erased -> Bool
    >= :: Erased -> Erased -> Bool
    $cmax :: Erased -> Erased -> Erased
    max :: Erased -> Erased -> Erased
    $cmin :: Erased -> Erased -> Erased
    min :: Erased -> Erased -> Erased
    Ord, (forall x. Erased -> Rep Erased x)
    -> (forall x. Rep Erased x -> Erased) -> Generic Erased
    forall x. Rep Erased x -> Erased
    forall x. Erased -> Rep Erased x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Erased -> Rep Erased x
    from :: forall x. Erased -> Rep Erased x
    $cto :: forall x. Rep Erased x -> Erased
    to :: forall x. Rep Erased x -> Erased
    Generic)

    -- | The default value of type 'Erased': not erased.

    defaultErased :: Erased
    defaultErased :: Erased
    defaultErased = QωOrigin -> Erased
    NotErased QωOrigin
    QωInferred

    -- | 'Erased' can be embedded into 'Quantity'.

    asQuantity :: Erased -> Quantity
    asQuantity :: Erased -> Quantity
    asQuantity (Erased    Q0Origin
    o) = Q0Origin -> Quantity
    Quantity0 Q0Origin
    o
    asQuantity (NotErased QωOrigin
    o) = QωOrigin -> Quantity
    Quantityω QωOrigin
    o

    -- | 'Quantity' can be projected onto 'Erased'.

    erasedFromQuantity :: Quantity -> Maybe Erased
    erasedFromQuantity :: Quantity -> Maybe Erased
    erasedFromQuantity = \case
      Quantity1{} -> Maybe Erased
    forall a. Maybe a
    Nothing
      Quantity0 Q0Origin
    o -> Erased -> Maybe Erased
    forall a. a -> Maybe a
    Just (Erased -> Maybe Erased) -> Erased -> Maybe Erased
    forall a b. (a -> b) -> a -> b
    $ Q0Origin -> Erased
    Erased    Q0Origin
    o
      Quantityω QωOrigin
    o -> Erased -> Maybe Erased
    forall a. a -> Maybe a
    Just (Erased -> Maybe Erased) -> Erased -> Maybe Erased
    forall a b. (a -> b) -> a -> b
    $ QωOrigin -> Erased
    NotErased QωOrigin
    o

    -- | Equality ignoring origin.

    sameErased :: Erased -> Erased -> Bool
    sameErased :: Erased -> Erased -> Bool
    sameErased = Quantity -> Quantity -> Bool
    sameQuantity (Quantity -> Quantity -> Bool)
    -> (Erased -> Quantity) -> Erased -> Erased -> Bool
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` Erased -> Quantity
    asQuantity

    -- | Is the value \"erased\"?

    isErased :: Erased -> Bool
    isErased :: Erased -> Bool
    isErased = Quantity -> Bool
    forall a. LensQuantity a => a -> Bool
    hasQuantity0 (Quantity -> Bool) -> (Erased -> Quantity) -> Erased -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Erased -> Quantity
    asQuantity

    instance NFData Erased

    instance HasRange Erased where
      getRange :: Erased -> Range
    getRange = Quantity -> Range
    forall a. HasRange a => a -> Range
    getRange (Quantity -> Range) -> (Erased -> Quantity) -> Erased -> Range
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Erased -> Quantity
    asQuantity

    instance KillRange Erased where
      killRange :: Erased -> Erased
    killRange = \case
        Erased Q0Origin
    o    -> Q0Origin -> Erased
    Erased (Q0Origin -> Erased) -> Q0Origin -> Erased
    forall a b. (a -> b) -> a -> b
    $ Q0Origin -> Q0Origin
    forall a. KillRange a => KillRangeT a
    killRange Q0Origin
    o
        NotErased QωOrigin
    o -> QωOrigin -> Erased
    NotErased (QωOrigin -> Erased) -> QωOrigin -> Erased
    forall a b. (a -> b) -> a -> b
    $ QωOrigin -> QωOrigin
    forall a. KillRange a => KillRangeT a
    killRange QωOrigin
    o

    instance Pretty Erased where
      pretty :: Erased -> Doc
    pretty = Quantity -> Doc
    forall a. Pretty a => a -> Doc
    pretty (Quantity -> Doc) -> (Erased -> Quantity) -> Erased -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Erased -> Quantity
    asQuantity

    -- | Composition of values of type 'Erased'.
    --
    -- 'Erased' is dominant.
    -- 'NotErased' is neutral.
    --
    -- Right-biased for the origin.

    composeErased :: Erased -> Erased -> Erased
    composeErased :: Erased -> Erased -> Erased
    composeErased = ((Erased, Erased) -> Erased) -> Erased -> Erased -> Erased
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry (((Erased, Erased) -> Erased) -> Erased -> Erased -> Erased)
    -> ((Erased, Erased) -> Erased) -> Erased -> Erased -> Erased
    forall a b. (a -> b) -> a -> b
    $ \case
      (Erased Q0Origin
    o,    Erased Q0Origin
    o')    -> Q0Origin -> Erased
    Erased (Q0Origin
    o Q0Origin -> Q0Origin -> Q0Origin
    forall a. Semigroup a => a -> a -> a
    <> Q0Origin
    o')
      (NotErased QωOrigin
    _, Erased Q0Origin
    o)     -> Q0Origin -> Erased
    Erased Q0Origin
    o
      (Erased Q0Origin
    o,    NotErased QωOrigin
    _)  -> Q0Origin -> Erased
    Erased Q0Origin
    o
      (NotErased QωOrigin
    o, NotErased QωOrigin
    o') -> QωOrigin -> Erased
    NotErased (QωOrigin
    o QωOrigin -> QωOrigin -> QωOrigin
    forall a. Semigroup a => a -> a -> a
    <> QωOrigin
    o')

    instance Semigroup (UnderComposition Erased) where
      <> :: UnderComposition Erased
    -> UnderComposition Erased -> UnderComposition Erased
    (<>) = (Erased -> Erased -> Erased)
    -> UnderComposition Erased
    -> UnderComposition Erased
    -> UnderComposition Erased
    forall a b c.
    (a -> b -> c)
    -> UnderComposition a -> UnderComposition b -> UnderComposition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Erased -> Erased -> Erased
    composeErased

    prettyErased :: Erased -> Doc -> Doc
    prettyErased :: Erased -> Doc -> Doc
    prettyErased = Quantity -> Doc -> Doc
    forall a. LensQuantity a => a -> Doc -> Doc
    prettyQuantity (Quantity -> Doc -> Doc)
    -> (Erased -> Quantity) -> Erased -> Doc -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Erased -> Quantity
    asQuantity

    ---------------------------------------------------------------------------
    -- * Relevance
    ---------------------------------------------------------------------------

    -- ** Relevance origin

    -- | Origin of 'Relevant'.

    data OriginRelevant
      = ORelInferred        -- ^ User wrote nothing.
      | ORelRelevant Range  -- ^ User wrote "@relevant".
      deriving (Int -> OriginRelevant -> ShowS
    [OriginRelevant] -> ShowS
    OriginRelevant -> ArgName
    (Int -> OriginRelevant -> ShowS)
    -> (OriginRelevant -> ArgName)
    -> ([OriginRelevant] -> ShowS)
    -> Show OriginRelevant
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OriginRelevant -> ShowS
    showsPrec :: Int -> OriginRelevant -> ShowS
    $cshow :: OriginRelevant -> ArgName
    show :: OriginRelevant -> ArgName
    $cshowList :: [OriginRelevant] -> ShowS
    showList :: [OriginRelevant] -> ShowS
    Show, (forall x. OriginRelevant -> Rep OriginRelevant x)
    -> (forall x. Rep OriginRelevant x -> OriginRelevant)
    -> Generic OriginRelevant
    forall x. Rep OriginRelevant x -> OriginRelevant
    forall x. OriginRelevant -> Rep OriginRelevant x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. OriginRelevant -> Rep OriginRelevant x
    from :: forall x. OriginRelevant -> Rep OriginRelevant x
    $cto :: forall x. Rep OriginRelevant x -> OriginRelevant
    to :: forall x. Rep OriginRelevant x -> OriginRelevant
    Generic)

    -- | Origin of 'Irrelevant'.

    data OriginIrrelevant
      = OIrrInferred          -- ^ User wrote nothing.
      | OIrrDot        Range  -- ^ User wrote ".".
      | OIrrIrr        Range  -- ^ User wrote "@irr".
      | OIrrIrrelevant Range  -- ^ User wrote "@irrelevant".
      deriving (Int -> OriginIrrelevant -> ShowS
    [OriginIrrelevant] -> ShowS
    OriginIrrelevant -> ArgName
    (Int -> OriginIrrelevant -> ShowS)
    -> (OriginIrrelevant -> ArgName)
    -> ([OriginIrrelevant] -> ShowS)
    -> Show OriginIrrelevant
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OriginIrrelevant -> ShowS
    showsPrec :: Int -> OriginIrrelevant -> ShowS
    $cshow :: OriginIrrelevant -> ArgName
    show :: OriginIrrelevant -> ArgName
    $cshowList :: [OriginIrrelevant] -> ShowS
    showList :: [OriginIrrelevant] -> ShowS
    Show, (forall x. OriginIrrelevant -> Rep OriginIrrelevant x)
    -> (forall x. Rep OriginIrrelevant x -> OriginIrrelevant)
    -> Generic OriginIrrelevant
    forall x. Rep OriginIrrelevant x -> OriginIrrelevant
    forall x. OriginIrrelevant -> Rep OriginIrrelevant x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. OriginIrrelevant -> Rep OriginIrrelevant x
    from :: forall x. OriginIrrelevant -> Rep OriginIrrelevant x
    $cto :: forall x. Rep OriginIrrelevant x -> OriginIrrelevant
    to :: forall x. Rep OriginIrrelevant x -> OriginIrrelevant
    Generic)

    -- | Origin of 'ShapeIrrelevant'.

    data OriginShapeIrrelevant
      = OShIrrInferred               -- ^ User wrote nothing.
      | OShIrrDotDot          Range  -- ^ User wrote "..".
      | OShIrrShIrr           Range  -- ^ User wrote "@shirr".
      | OShIrrShapeIrrelevant Range  -- ^ User wrote "@shape-irrelevant".
      deriving (Int -> OriginShapeIrrelevant -> ShowS
    [OriginShapeIrrelevant] -> ShowS
    OriginShapeIrrelevant -> ArgName
    (Int -> OriginShapeIrrelevant -> ShowS)
    -> (OriginShapeIrrelevant -> ArgName)
    -> ([OriginShapeIrrelevant] -> ShowS)
    -> Show OriginShapeIrrelevant
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OriginShapeIrrelevant -> ShowS
    showsPrec :: Int -> OriginShapeIrrelevant -> ShowS
    $cshow :: OriginShapeIrrelevant -> ArgName
    show :: OriginShapeIrrelevant -> ArgName
    $cshowList :: [OriginShapeIrrelevant] -> ShowS
    showList :: [OriginShapeIrrelevant] -> ShowS
    Show, (forall x. OriginShapeIrrelevant -> Rep OriginShapeIrrelevant x)
    -> (forall x. Rep OriginShapeIrrelevant x -> OriginShapeIrrelevant)
    -> Generic OriginShapeIrrelevant
    forall x. Rep OriginShapeIrrelevant x -> OriginShapeIrrelevant
    forall x. OriginShapeIrrelevant -> Rep OriginShapeIrrelevant x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. OriginShapeIrrelevant -> Rep OriginShapeIrrelevant x
    from :: forall x. OriginShapeIrrelevant -> Rep OriginShapeIrrelevant x
    $cto :: forall x. Rep OriginShapeIrrelevant x -> OriginShapeIrrelevant
    to :: forall x. Rep OriginShapeIrrelevant x -> OriginShapeIrrelevant
    Generic)

    -- *** Instances for 'OriginRelevant'

    instance Null OriginRelevant where
      empty :: OriginRelevant
    empty = OriginRelevant
    ORelInferred
      null :: OriginRelevant -> Bool
    null = \case
        OriginRelevant
    ORelInferred -> Bool
    True
        OriginRelevant
    _ -> Bool
    False

    instance Semigroup OriginRelevant where
      <> :: OriginRelevant -> OriginRelevant -> OriginRelevant
    (<>) = ((OriginRelevant, OriginRelevant) -> OriginRelevant)
    -> OriginRelevant -> OriginRelevant -> OriginRelevant
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry \case
        (OriginRelevant
    ORelInferred, OriginRelevant
    o  ) -> OriginRelevant
    o
        (OriginRelevant
    o, OriginRelevant
    ORelInferred  ) -> OriginRelevant
    o
        (OriginRelevant
    o, ORelRelevant Range
    r) -> Range -> OriginRelevant
    ORelRelevant (Range -> OriginRelevant) -> Range -> OriginRelevant
    forall a b. (a -> b) -> a -> b
    $ OriginRelevant -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange OriginRelevant
    o Range
    r

    instance Monoid OriginRelevant where
      mempty :: OriginRelevant
    mempty = OriginRelevant
    forall a. Null a => a
    empty

    instance HasRange OriginRelevant where
      getRange :: OriginRelevant -> Range
    getRange = \case
        OriginRelevant
    ORelInferred   -> Range
    forall a. Range' a
    noRange
        ORelRelevant Range
    r -> Range
    r

    instance SetRange OriginRelevant where
      setRange :: Range -> OriginRelevant -> OriginRelevant
    setRange Range
    r = \case
        OriginRelevant
    ORelInferred   -> OriginRelevant
    ORelInferred
        ORelRelevant Range
    _ -> Range -> OriginRelevant
    ORelRelevant Range
    r

    instance KillRange OriginRelevant where
      killRange :: OriginRelevant -> OriginRelevant
    killRange = Range -> OriginRelevant -> OriginRelevant
    forall a. SetRange a => Range -> a -> a
    setRange Range
    forall a. Range' a
    noRange

    instance NFData OriginRelevant where
      rnf :: OriginRelevant -> ()
    rnf = \case
        OriginRelevant
    ORelInferred   -> ()
        ORelRelevant Range
    _ -> ()

    -- *** Instances for 'OriginIrrelevant'

    instance Null OriginIrrelevant where
      empty :: OriginIrrelevant
    empty = OriginIrrelevant
    OIrrInferred
      null :: OriginIrrelevant -> Bool
    null = \case
        OriginIrrelevant
    OIrrInferred -> Bool
    True
        OriginIrrelevant
    _ -> Bool
    False

    -- | Right-biased composition, because the left relevance
    --   acts as context, and the right one as occurrence.

    instance Semigroup OriginIrrelevant where
      <> :: OriginIrrelevant -> OriginIrrelevant -> OriginIrrelevant
    (<>) = ((OriginIrrelevant, OriginIrrelevant) -> OriginIrrelevant)
    -> OriginIrrelevant -> OriginIrrelevant -> OriginIrrelevant
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry \case
        (OriginIrrelevant
    OIrrInferred, OriginIrrelevant
    o    ) -> OriginIrrelevant
    o
        (OriginIrrelevant
    o, OriginIrrelevant
    OIrrInferred    ) -> OriginIrrelevant
    o
        (OriginIrrelevant
    o, OIrrDot        Range
    r) -> Range -> OriginIrrelevant
    OIrrDot        (Range -> OriginIrrelevant) -> Range -> OriginIrrelevant
    forall a b. (a -> b) -> a -> b
    $ OriginIrrelevant -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange OriginIrrelevant
    o Range
    r
        (OriginIrrelevant
    o, OIrrIrr        Range
    r) -> Range -> OriginIrrelevant
    OIrrIrr        (Range -> OriginIrrelevant) -> Range -> OriginIrrelevant
    forall a b. (a -> b) -> a -> b
    $ OriginIrrelevant -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange OriginIrrelevant
    o Range
    r
        (OriginIrrelevant
    o, OIrrIrrelevant Range
    r) -> Range -> OriginIrrelevant
    OIrrIrrelevant (Range -> OriginIrrelevant) -> Range -> OriginIrrelevant
    forall a b. (a -> b) -> a -> b
    $ OriginIrrelevant -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange OriginIrrelevant
    o Range
    r

    instance Monoid OriginIrrelevant where
      mempty :: OriginIrrelevant
    mempty = OriginIrrelevant
    forall a. Null a => a
    empty

    instance HasRange OriginIrrelevant where
      getRange :: OriginIrrelevant -> Range
    getRange = \case
        OriginIrrelevant
    OIrrInferred     -> Range
    forall a. Range' a
    noRange
        OIrrDot        Range
    r -> Range
    r
        OIrrIrr        Range
    r -> Range
    r
        OIrrIrrelevant Range
    r -> Range
    r

    instance SetRange OriginIrrelevant where
      setRange :: Range -> OriginIrrelevant -> OriginIrrelevant
    setRange Range
    r = \case
        OriginIrrelevant
    OIrrInferred     -> OriginIrrelevant
    OIrrInferred
        OIrrDot Range
    _        -> Range -> OriginIrrelevant
    OIrrDot Range
    r
        OIrrIrr Range
    _        -> Range -> OriginIrrelevant
    OIrrIrr Range
    r
        OIrrIrrelevant Range
    _ -> Range -> OriginIrrelevant
    OIrrIrrelevant Range
    r

    instance KillRange OriginIrrelevant where
      killRange :: OriginIrrelevant -> OriginIrrelevant
    killRange = Range -> OriginIrrelevant -> OriginIrrelevant
    forall a. SetRange a => Range -> a -> a
    setRange Range
    forall a. Range' a
    noRange

    instance NFData OriginIrrelevant where
      rnf :: OriginIrrelevant -> ()
    rnf = \case
        OriginIrrelevant
    OIrrInferred     -> ()
        OIrrDot Range
    _        -> ()
        OIrrIrr Range
    _        -> ()
        OIrrIrrelevant Range
    _ -> ()

    -- *** Instances for 'OriginShapeIrrelevant'

    instance Null OriginShapeIrrelevant where
      empty :: OriginShapeIrrelevant
    empty = OriginShapeIrrelevant
    OShIrrInferred
      null :: OriginShapeIrrelevant -> Bool
    null = \case
        OriginShapeIrrelevant
    OShIrrInferred -> Bool
    True
        OriginShapeIrrelevant
    _ -> Bool
    False

    -- | Right-biased composition, because the left relevance
    --   acts as context, and the right one as occurrence.

    instance Semigroup OriginShapeIrrelevant where
      <> :: OriginShapeIrrelevant
    -> OriginShapeIrrelevant -> OriginShapeIrrelevant
    (<>) = ((OriginShapeIrrelevant, OriginShapeIrrelevant)
     -> OriginShapeIrrelevant)
    -> OriginShapeIrrelevant
    -> OriginShapeIrrelevant
    -> OriginShapeIrrelevant
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry \case
        (OriginShapeIrrelevant
    OShIrrInferred, OriginShapeIrrelevant
    o         ) -> OriginShapeIrrelevant
    o
        (OriginShapeIrrelevant
    o, OriginShapeIrrelevant
    OShIrrInferred         ) -> OriginShapeIrrelevant
    o
        (OriginShapeIrrelevant
    o, OShIrrDotDot          Range
    r) -> Range -> OriginShapeIrrelevant
    OShIrrDotDot          (Range -> OriginShapeIrrelevant) -> Range -> OriginShapeIrrelevant
    forall a b. (a -> b) -> a -> b
    $ OriginShapeIrrelevant -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange OriginShapeIrrelevant
    o Range
    r
        (OriginShapeIrrelevant
    o, OShIrrShIrr           Range
    r) -> Range -> OriginShapeIrrelevant
    OShIrrShIrr           (Range -> OriginShapeIrrelevant) -> Range -> OriginShapeIrrelevant
    forall a b. (a -> b) -> a -> b
    $ OriginShapeIrrelevant -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange OriginShapeIrrelevant
    o Range
    r
        (OriginShapeIrrelevant
    o, OShIrrShapeIrrelevant Range
    r) -> Range -> OriginShapeIrrelevant
    OShIrrShapeIrrelevant (Range -> OriginShapeIrrelevant) -> Range -> OriginShapeIrrelevant
    forall a b. (a -> b) -> a -> b
    $ OriginShapeIrrelevant -> Range -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange OriginShapeIrrelevant
    o Range
    r

    instance Monoid OriginShapeIrrelevant where
      mempty :: OriginShapeIrrelevant
    mempty = OriginShapeIrrelevant
    forall a. Null a => a
    empty

    instance HasRange OriginShapeIrrelevant where
      getRange :: OriginShapeIrrelevant -> Range
    getRange = \case
        OriginShapeIrrelevant
    OShIrrInferred          -> Range
    forall a. Range' a
    noRange
        OShIrrDotDot          Range
    r -> Range
    r
        OShIrrShIrr           Range
    r -> Range
    r
        OShIrrShapeIrrelevant Range
    r -> Range
    r

    instance SetRange OriginShapeIrrelevant where
      setRange :: Range -> OriginShapeIrrelevant -> OriginShapeIrrelevant
    setRange Range
    r = \case
        OriginShapeIrrelevant
    OShIrrInferred          -> OriginShapeIrrelevant
    OShIrrInferred
        OShIrrDotDot Range
    _          -> Range -> OriginShapeIrrelevant
    OShIrrDotDot Range
    r
        OShIrrShIrr Range
    _           -> Range -> OriginShapeIrrelevant
    OShIrrShIrr Range
    r
        OShIrrShapeIrrelevant Range
    _ -> Range -> OriginShapeIrrelevant
    OShIrrShapeIrrelevant Range
    r

    instance KillRange OriginShapeIrrelevant where
      killRange :: OriginShapeIrrelevant -> OriginShapeIrrelevant
    killRange = Range -> OriginShapeIrrelevant -> OriginShapeIrrelevant
    forall a. SetRange a => Range -> a -> a
    setRange Range
    forall a. Range' a
    noRange

    instance NFData OriginShapeIrrelevant where
      rnf :: OriginShapeIrrelevant -> ()
    rnf = \case
        OriginShapeIrrelevant
    OShIrrInferred          -> ()
        OShIrrDotDot Range
    _          -> ()
        OShIrrShIrr Range
    _           -> ()
        OShIrrShapeIrrelevant Range
    _ -> ()

    instance Pretty OriginRelevant where
      pretty :: OriginRelevant -> Doc
    pretty = \case
        ORelInferred {} -> Doc
    forall a. Null a => a
    empty
        ORelRelevant {} -> Doc
    "@relevant"

    instance Pretty OriginIrrelevant where
      pretty :: OriginIrrelevant -> Doc
    pretty = \case
        OIrrInferred   {} -> Doc
    forall a. Null a => a
    empty
        OIrrDot        {} -> Doc
    "."
        OIrrIrr        {} -> Doc
    "@irr"
        OIrrIrrelevant {} -> Doc
    "@irrelevant"

    instance Pretty OriginShapeIrrelevant where
      pretty :: OriginShapeIrrelevant -> Doc
    pretty = \case
        OShIrrInferred        {} -> Doc
    forall a. Null a => a
    empty
        OShIrrDotDot          {} -> Doc
    ".."
        OShIrrShIrr           {} -> Doc
    "@shirr"
        OShIrrShapeIrrelevant {} -> Doc
    "@shape-irrelevant"

    -- ** Relevance levels

    -- | A function argument can be relevant or irrelevant.
    --   See "Agda.TypeChecking.Irrelevance".
    data Relevance
      = Relevant OriginRelevant
          -- ^ The argument is (possibly) relevant at compile-time.
      | ShapeIrrelevant OriginShapeIrrelevant
          -- ^ Like 'Quantity0', the argument may never flow into evaluation position.
          --   So it is irrelevant at run-time,
          --   yet treated relevantly during equality checking.
          --
          --   Unlike 'Quantity0', it is used to type 'Irrelevant' arguments in functions:
          --   If you enable @--experimental-irrelevance@,
          --   then the type of an irrelevant function is forced to be shape-irrelevant.
          --   See:
          --   - <https://doi.org/10.2168/LMCS-8(1:29)2012> example 2.8
          --     (Not enforcing shape-irrelevant codomains can break subject reduction!)
          --   - <https://dl.acm.org/doi/10.1145/3110277>
          --   - <https://doi.org/10.1145/3209108.3209119>
      | Irrelevant OriginIrrelevant
          -- ^ The argument is irrelevant at compile- and runtime.
        deriving (Int -> Relevance -> ShowS
    [Relevance] -> ShowS
    Relevance -> ArgName
    (Int -> Relevance -> ShowS)
    -> (Relevance -> ArgName)
    -> ([Relevance] -> ShowS)
    -> Show Relevance
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Relevance -> ShowS
    showsPrec :: Int -> Relevance -> ShowS
    $cshow :: Relevance -> ArgName
    show :: Relevance -> ArgName
    $cshowList :: [Relevance] -> ShowS
    showList :: [Relevance] -> ShowS
    Show, (forall x. Relevance -> Rep Relevance x)
    -> (forall x. Rep Relevance x -> Relevance) -> Generic Relevance
    forall x. Rep Relevance x -> Relevance
    forall x. Relevance -> Rep Relevance x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Relevance -> Rep Relevance x
    from :: forall x. Relevance -> Rep Relevance x
    $cto :: forall x. Rep Relevance x -> Relevance
    to :: forall x. Rep Relevance x -> Relevance
    Generic)

    instance Eq Relevance where
      == :: Relevance -> Relevance -> Bool
    (==) = Relevance -> Relevance -> Bool
    sameRelevance

    instance HasRange Relevance where
      getRange :: Relevance -> Range
    getRange = \case
        Relevant        OriginRelevant
    o -> OriginRelevant -> Range
    forall a. HasRange a => a -> Range
    getRange OriginRelevant
    o
        ShapeIrrelevant OriginShapeIrrelevant
    o -> OriginShapeIrrelevant -> Range
    forall a. HasRange a => a -> Range
    getRange OriginShapeIrrelevant
    o
        Irrelevant      OriginIrrelevant
    o -> OriginIrrelevant -> Range
    forall a. HasRange a => a -> Range
    getRange OriginIrrelevant
    o

    instance SetRange Relevance where
      setRange :: Range -> Relevance -> Relevance
    setRange Range
    r = \case
        Relevant        OriginRelevant
    o -> OriginRelevant -> Relevance
    Relevant        (OriginRelevant -> Relevance) -> OriginRelevant -> Relevance
    forall a b. (a -> b) -> a -> b
    $ Range -> OriginRelevant -> OriginRelevant
    forall a. SetRange a => Range -> a -> a
    setRange Range
    r OriginRelevant
    o
        ShapeIrrelevant OriginShapeIrrelevant
    o -> OriginShapeIrrelevant -> Relevance
    ShapeIrrelevant (OriginShapeIrrelevant -> Relevance)
    -> OriginShapeIrrelevant -> Relevance
    forall a b. (a -> b) -> a -> b
    $ Range -> OriginShapeIrrelevant -> OriginShapeIrrelevant
    forall a. SetRange a => Range -> a -> a
    setRange Range
    r OriginShapeIrrelevant
    o
        Irrelevant      OriginIrrelevant
    o -> OriginIrrelevant -> Relevance
    Irrelevant      (OriginIrrelevant -> Relevance) -> OriginIrrelevant -> Relevance
    forall a b. (a -> b) -> a -> b
    $ Range -> OriginIrrelevant -> OriginIrrelevant
    forall a. SetRange a => Range -> a -> a
    setRange Range
    r OriginIrrelevant
    o

    instance KillRange Relevance where
      killRange :: Relevance -> Relevance
    killRange = Range -> Relevance -> Relevance
    forall a. SetRange a => Range -> a -> a
    setRange Range
    forall a. Range' a
    noRange

    instance NFData Relevance where
      rnf :: Relevance -> ()
    rnf = \case
        Relevant        OriginRelevant
    o -> OriginRelevant -> ()
    forall a. NFData a => a -> ()
    rnf OriginRelevant
    o
        ShapeIrrelevant OriginShapeIrrelevant
    o -> OriginShapeIrrelevant -> ()
    forall a. NFData a => a -> ()
    rnf OriginShapeIrrelevant
    o
        Irrelevant      OriginIrrelevant
    o -> OriginIrrelevant -> ()
    forall a. NFData a => a -> ()
    rnf OriginIrrelevant
    o

    -- | A lens to access the 'Relevance' attribute in data structures.
    --   Minimal implementation: @getRelevance@ and @mapRelevance@ or @LensModality@.
    class LensRelevance a where

      getRelevance :: a -> Relevance

      setRelevance :: Relevance -> a -> a
      setRelevance Relevance
    h = (Relevance -> Relevance) -> a -> a
    forall a. LensRelevance a => (Relevance -> Relevance) -> a -> a
    mapRelevance (Relevance -> Relevance -> Relevance
    forall a b. a -> b -> a
    const Relevance
    h)

      mapRelevance :: (Relevance -> Relevance) -> a -> a

      default getRelevance :: LensModality a => a -> Relevance
      getRelevance = Modality -> Relevance
    modRelevance (Modality -> Relevance) -> (a -> Modality) -> a -> Relevance
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Modality
    forall a. LensModality a => a -> Modality
    getModality

      default mapRelevance :: LensModality a => (Relevance -> Relevance) -> a -> a
      mapRelevance Relevance -> Relevance
    f = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> (Modality -> Modality) -> a -> a
    forall a b. (a -> b) -> a -> b
    $ \ Modality
    ai -> Modality
    ai { modRelevance = f $ modRelevance ai }

    instance LensRelevance Relevance where
      getRelevance :: Relevance -> Relevance
    getRelevance = Relevance -> Relevance
    forall a. a -> a
    id
      setRelevance :: Relevance -> Relevance -> Relevance
    setRelevance = Relevance -> Relevance -> Relevance
    forall a b. a -> b -> a
    const
      mapRelevance :: (Relevance -> Relevance) -> Relevance -> Relevance
    mapRelevance = (Relevance -> Relevance) -> Relevance -> Relevance
    forall a. a -> a
    id

    relevant :: Relevance
    relevant :: Relevance
    relevant = OriginRelevant -> Relevance
    Relevant OriginRelevant
    forall a. Null a => a
    empty

    irrelevant :: Relevance
    irrelevant :: Relevance
    irrelevant = OriginIrrelevant -> Relevance
    Irrelevant OriginIrrelevant
    forall a. Null a => a
    empty

    shapeIrrelevant :: Relevance
    shapeIrrelevant :: Relevance
    shapeIrrelevant = OriginShapeIrrelevant -> Relevance
    ShapeIrrelevant OriginShapeIrrelevant
    forall a. Null a => a
    empty

    isRelevant :: LensRelevance a => a -> Bool
    isRelevant :: forall a. LensRelevance a => a -> Bool
    isRelevant a
    a = case a -> Relevance
    forall a. LensRelevance a => a -> Relevance
    getRelevance a
    a of
      Relevant{} -> Bool
    True
      Relevance
    _ -> Bool
    False

    isIrrelevant :: LensRelevance a => a -> Bool
    isIrrelevant :: forall a. LensRelevance a => a -> Bool
    isIrrelevant a
    a = case a -> Relevance
    forall a. LensRelevance a => a -> Relevance
    getRelevance a
    a of
      Irrelevant{} -> Bool
    True
      Relevance
    _ -> Bool
    False

    isShapeIrrelevant :: LensRelevance a => a -> Bool
    isShapeIrrelevant :: forall a. LensRelevance a => a -> Bool
    isShapeIrrelevant a
    a = case a -> Relevance
    forall a. LensRelevance a => a -> Relevance
    getRelevance a
    a of
      ShapeIrrelevant{} -> Bool
    True
      Relevance
    _ -> Bool
    False

    -- | Information ordering.
    -- @Relevant  \`moreRelevant\`
    --  ShapeIrrelevant \`moreRelevant\`
    --  Irrelevant@
    moreRelevant :: Relevance -> Relevance -> Bool
    moreRelevant :: Relevance -> Relevance -> Bool
    moreRelevant = Relevance -> Relevance -> Bool
    forall a. Ord a => a -> a -> Bool
    (<=)

    -- | Equality ignoring origin.
    sameRelevance :: Relevance -> Relevance -> Bool
    sameRelevance :: Relevance -> Relevance -> Bool
    sameRelevance = ((Relevance, Relevance) -> Bool) -> Relevance -> Relevance -> Bool
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry (((Relevance, Relevance) -> Bool)
     -> Relevance -> Relevance -> Bool)
    -> ((Relevance, Relevance) -> Bool)
    -> Relevance
    -> Relevance
    -> Bool
    forall a b. (a -> b) -> a -> b
    $ \case
      (Relevant        {}, Relevant        {}) -> Bool
    True
      (Irrelevant      {}, Irrelevant      {}) -> Bool
    True
      (ShapeIrrelevant {}, ShapeIrrelevant {}) -> Bool
    True
      (Relevance, Relevance)
    _ -> Bool
    False

    -- | More relevant is smaller.
    instance Ord Relevance where
      compare :: Relevance -> Relevance -> Ordering
    compare = ((Relevance, Relevance) -> Ordering)
    -> Relevance -> Relevance -> Ordering
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry \case
        (Relevance
    r, Relevance
    r') | Relevance -> Relevance -> Bool
    sameRelevance Relevance
    r Relevance
    r' -> Ordering
    EQ
        -- top
        (Relevance
    _, Irrelevant{}) -> Ordering
    LT
        (Irrelevant{}, Relevance
    _) -> Ordering
    GT
        -- bottom
        (Relevant{}, Relevance
    _) -> Ordering
    LT
        (Relevance
    _, Relevant{}) -> Ordering
    GT
        -- redundant case
        (ShapeIrrelevant{}, ShapeIrrelevant{}) -> Ordering
    EQ

    -- | More relevant is smaller.
    instance PartialOrd Relevance where
      comparable :: Comparable Relevance
    comparable = Comparable Relevance
    forall a. Ord a => Comparable a
    comparableOrd

    -- | @usableRelevance rel == False@ iff we cannot use a variable of @rel@.
    usableRelevance :: LensRelevance a => a -> Bool
    usableRelevance :: forall a. LensRelevance a => a -> Bool
    usableRelevance = a -> Bool
    forall a. LensRelevance a => a -> Bool
    isRelevant

    -- | 'Relevance' composition.
    --   'Irrelevant' is dominant, 'Relevant' is neutral.
    --   Composition coincides with 'max'.
    composeRelevance :: Relevance -> Relevance -> Relevance
    composeRelevance :: Relevance -> Relevance -> Relevance
    composeRelevance = ((Relevance, Relevance) -> Relevance)
    -> Relevance -> Relevance -> Relevance
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry \case
      (Relevant OriginRelevant
    o        , Relevant OriginRelevant
    o'       ) -> OriginRelevant -> Relevance
    Relevant (OriginRelevant
    o OriginRelevant -> OriginRelevant -> OriginRelevant
    forall a. Semigroup a => a -> a -> a
    <> OriginRelevant
    o')
      (Relevant{}        , Relevance
    r                 ) -> Relevance
    r
      (Relevance
    r                 , Relevant{}        ) -> Relevance
    r
      (Irrelevant OriginIrrelevant
    o      , Irrelevant OriginIrrelevant
    o'     ) -> OriginIrrelevant -> Relevance
    Irrelevant (OriginIrrelevant
    o OriginIrrelevant -> OriginIrrelevant -> OriginIrrelevant
    forall a. Semigroup a => a -> a -> a
    <> OriginIrrelevant
    o')
      (Relevance
    _                 , Irrelevant OriginIrrelevant
    o      ) -> OriginIrrelevant -> Relevance
    Irrelevant OriginIrrelevant
    o
      (Irrelevant OriginIrrelevant
    o      , Relevance
    _                 ) -> OriginIrrelevant -> Relevance
    Irrelevant OriginIrrelevant
    o
      (ShapeIrrelevant OriginShapeIrrelevant
    o , ShapeIrrelevant OriginShapeIrrelevant
    o') -> OriginShapeIrrelevant -> Relevance
    ShapeIrrelevant (OriginShapeIrrelevant
    o OriginShapeIrrelevant
    -> OriginShapeIrrelevant -> OriginShapeIrrelevant
    forall a. Semigroup a => a -> a -> a
    <> OriginShapeIrrelevant
    o')

    -- | Compose with relevance flag from the left.
    --   This function is e.g. used to update the relevance information
    --   on pattern variables @a@ after a match against something @rel@.
    applyRelevance :: LensRelevance a => Relevance -> a -> a
    applyRelevance :: forall a. LensRelevance a => Relevance -> a -> a
    applyRelevance Relevance
    rel = (Relevance -> Relevance) -> a -> a
    forall a. LensRelevance a => (Relevance -> Relevance) -> a -> a
    mapRelevance (Relevance
    rel Relevance -> Relevance -> Relevance
    `composeRelevance`)

    -- | @inverseComposeRelevance r x@ returns the most irrelevant @y@
    --   such that forall @x@, @y@ we have
    --   @x \`moreRelevant\` (r \`composeRelevance\` y)@
    --   iff
    --   @(r \`inverseComposeRelevance\` x) \`moreRelevant\` y@ (Galois connection).
    inverseComposeRelevance :: Relevance -> Relevance -> Relevance
    inverseComposeRelevance :: Relevance -> Relevance -> Relevance
    inverseComposeRelevance = ((Relevance, Relevance) -> Relevance)
    -> Relevance -> Relevance -> Relevance
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry \case
      (Relevance
    _                 , Relevant OriginRelevant
    o       ) -> OriginRelevant -> Relevance
    Relevant OriginRelevant
    o   -- can't get more relevant
      (Relevant{}        , Relevance
    x                ) -> Relevance
    x            -- going to relevant arg.: nothing changes
                                                              -- because Relevant is comp.-neutral
      (Irrelevant{}      , Relevance
    x                ) -> Relevance
    relevant     -- going irrelevant: every thing usable
      (ShapeIrrelevant{} , Irrelevant OriginIrrelevant
    o     ) -> OriginIrrelevant -> Relevance
    Irrelevant OriginIrrelevant
    o -- otherwise: irrelevant things remain unusable
      (ShapeIrrelevant{} , ShapeIrrelevant{}) -> Relevance
    relevant     -- but @ShapeIrrelevant@s become usable

    -- | Left division by a 'Relevance'.
    --   Used e.g. to modify context when going into a @rel@ argument.
    inverseApplyRelevance :: LensRelevance a => Relevance -> a -> a
    inverseApplyRelevance :: forall a. LensRelevance a => Relevance -> a -> a
    inverseApplyRelevance Relevance
    rel = (Relevance -> Relevance) -> a -> a
    forall a. LensRelevance a => (Relevance -> Relevance) -> a -> a
    mapRelevance (Relevance
    rel Relevance -> Relevance -> Relevance
    `inverseComposeRelevance`)

    -- | 'Relevance' forms a semigroup under composition.
    instance Semigroup (UnderComposition Relevance) where
      <> :: UnderComposition Relevance
    -> UnderComposition Relevance -> UnderComposition Relevance
    (<>) = (Relevance -> Relevance -> Relevance)
    -> UnderComposition Relevance
    -> UnderComposition Relevance
    -> UnderComposition Relevance
    forall a b c.
    (a -> b -> c)
    -> UnderComposition a -> UnderComposition b -> UnderComposition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Relevance -> Relevance -> Relevance
    composeRelevance

    -- | 'Relevant' is the unit under composition.
    instance Monoid (UnderComposition Relevance) where
      mempty :: UnderComposition Relevance
    mempty  = Relevance -> UnderComposition Relevance
    forall a. a -> UnderComposition a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Relevance
    unitRelevance
      mappend :: UnderComposition Relevance
    -> UnderComposition Relevance -> UnderComposition Relevance
    mappend = UnderComposition Relevance
    -> UnderComposition Relevance -> UnderComposition Relevance
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance POSemigroup (UnderComposition Relevance) where
    instance POMonoid (UnderComposition Relevance) where

    instance LeftClosedPOMonoid (UnderComposition Relevance) where
      inverseCompose :: UnderComposition Relevance
    -> UnderComposition Relevance -> UnderComposition Relevance
    inverseCompose = (Relevance -> Relevance -> Relevance)
    -> UnderComposition Relevance
    -> UnderComposition Relevance
    -> UnderComposition Relevance
    forall a b c.
    (a -> b -> c)
    -> UnderComposition a -> UnderComposition b -> UnderComposition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Relevance -> Relevance -> Relevance
    inverseComposeRelevance

    instance Semigroup (UnderAddition Relevance) where
      <> :: UnderAddition Relevance
    -> UnderAddition Relevance -> UnderAddition Relevance
    (<>) = (Relevance -> Relevance -> Relevance)
    -> UnderAddition Relevance
    -> UnderAddition Relevance
    -> UnderAddition Relevance
    forall a b c.
    (a -> b -> c)
    -> UnderAddition a -> UnderAddition b -> UnderAddition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Relevance -> Relevance -> Relevance
    addRelevance

    instance Monoid (UnderAddition Relevance) where
      mempty :: UnderAddition Relevance
    mempty  = Relevance -> UnderAddition Relevance
    forall a. a -> UnderAddition a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Relevance
    zeroRelevance
      mappend :: UnderAddition Relevance
    -> UnderAddition Relevance -> UnderAddition Relevance
    mappend = UnderAddition Relevance
    -> UnderAddition Relevance -> UnderAddition Relevance
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance POSemigroup (UnderAddition Relevance) where
    instance POMonoid (UnderAddition Relevance) where

    -- | Combine inferred 'Relevance'.
    --   The unit is 'Irrelevant'.
    addRelevance :: Relevance -> Relevance -> Relevance
    addRelevance :: Relevance -> Relevance -> Relevance
    addRelevance = Relevance -> Relevance -> Relevance
    forall a. Ord a => a -> a -> a
    min

    -- | 'Relevance' forms a monoid under addition, and even a semiring.
    zeroRelevance :: Relevance
    zeroRelevance :: Relevance
    zeroRelevance = Relevance
    irrelevant

    -- | Identity element under composition
    unitRelevance :: Relevance
    unitRelevance :: Relevance
    unitRelevance = Relevance
    relevant

    -- | Absorptive element under addition.
    topRelevance :: Relevance
    topRelevance :: Relevance
    topRelevance = Relevance
    relevant

    -- | Default Relevance is the identity element under composition
    defaultRelevance :: Relevance
    defaultRelevance :: Relevance
    defaultRelevance = Relevance
    unitRelevance

    -- | 'null' means no information, not even origin or range.
    instance Null Relevance where
      empty :: Relevance
    empty = Relevance
    defaultRelevance
      null :: Relevance -> Bool
    null = \case
        Relevant OriginRelevant
    o -> OriginRelevant -> Bool
    forall a. Null a => a -> Bool
    null OriginRelevant
    o
        Relevance
    _ -> Bool
    False

    -- | Irrelevant function arguments may appear non-strictly in the codomain type.
    irrelevantToShapeIrrelevant :: Relevance -> Relevance
    irrelevantToShapeIrrelevant :: Relevance -> Relevance
    irrelevantToShapeIrrelevant Irrelevant{} = Relevance
    shapeIrrelevant
    irrelevantToShapeIrrelevant Relevance
    rel = Relevance
    rel

    -- | Applied when working on types (unless --experimental-irrelevance).
    shapeIrrelevantToRelevant :: Relevance -> Relevance
    shapeIrrelevantToRelevant :: Relevance -> Relevance
    shapeIrrelevantToRelevant ShapeIrrelevant{} = Relevance
    relevant
    shapeIrrelevantToRelevant Relevance
    rel = Relevance
    rel

    shapeIrrelevantToIrrelevant :: Relevance -> Relevance
    shapeIrrelevantToIrrelevant :: Relevance -> Relevance
    shapeIrrelevantToIrrelevant ShapeIrrelevant{} = Relevance
    irrelevant
    shapeIrrelevantToIrrelevant Relevance
    rel = Relevance
    rel

    prettyRelevance :: LensRelevance a => a -> Doc -> Doc
    prettyRelevance :: forall a. LensRelevance a => a -> Doc -> Doc
    prettyRelevance a
    a = if ArgName -> Maybe Char
    forall a. [a] -> Maybe a
    lastMaybe (Doc -> ArgName
    forall a. Doc a -> ArgName
    render Doc
    d) Maybe Char -> Maybe Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char -> Maybe Char
    forall a. a -> Maybe a
    Just Char
    '.' then (Doc
    d Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <>) else (Doc
    d Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+>)
      where
        d :: Doc
    d = Relevance -> Doc
    forall a. Pretty a => a -> Doc
    pretty (Relevance -> Doc) -> Relevance -> Doc
    forall a b. (a -> b) -> a -> b
    $ a -> Relevance
    forall a. LensRelevance a => a -> Relevance
    getRelevance a
    a

    instance Pretty Relevance where
      pretty :: Relevance -> Doc
    pretty = \case
        Relevant        OriginRelevant
    o -> OriginRelevant -> Doc
    forall a. Pretty a => a -> Doc
    pretty OriginRelevant
    o
        Irrelevant      OriginIrrelevant
    o -> Doc -> Doc -> (Doc -> Doc) -> Doc
    forall a b. Null a => a -> b -> (a -> b) -> b
    ifNull (OriginIrrelevant -> Doc
    forall a. Pretty a => a -> Doc
    pretty OriginIrrelevant
    o) Doc
    "." Doc -> Doc
    forall a. a -> a
    id
        ShapeIrrelevant OriginShapeIrrelevant
    o -> Doc -> Doc -> (Doc -> Doc) -> Doc
    forall a b. Null a => a -> b -> (a -> b) -> b
    ifNull (OriginShapeIrrelevant -> Doc
    forall a. Pretty a => a -> Doc
    pretty OriginShapeIrrelevant
    o) Doc
    ".." Doc -> Doc
    forall a. a -> a
    id

    ---------------------------------------------------------------------------
    -- * Annotations
    ---------------------------------------------------------------------------

    -- | We have a tuple of annotations, which might not be fully orthogonal.
    data Annotation = Annotation
      { Annotation -> Lock
    annLock :: Lock
        -- ^ Fitch-style dependent right adjoints.
        --   See Modal Dependent Type Theory and Dependent Right Adjoints, arXiv:1804.05236.
      } deriving (Annotation -> Annotation -> Bool
    (Annotation -> Annotation -> Bool)
    -> (Annotation -> Annotation -> Bool) -> Eq Annotation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Annotation -> Annotation -> Bool
    == :: Annotation -> Annotation -> Bool
    $c/= :: Annotation -> Annotation -> Bool
    /= :: Annotation -> Annotation -> Bool
    Eq, Eq Annotation
    Eq Annotation =>
    (Annotation -> Annotation -> Ordering)
    -> (Annotation -> Annotation -> Bool)
    -> (Annotation -> Annotation -> Bool)
    -> (Annotation -> Annotation -> Bool)
    -> (Annotation -> Annotation -> Bool)
    -> (Annotation -> Annotation -> Annotation)
    -> (Annotation -> Annotation -> Annotation)
    -> Ord Annotation
    Annotation -> Annotation -> Bool
    Annotation -> Annotation -> Ordering
    Annotation -> Annotation -> Annotation
    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
    $ccompare :: Annotation -> Annotation -> Ordering
    compare :: Annotation -> Annotation -> Ordering
    $c< :: Annotation -> Annotation -> Bool
    < :: Annotation -> Annotation -> Bool
    $c<= :: Annotation -> Annotation -> Bool
    <= :: Annotation -> Annotation -> Bool
    $c> :: Annotation -> Annotation -> Bool
    > :: Annotation -> Annotation -> Bool
    $c>= :: Annotation -> Annotation -> Bool
    >= :: Annotation -> Annotation -> Bool
    $cmax :: Annotation -> Annotation -> Annotation
    max :: Annotation -> Annotation -> Annotation
    $cmin :: Annotation -> Annotation -> Annotation
    min :: Annotation -> Annotation -> Annotation
    Ord, Int -> Annotation -> ShowS
    [Annotation] -> ShowS
    Annotation -> ArgName
    (Int -> Annotation -> ShowS)
    -> (Annotation -> ArgName)
    -> ([Annotation] -> ShowS)
    -> Show Annotation
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Annotation -> ShowS
    showsPrec :: Int -> Annotation -> ShowS
    $cshow :: Annotation -> ArgName
    show :: Annotation -> ArgName
    $cshowList :: [Annotation] -> ShowS
    showList :: [Annotation] -> ShowS
    Show, (forall x. Annotation -> Rep Annotation x)
    -> (forall x. Rep Annotation x -> Annotation) -> Generic Annotation
    forall x. Rep Annotation x -> Annotation
    forall x. Annotation -> Rep Annotation x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Annotation -> Rep Annotation x
    from :: forall x. Annotation -> Rep Annotation x
    $cto :: forall x. Rep Annotation x -> Annotation
    to :: forall x. Rep Annotation x -> Annotation
    Generic)

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

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

    defaultAnnotation :: Annotation
    defaultAnnotation :: Annotation
    defaultAnnotation = Lock -> Annotation
    Annotation Lock
    defaultLock

    instance Null Annotation where
      empty :: Annotation
    empty = Annotation
    defaultAnnotation
      null :: Annotation -> Bool
    null (Annotation Lock
    lock) = Lock -> Bool
    forall a. Null a => a -> Bool
    null Lock
    lock

    instance NFData Annotation where
      rnf :: Annotation -> ()
    rnf (Annotation Lock
    l) = Lock -> ()
    forall a. NFData a => a -> ()
    rnf Lock
    l

    class LensAnnotation a where

      getAnnotation :: a -> Annotation

      setAnnotation :: Annotation -> a -> a

      mapAnnotation :: (Annotation -> Annotation) -> a -> a
      mapAnnotation Annotation -> Annotation
    f a
    a = Annotation -> a -> a
    forall a. LensAnnotation a => Annotation -> a -> a
    setAnnotation (Annotation -> Annotation
    f (Annotation -> Annotation) -> Annotation -> Annotation
    forall a b. (a -> b) -> a -> b
    $ a -> Annotation
    forall a. LensAnnotation a => a -> Annotation
    getAnnotation a
    a) a
    a

      default getAnnotation :: LensArgInfo a => a -> Annotation
      getAnnotation = ArgInfo -> Annotation
    argInfoAnnotation (ArgInfo -> Annotation) -> (a -> ArgInfo) -> a -> Annotation
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo

      default setAnnotation :: LensArgInfo a => Annotation -> a -> a
      setAnnotation Annotation
    a = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a) -> (ArgInfo -> ArgInfo) -> a -> a
    forall a b. (a -> b) -> a -> b
    $ \ ArgInfo
    ai -> ArgInfo
    ai { argInfoAnnotation = a }

    instance LensAnnotation Annotation where
      getAnnotation :: Annotation -> Annotation
    getAnnotation = Annotation -> Annotation
    forall a. a -> a
    id
      setAnnotation :: Annotation -> Annotation -> Annotation
    setAnnotation = Annotation -> Annotation -> Annotation
    forall a b. a -> b -> a
    const
      mapAnnotation :: (Annotation -> Annotation) -> Annotation -> Annotation
    mapAnnotation = (Annotation -> Annotation) -> Annotation -> Annotation
    forall a. a -> a
    id

    instance LensAnnotation (Arg t) where
      getAnnotation :: Arg t -> Annotation
    getAnnotation = ArgInfo -> Annotation
    forall a. LensAnnotation a => a -> Annotation
    getAnnotation (ArgInfo -> Annotation)
    -> (Arg t -> ArgInfo) -> Arg t -> Annotation
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Arg t -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo
      setAnnotation :: Annotation -> Arg t -> Arg t
    setAnnotation = (ArgInfo -> ArgInfo) -> Arg t -> Arg t
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> Arg t -> Arg t)
    -> (Annotation -> ArgInfo -> ArgInfo)
    -> Annotation
    -> Arg t
    -> Arg t
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Annotation -> ArgInfo -> ArgInfo
    forall a. LensAnnotation a => Annotation -> a -> a
    setAnnotation

    ---------------------------------------------------------------------------
    -- * Locks
    ---------------------------------------------------------------------------

    data LockOrigin
      = LockOLock -- ^ The user wrote @lock.
      | LockOTick -- ^ The user wrote @tick.
      deriving (Int -> LockOrigin -> ShowS
    [LockOrigin] -> ShowS
    LockOrigin -> ArgName
    (Int -> LockOrigin -> ShowS)
    -> (LockOrigin -> ArgName)
    -> ([LockOrigin] -> ShowS)
    -> Show LockOrigin
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> LockOrigin -> ShowS
    showsPrec :: Int -> LockOrigin -> ShowS
    $cshow :: LockOrigin -> ArgName
    show :: LockOrigin -> ArgName
    $cshowList :: [LockOrigin] -> ShowS
    showList :: [LockOrigin] -> ShowS
    Show, (forall x. LockOrigin -> Rep LockOrigin x)
    -> (forall x. Rep LockOrigin x -> LockOrigin) -> Generic LockOrigin
    forall x. Rep LockOrigin x -> LockOrigin
    forall x. LockOrigin -> Rep LockOrigin x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. LockOrigin -> Rep LockOrigin x
    from :: forall x. LockOrigin -> Rep LockOrigin x
    $cto :: forall x. Rep LockOrigin x -> LockOrigin
    to :: forall x. Rep LockOrigin x -> LockOrigin
    Generic, LockOrigin -> LockOrigin -> Bool
    (LockOrigin -> LockOrigin -> Bool)
    -> (LockOrigin -> LockOrigin -> Bool) -> Eq LockOrigin
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: LockOrigin -> LockOrigin -> Bool
    == :: LockOrigin -> LockOrigin -> Bool
    $c/= :: LockOrigin -> LockOrigin -> Bool
    /= :: LockOrigin -> LockOrigin -> Bool
    Eq, Int -> LockOrigin
    LockOrigin -> Int
    LockOrigin -> [LockOrigin]
    LockOrigin -> LockOrigin
    LockOrigin -> LockOrigin -> [LockOrigin]
    LockOrigin -> LockOrigin -> LockOrigin -> [LockOrigin]
    (LockOrigin -> LockOrigin)
    -> (LockOrigin -> LockOrigin)
    -> (Int -> LockOrigin)
    -> (LockOrigin -> Int)
    -> (LockOrigin -> [LockOrigin])
    -> (LockOrigin -> LockOrigin -> [LockOrigin])
    -> (LockOrigin -> LockOrigin -> [LockOrigin])
    -> (LockOrigin -> LockOrigin -> LockOrigin -> [LockOrigin])
    -> Enum LockOrigin
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: LockOrigin -> LockOrigin
    succ :: LockOrigin -> LockOrigin
    $cpred :: LockOrigin -> LockOrigin
    pred :: LockOrigin -> LockOrigin
    $ctoEnum :: Int -> LockOrigin
    toEnum :: Int -> LockOrigin
    $cfromEnum :: LockOrigin -> Int
    fromEnum :: LockOrigin -> Int
    $cenumFrom :: LockOrigin -> [LockOrigin]
    enumFrom :: LockOrigin -> [LockOrigin]
    $cenumFromThen :: LockOrigin -> LockOrigin -> [LockOrigin]
    enumFromThen :: LockOrigin -> LockOrigin -> [LockOrigin]
    $cenumFromTo :: LockOrigin -> LockOrigin -> [LockOrigin]
    enumFromTo :: LockOrigin -> LockOrigin -> [LockOrigin]
    $cenumFromThenTo :: LockOrigin -> LockOrigin -> LockOrigin -> [LockOrigin]
    enumFromThenTo :: LockOrigin -> LockOrigin -> LockOrigin -> [LockOrigin]
    Enum, LockOrigin
    LockOrigin -> LockOrigin -> Bounded LockOrigin
    forall a. a -> a -> Bounded a
    $cminBound :: LockOrigin
    minBound :: LockOrigin
    $cmaxBound :: LockOrigin
    maxBound :: LockOrigin
    Bounded, Eq LockOrigin
    Eq LockOrigin =>
    (LockOrigin -> LockOrigin -> Ordering)
    -> (LockOrigin -> LockOrigin -> Bool)
    -> (LockOrigin -> LockOrigin -> Bool)
    -> (LockOrigin -> LockOrigin -> Bool)
    -> (LockOrigin -> LockOrigin -> Bool)
    -> (LockOrigin -> LockOrigin -> LockOrigin)
    -> (LockOrigin -> LockOrigin -> LockOrigin)
    -> Ord LockOrigin
    LockOrigin -> LockOrigin -> Bool
    LockOrigin -> LockOrigin -> Ordering
    LockOrigin -> LockOrigin -> LockOrigin
    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
    $ccompare :: LockOrigin -> LockOrigin -> Ordering
    compare :: LockOrigin -> LockOrigin -> Ordering
    $c< :: LockOrigin -> LockOrigin -> Bool
    < :: LockOrigin -> LockOrigin -> Bool
    $c<= :: LockOrigin -> LockOrigin -> Bool
    <= :: LockOrigin -> LockOrigin -> Bool
    $c> :: LockOrigin -> LockOrigin -> Bool
    > :: LockOrigin -> LockOrigin -> Bool
    $c>= :: LockOrigin -> LockOrigin -> Bool
    >= :: LockOrigin -> LockOrigin -> Bool
    $cmax :: LockOrigin -> LockOrigin -> LockOrigin
    max :: LockOrigin -> LockOrigin -> LockOrigin
    $cmin :: LockOrigin -> LockOrigin -> LockOrigin
    min :: LockOrigin -> LockOrigin -> LockOrigin
    Ord)

    data Lock
      = IsNotLock
      | IsLock LockOrigin
      -- ^ In the future there might be different kinds of them.
      --   For now we assume lock weakening.
      deriving (Int -> Lock -> ShowS
    [Lock] -> ShowS
    Lock -> ArgName
    (Int -> Lock -> ShowS)
    -> (Lock -> ArgName) -> ([Lock] -> ShowS) -> Show Lock
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Lock -> ShowS
    showsPrec :: Int -> Lock -> ShowS
    $cshow :: Lock -> ArgName
    show :: Lock -> ArgName
    $cshowList :: [Lock] -> ShowS
    showList :: [Lock] -> ShowS
    Show, (forall x. Lock -> Rep Lock x)
    -> (forall x. Rep Lock x -> Lock) -> Generic Lock
    forall x. Rep Lock x -> Lock
    forall x. Lock -> Rep Lock x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Lock -> Rep Lock x
    from :: forall x. Lock -> Rep Lock x
    $cto :: forall x. Rep Lock x -> Lock
    to :: forall x. Rep Lock x -> Lock
    Generic, Lock -> Lock -> Bool
    (Lock -> Lock -> Bool) -> (Lock -> Lock -> Bool) -> Eq Lock
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Lock -> Lock -> Bool
    == :: Lock -> Lock -> Bool
    $c/= :: Lock -> Lock -> Bool
    /= :: Lock -> Lock -> Bool
    Eq, Eq Lock
    Eq Lock =>
    (Lock -> Lock -> Ordering)
    -> (Lock -> Lock -> Bool)
    -> (Lock -> Lock -> Bool)
    -> (Lock -> Lock -> Bool)
    -> (Lock -> Lock -> Bool)
    -> (Lock -> Lock -> Lock)
    -> (Lock -> Lock -> Lock)
    -> Ord Lock
    Lock -> Lock -> Bool
    Lock -> Lock -> Ordering
    Lock -> Lock -> Lock
    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
    $ccompare :: Lock -> Lock -> Ordering
    compare :: Lock -> Lock -> Ordering
    $c< :: Lock -> Lock -> Bool
    < :: Lock -> Lock -> Bool
    $c<= :: Lock -> Lock -> Bool
    <= :: Lock -> Lock -> Bool
    $c> :: Lock -> Lock -> Bool
    > :: Lock -> Lock -> Bool
    $c>= :: Lock -> Lock -> Bool
    >= :: Lock -> Lock -> Bool
    $cmax :: Lock -> Lock -> Lock
    max :: Lock -> Lock -> Lock
    $cmin :: Lock -> Lock -> Lock
    min :: Lock -> Lock -> Lock
    Ord)

    defaultLock :: Lock
    defaultLock :: Lock
    defaultLock = Lock
    IsNotLock

    instance Null Lock where
      empty :: Lock
    empty = Lock
    defaultLock

    instance NFData Lock where
      rnf :: Lock -> ()
    rnf Lock
    IsNotLock          = ()
      rnf (IsLock LockOrigin
    LockOLock) = ()
      rnf (IsLock LockOrigin
    LockOTick) = ()

    class LensLock a where

      getLock :: a -> Lock

      setLock :: Lock -> a -> a
      setLock = (Lock -> Lock) -> a -> a
    forall a. LensLock a => (Lock -> Lock) -> a -> a
    mapLock ((Lock -> Lock) -> a -> a)
    -> (Lock -> Lock -> Lock) -> Lock -> a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Lock -> Lock -> Lock
    forall a b. a -> b -> a
    const

      mapLock :: (Lock -> Lock) -> a -> a
      mapLock Lock -> Lock
    f a
    a = Lock -> a -> a
    forall a. LensLock a => Lock -> a -> a
    setLock (Lock -> Lock
    f (Lock -> Lock) -> Lock -> Lock
    forall a b. (a -> b) -> a -> b
    $ a -> Lock
    forall a. LensLock a => a -> Lock
    getLock a
    a) a
    a

    instance LensLock Lock where
      getLock :: Lock -> Lock
    getLock = Lock -> Lock
    forall a. a -> a
    id
      setLock :: Lock -> Lock -> Lock
    setLock = Lock -> Lock -> Lock
    forall a b. a -> b -> a
    const
      mapLock :: (Lock -> Lock) -> Lock -> Lock
    mapLock = (Lock -> Lock) -> Lock -> Lock
    forall a. a -> a
    id

    instance LensLock ArgInfo where
      getLock :: ArgInfo -> Lock
    getLock = Annotation -> Lock
    annLock (Annotation -> Lock) -> (ArgInfo -> Annotation) -> ArgInfo -> Lock
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ArgInfo -> Annotation
    argInfoAnnotation
      setLock :: Lock -> ArgInfo -> ArgInfo
    setLock Lock
    l ArgInfo
    info = ArgInfo
    info { argInfoAnnotation = (argInfoAnnotation info){ annLock = l } }

    instance LensLock (Arg t) where
      getLock :: Arg t -> Lock
    getLock = ArgInfo -> Lock
    forall a. LensLock a => a -> Lock
    getLock (ArgInfo -> Lock) -> (Arg t -> ArgInfo) -> Arg t -> Lock
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Arg t -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo
      setLock :: Lock -> Arg t -> Arg t
    setLock = (ArgInfo -> ArgInfo) -> Arg t -> Arg t
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> Arg t -> Arg t)
    -> (Lock -> ArgInfo -> ArgInfo) -> Lock -> Arg t -> Arg t
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Lock -> ArgInfo -> ArgInfo
    forall a. LensLock a => Lock -> a -> a
    setLock

    instance Pretty Lock where
      pretty :: Lock -> Doc
    pretty = \case
        IsLock LockOrigin
    LockOLock -> Doc
    "@lock"
        IsLock LockOrigin
    LockOTick -> Doc
    "@tick"
        Lock
    IsNotLock -> Doc
    forall a. Null a => a
    empty

    prettyLock :: LensLock a => a -> Doc -> Doc
    prettyLock :: forall a. LensLock a => a -> Doc -> Doc
    prettyLock a
    a = (Lock -> Doc
    forall a. Pretty a => a -> Doc
    pretty (a -> Lock
    forall a. LensLock a => a -> Lock
    getLock a
    a) Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+>)

    ---------------------------------------------------------------------------
    -- * Cohesion
    ---------------------------------------------------------------------------

    -- | Cohesion modalities
    --   see "Brouwer's fixed-point theorem in real-cohesive homotopy type theory" (arXiv:1509.07584)
    --   types are now given an additional topological layer which the modalities interact with.
    data Cohesion
      = Flat        -- ^ same points, discrete topology, idempotent comonad, box-like.
      | Continuous  -- ^ identity modality.
      -- | Sharp    -- ^ same points, codiscrete topology, idempotent monad, diamond-like.
      | Squash      -- ^ single point space, artificially added for Flat left-composition.
        deriving (Int -> Cohesion -> ShowS
    [Cohesion] -> ShowS
    Cohesion -> ArgName
    (Int -> Cohesion -> ShowS)
    -> (Cohesion -> ArgName) -> ([Cohesion] -> ShowS) -> Show Cohesion
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Cohesion -> ShowS
    showsPrec :: Int -> Cohesion -> ShowS
    $cshow :: Cohesion -> ArgName
    show :: Cohesion -> ArgName
    $cshowList :: [Cohesion] -> ShowS
    showList :: [Cohesion] -> ShowS
    Show, Cohesion -> Cohesion -> Bool
    (Cohesion -> Cohesion -> Bool)
    -> (Cohesion -> Cohesion -> Bool) -> Eq Cohesion
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Cohesion -> Cohesion -> Bool
    == :: Cohesion -> Cohesion -> Bool
    $c/= :: Cohesion -> Cohesion -> Bool
    /= :: Cohesion -> Cohesion -> Bool
    Eq, Int -> Cohesion
    Cohesion -> Int
    Cohesion -> [Cohesion]
    Cohesion -> Cohesion
    Cohesion -> Cohesion -> [Cohesion]
    Cohesion -> Cohesion -> Cohesion -> [Cohesion]
    (Cohesion -> Cohesion)
    -> (Cohesion -> Cohesion)
    -> (Int -> Cohesion)
    -> (Cohesion -> Int)
    -> (Cohesion -> [Cohesion])
    -> (Cohesion -> Cohesion -> [Cohesion])
    -> (Cohesion -> Cohesion -> [Cohesion])
    -> (Cohesion -> Cohesion -> Cohesion -> [Cohesion])
    -> Enum Cohesion
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: Cohesion -> Cohesion
    succ :: Cohesion -> Cohesion
    $cpred :: Cohesion -> Cohesion
    pred :: Cohesion -> Cohesion
    $ctoEnum :: Int -> Cohesion
    toEnum :: Int -> Cohesion
    $cfromEnum :: Cohesion -> Int
    fromEnum :: Cohesion -> Int
    $cenumFrom :: Cohesion -> [Cohesion]
    enumFrom :: Cohesion -> [Cohesion]
    $cenumFromThen :: Cohesion -> Cohesion -> [Cohesion]
    enumFromThen :: Cohesion -> Cohesion -> [Cohesion]
    $cenumFromTo :: Cohesion -> Cohesion -> [Cohesion]
    enumFromTo :: Cohesion -> Cohesion -> [Cohesion]
    $cenumFromThenTo :: Cohesion -> Cohesion -> Cohesion -> [Cohesion]
    enumFromThenTo :: Cohesion -> Cohesion -> Cohesion -> [Cohesion]
    Enum, Cohesion
    Cohesion -> Cohesion -> Bounded Cohesion
    forall a. a -> a -> Bounded a
    $cminBound :: Cohesion
    minBound :: Cohesion
    $cmaxBound :: Cohesion
    maxBound :: Cohesion
    Bounded, (forall x. Cohesion -> Rep Cohesion x)
    -> (forall x. Rep Cohesion x -> Cohesion) -> Generic Cohesion
    forall x. Rep Cohesion x -> Cohesion
    forall x. Cohesion -> Rep Cohesion x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Cohesion -> Rep Cohesion x
    from :: forall x. Cohesion -> Rep Cohesion x
    $cto :: forall x. Rep Cohesion x -> Cohesion
    to :: forall x. Rep Cohesion x -> Cohesion
    Generic)

    allCohesions :: [Cohesion]
    allCohesions :: [Cohesion]
    allCohesions = [Cohesion
    forall a. Bounded a => a
    minBound..Cohesion
    forall a. Bounded a => a
    maxBound]

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

    instance SetRange Cohesion where
      setRange :: Range -> Cohesion -> Cohesion
    setRange Range
    _ = Cohesion -> Cohesion
    forall a. a -> a
    id

    instance KillRange Cohesion where
      killRange :: Cohesion -> Cohesion
    killRange Cohesion
    rel = Cohesion
    rel -- no range to kill

    instance NFData Cohesion where
      rnf :: Cohesion -> ()
    rnf Cohesion
    Flat       = ()
      rnf Cohesion
    Continuous = ()
      rnf Cohesion
    Squash     = ()

    instance Pretty Cohesion where
      pretty :: Cohesion -> Doc
    pretty Cohesion
    Flat   = Doc
    "@♭"
      pretty Cohesion
    Continuous = Doc
    forall a. Monoid a => a
    mempty
      pretty Cohesion
    Squash  = Doc
    "@⊤"

    -- | A lens to access the 'Cohesion' attribute in data structures.
    --   Minimal implementation: @getCohesion@ and @mapCohesion@ or @LensModality@.
    class LensCohesion a where

      getCohesion :: a -> Cohesion

      setCohesion :: Cohesion -> a -> a
      setCohesion Cohesion
    h = (Cohesion -> Cohesion) -> a -> a
    forall a. LensCohesion a => (Cohesion -> Cohesion) -> a -> a
    mapCohesion (Cohesion -> Cohesion -> Cohesion
    forall a b. a -> b -> a
    const Cohesion
    h)

      mapCohesion :: (Cohesion -> Cohesion) -> a -> a

      default getCohesion :: LensModality a => a -> Cohesion
      getCohesion = Modality -> Cohesion
    modCohesion (Modality -> Cohesion) -> (a -> Modality) -> a -> Cohesion
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Modality
    forall a. LensModality a => a -> Modality
    getModality

      default mapCohesion :: LensModality a => (Cohesion -> Cohesion) -> a -> a
      mapCohesion Cohesion -> Cohesion
    f = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> (Modality -> Modality) -> a -> a
    forall a b. (a -> b) -> a -> b
    $ \ Modality
    ai -> Modality
    ai { modCohesion = f $ modCohesion ai }

    instance LensCohesion Cohesion where
      getCohesion :: Cohesion -> Cohesion
    getCohesion = Cohesion -> Cohesion
    forall a. a -> a
    id
      setCohesion :: Cohesion -> Cohesion -> Cohesion
    setCohesion = Cohesion -> Cohesion -> Cohesion
    forall a b. a -> b -> a
    const
      mapCohesion :: (Cohesion -> Cohesion) -> Cohesion -> Cohesion
    mapCohesion = (Cohesion -> Cohesion) -> Cohesion -> Cohesion
    forall a. a -> a
    id

    isContinuous :: LensCohesion a => a -> Bool
    isContinuous :: forall a. LensCohesion a => a -> Bool
    isContinuous = (Cohesion
    Continuous Cohesion -> Cohesion -> Bool
    forall a. Eq a => a -> a -> Bool
    ==) (Cohesion -> Bool) -> (a -> Cohesion) -> a -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Cohesion
    forall a. LensCohesion a => a -> Cohesion
    getCohesion

    -- | Information ordering.
    -- @Flat  \`moreCohesion\`
    --  Continuous \`moreCohesion\`
    --  Sharp \`moreCohesion\`
    --  Squash@
    moreCohesion :: Cohesion -> Cohesion -> Bool
    moreCohesion :: Cohesion -> Cohesion -> Bool
    moreCohesion = Cohesion -> Cohesion -> Bool
    forall a. Ord a => a -> a -> Bool
    (<=)

    -- | Equality ignoring origin.
    sameCohesion :: Cohesion -> Cohesion -> Bool
    sameCohesion :: Cohesion -> Cohesion -> Bool
    sameCohesion = Cohesion -> Cohesion -> Bool
    forall a. Eq a => a -> a -> Bool
    (==)

    -- | Order is given by implication: flatter is smaller.
    instance Ord Cohesion where
      compare :: Cohesion -> Cohesion -> Ordering
    compare = ((Cohesion, Cohesion) -> Ordering)
    -> Cohesion -> Cohesion -> Ordering
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry (((Cohesion, Cohesion) -> Ordering)
     -> Cohesion -> Cohesion -> Ordering)
    -> ((Cohesion, Cohesion) -> Ordering)
    -> Cohesion
    -> Cohesion
    -> Ordering
    forall a b. (a -> b) -> a -> b
    $ \case
        (Cohesion
    r, Cohesion
    r') | Cohesion
    r Cohesion -> Cohesion -> Bool
    forall a. Eq a => a -> a -> Bool
    == Cohesion
    r' -> Ordering
    EQ
        -- top
        (Cohesion
    _, Cohesion
    Squash) -> Ordering
    LT
        (Cohesion
    Squash, Cohesion
    _) -> Ordering
    GT
        -- bottom
        (Cohesion
    Flat, Cohesion
    _) -> Ordering
    LT
        (Cohesion
    _, Cohesion
    Flat) -> Ordering
    GT
        -- redundant case
        (Cohesion
    Continuous,Cohesion
    Continuous) -> Ordering
    EQ

    -- | Flatter is smaller.
    instance PartialOrd Cohesion where
      comparable :: Comparable Cohesion
    comparable = Comparable Cohesion
    forall a. Ord a => Comparable a
    comparableOrd

    -- | @usableCohesion rel == False@ iff we cannot use a variable of @rel@.
    usableCohesion :: LensCohesion a => a -> Bool
    usableCohesion :: forall a. LensCohesion a => a -> Bool
    usableCohesion a
    a = a -> Cohesion
    forall a. LensCohesion a => a -> Cohesion
    getCohesion a
    a Cohesion -> Cohesion -> Bool
    `moreCohesion` Cohesion
    Continuous

    -- | 'Cohesion' composition.
    --   'Squash' is dominant, 'Continuous' is neutral.
    composeCohesion :: Cohesion -> Cohesion -> Cohesion
    composeCohesion :: Cohesion -> Cohesion -> Cohesion
    composeCohesion Cohesion
    r Cohesion
    r' =
      case (Cohesion
    r, Cohesion
    r') of
        (Cohesion
    Squash, Cohesion
    _) -> Cohesion
    Squash
        (Cohesion
    _, Cohesion
    Squash) -> Cohesion
    Squash
        (Cohesion
    Flat, Cohesion
    _)  -> Cohesion
    Flat
        (Cohesion
    _, Cohesion
    Flat)  -> Cohesion
    Flat
        (Cohesion
    Continuous, Cohesion
    Continuous) -> Cohesion
    Continuous

    -- | Compose with cohesion flag from the left.
    --   This function is e.g. used to update the cohesion information
    --   on pattern variables @a@ after a match against something of cohesion @rel@.
    applyCohesion :: LensCohesion a => Cohesion -> a -> a
    applyCohesion :: forall a. LensCohesion a => Cohesion -> a -> a
    applyCohesion Cohesion
    rel = (Cohesion -> Cohesion) -> a -> a
    forall a. LensCohesion a => (Cohesion -> Cohesion) -> a -> a
    mapCohesion (Cohesion
    rel Cohesion -> Cohesion -> Cohesion
    `composeCohesion`)

    -- | @inverseComposeCohesion r x@ returns the least @y@
    --   such that forall @x@, @y@ we have
    --   @x \`moreCohesion\` (r \`composeCohesion\` y)@
    --   iff
    --   @(r \`inverseComposeCohesion\` x) \`moreCohesion\` y@ (Galois connection).
    --   The above law fails for @r = Squash@.
    inverseComposeCohesion :: Cohesion -> Cohesion -> Cohesion
    inverseComposeCohesion :: Cohesion -> Cohesion -> Cohesion
    inverseComposeCohesion Cohesion
    r Cohesion
    x =
      case (Cohesion
    r, Cohesion
    x) of
        (Cohesion
    Continuous  , Cohesion
    x) -> Cohesion
    x          -- going to continous arg.: nothing changes
                                        -- because Continuous is comp.-neutral
        (Cohesion
    Squash, Cohesion
    x)       -> Cohesion
    Flat       -- in squash position everything is usable
        (Cohesion
    Flat , Cohesion
    Flat)     -> Cohesion
    Flat       -- otherwise: Flat things remain Flat
        (Cohesion
    Flat , Cohesion
    _)        -> Cohesion
    Squash     -- but everything else becomes unusable.

    -- | Left division by a 'Cohesion'.
    --   Used e.g. to modify context when going into a @rel@ argument.
    inverseApplyCohesion :: LensCohesion a => Cohesion -> a -> a
    inverseApplyCohesion :: forall a. LensCohesion a => Cohesion -> a -> a
    inverseApplyCohesion Cohesion
    rel = (Cohesion -> Cohesion) -> a -> a
    forall a. LensCohesion a => (Cohesion -> Cohesion) -> a -> a
    mapCohesion (Cohesion
    rel Cohesion -> Cohesion -> Cohesion
    `inverseComposeCohesion`)

    -- | 'Cohesion' forms a semigroup under composition.
    instance Semigroup (UnderComposition Cohesion) where
      <> :: UnderComposition Cohesion
    -> UnderComposition Cohesion -> UnderComposition Cohesion
    (<>) = (Cohesion -> Cohesion -> Cohesion)
    -> UnderComposition Cohesion
    -> UnderComposition Cohesion
    -> UnderComposition Cohesion
    forall a b c.
    (a -> b -> c)
    -> UnderComposition a -> UnderComposition b -> UnderComposition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Cohesion -> Cohesion -> Cohesion
    composeCohesion

    -- | 'Continous' is the multiplicative unit.
    instance Monoid (UnderComposition Cohesion) where
      mempty :: UnderComposition Cohesion
    mempty  = Cohesion -> UnderComposition Cohesion
    forall a. a -> UnderComposition a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Cohesion
    unitCohesion
      mappend :: UnderComposition Cohesion
    -> UnderComposition Cohesion -> UnderComposition Cohesion
    mappend = UnderComposition Cohesion
    -> UnderComposition Cohesion -> UnderComposition Cohesion
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance POSemigroup (UnderComposition Cohesion) where
    instance POMonoid (UnderComposition Cohesion) where

    instance LeftClosedPOMonoid (UnderComposition Cohesion) where
      inverseCompose :: UnderComposition Cohesion
    -> UnderComposition Cohesion -> UnderComposition Cohesion
    inverseCompose = (Cohesion -> Cohesion -> Cohesion)
    -> UnderComposition Cohesion
    -> UnderComposition Cohesion
    -> UnderComposition Cohesion
    forall a b c.
    (a -> b -> c)
    -> UnderComposition a -> UnderComposition b -> UnderComposition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Cohesion -> Cohesion -> Cohesion
    inverseComposeCohesion

    -- | 'Cohesion' forms a semigroup under addition.
    instance Semigroup (UnderAddition Cohesion) where
      <> :: UnderAddition Cohesion
    -> UnderAddition Cohesion -> UnderAddition Cohesion
    (<>) = (Cohesion -> Cohesion -> Cohesion)
    -> UnderAddition Cohesion
    -> UnderAddition Cohesion
    -> UnderAddition Cohesion
    forall a b c.
    (a -> b -> c)
    -> UnderAddition a -> UnderAddition b -> UnderAddition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 Cohesion -> Cohesion -> Cohesion
    addCohesion

    -- | 'Squash' is the additive unit.
    instance Monoid (UnderAddition Cohesion) where
      mempty :: UnderAddition Cohesion
    mempty  = Cohesion -> UnderAddition Cohesion
    forall a. a -> UnderAddition a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Cohesion
    zeroCohesion
      mappend :: UnderAddition Cohesion
    -> UnderAddition Cohesion -> UnderAddition Cohesion
    mappend = UnderAddition Cohesion
    -> UnderAddition Cohesion -> UnderAddition Cohesion
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance POSemigroup (UnderAddition Cohesion) where
    instance POMonoid (UnderAddition Cohesion) where

    -- | Combine inferred 'Cohesion'.
    --   The unit is 'Squash'.
    addCohesion :: Cohesion -> Cohesion -> Cohesion
    addCohesion :: Cohesion -> Cohesion -> Cohesion
    addCohesion = Cohesion -> Cohesion -> Cohesion
    forall a. Ord a => a -> a -> a
    min

    -- | 'Cohesion' forms a monoid under addition, and even a semiring.
    zeroCohesion :: Cohesion
    zeroCohesion :: Cohesion
    zeroCohesion = Cohesion
    Squash

    -- | Identity under composition
    unitCohesion :: Cohesion
    unitCohesion :: Cohesion
    unitCohesion = Cohesion
    Continuous

    -- | Absorptive element under addition.
    topCohesion :: Cohesion
    topCohesion :: Cohesion
    topCohesion = Cohesion
    Flat

    -- | Default Cohesion is the identity element under composition
    defaultCohesion :: Cohesion
    defaultCohesion :: Cohesion
    defaultCohesion = Cohesion
    unitCohesion

    -- | 'null' shall mean no information, not even origin or range.
    instance Null Cohesion where
      empty :: Cohesion
    empty = Cohesion
    defaultCohesion
      null :: Cohesion -> Bool
    null = \case
        Cohesion
    Continuous -> Bool
    True
        Cohesion
    _ -> Bool
    False

    prettyCohesion :: LensCohesion a => a -> Doc -> Doc
    prettyCohesion :: forall a. LensCohesion a => a -> Doc -> Doc
    prettyCohesion a
    a = (Cohesion -> Doc
    forall a. Pretty a => a -> Doc
    pretty (a -> Cohesion
    forall a. LensCohesion a => a -> Cohesion
    getCohesion a
    a) Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+>)

    ---------------------------------------------------------------------------
    -- * Polarity
    ---------------------------------------------------------------------------

    -- | The different polarity options
    data ModalPolarity
      = UnusedPolarity    -- ^ argument will not be used.
      | StrictlyPositive  -- ^ argument will only be used in strictly positive position.
      | Positive          -- ^ argument will only be used in positive position.
      | Negative          -- ^ argument will only be used in negative position.
      | MixedPolarity     -- ^ we don't know anything, argument can be used anywhere.
        deriving (Int -> ModalPolarity -> ShowS
    [ModalPolarity] -> ShowS
    ModalPolarity -> ArgName
    (Int -> ModalPolarity -> ShowS)
    -> (ModalPolarity -> ArgName)
    -> ([ModalPolarity] -> ShowS)
    -> Show ModalPolarity
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ModalPolarity -> ShowS
    showsPrec :: Int -> ModalPolarity -> ShowS
    $cshow :: ModalPolarity -> ArgName
    show :: ModalPolarity -> ArgName
    $cshowList :: [ModalPolarity] -> ShowS
    showList :: [ModalPolarity] -> ShowS
    Show, Eq ModalPolarity
    Eq ModalPolarity =>
    (ModalPolarity -> ModalPolarity -> Ordering)
    -> (ModalPolarity -> ModalPolarity -> Bool)
    -> (ModalPolarity -> ModalPolarity -> Bool)
    -> (ModalPolarity -> ModalPolarity -> Bool)
    -> (ModalPolarity -> ModalPolarity -> Bool)
    -> (ModalPolarity -> ModalPolarity -> ModalPolarity)
    -> (ModalPolarity -> ModalPolarity -> ModalPolarity)
    -> Ord ModalPolarity
    ModalPolarity -> ModalPolarity -> Bool
    ModalPolarity -> ModalPolarity -> Ordering
    ModalPolarity -> ModalPolarity -> ModalPolarity
    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
    $ccompare :: ModalPolarity -> ModalPolarity -> Ordering
    compare :: ModalPolarity -> ModalPolarity -> Ordering
    $c< :: ModalPolarity -> ModalPolarity -> Bool
    < :: ModalPolarity -> ModalPolarity -> Bool
    $c<= :: ModalPolarity -> ModalPolarity -> Bool
    <= :: ModalPolarity -> ModalPolarity -> Bool
    $c> :: ModalPolarity -> ModalPolarity -> Bool
    > :: ModalPolarity -> ModalPolarity -> Bool
    $c>= :: ModalPolarity -> ModalPolarity -> Bool
    >= :: ModalPolarity -> ModalPolarity -> Bool
    $cmax :: ModalPolarity -> ModalPolarity -> ModalPolarity
    max :: ModalPolarity -> ModalPolarity -> ModalPolarity
    $cmin :: ModalPolarity -> ModalPolarity -> ModalPolarity
    min :: ModalPolarity -> ModalPolarity -> ModalPolarity
    Ord, Int -> ModalPolarity
    ModalPolarity -> Int
    ModalPolarity -> [ModalPolarity]
    ModalPolarity -> ModalPolarity
    ModalPolarity -> ModalPolarity -> [ModalPolarity]
    ModalPolarity -> ModalPolarity -> ModalPolarity -> [ModalPolarity]
    (ModalPolarity -> ModalPolarity)
    -> (ModalPolarity -> ModalPolarity)
    -> (Int -> ModalPolarity)
    -> (ModalPolarity -> Int)
    -> (ModalPolarity -> [ModalPolarity])
    -> (ModalPolarity -> ModalPolarity -> [ModalPolarity])
    -> (ModalPolarity -> ModalPolarity -> [ModalPolarity])
    -> (ModalPolarity
        -> ModalPolarity -> ModalPolarity -> [ModalPolarity])
    -> Enum ModalPolarity
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: ModalPolarity -> ModalPolarity
    succ :: ModalPolarity -> ModalPolarity
    $cpred :: ModalPolarity -> ModalPolarity
    pred :: ModalPolarity -> ModalPolarity
    $ctoEnum :: Int -> ModalPolarity
    toEnum :: Int -> ModalPolarity
    $cfromEnum :: ModalPolarity -> Int
    fromEnum :: ModalPolarity -> Int
    $cenumFrom :: ModalPolarity -> [ModalPolarity]
    enumFrom :: ModalPolarity -> [ModalPolarity]
    $cenumFromThen :: ModalPolarity -> ModalPolarity -> [ModalPolarity]
    enumFromThen :: ModalPolarity -> ModalPolarity -> [ModalPolarity]
    $cenumFromTo :: ModalPolarity -> ModalPolarity -> [ModalPolarity]
    enumFromTo :: ModalPolarity -> ModalPolarity -> [ModalPolarity]
    $cenumFromThenTo :: ModalPolarity -> ModalPolarity -> ModalPolarity -> [ModalPolarity]
    enumFromThenTo :: ModalPolarity -> ModalPolarity -> ModalPolarity -> [ModalPolarity]
    Enum, ModalPolarity -> ModalPolarity -> Bool
    (ModalPolarity -> ModalPolarity -> Bool)
    -> (ModalPolarity -> ModalPolarity -> Bool) -> Eq ModalPolarity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ModalPolarity -> ModalPolarity -> Bool
    == :: ModalPolarity -> ModalPolarity -> Bool
    $c/= :: ModalPolarity -> ModalPolarity -> Bool
    /= :: ModalPolarity -> ModalPolarity -> Bool
    Eq, ModalPolarity
    ModalPolarity -> ModalPolarity -> Bounded ModalPolarity
    forall a. a -> a -> Bounded a
    $cminBound :: ModalPolarity
    minBound :: ModalPolarity
    $cmaxBound :: ModalPolarity
    maxBound :: ModalPolarity
    Bounded, (forall x. ModalPolarity -> Rep ModalPolarity x)
    -> (forall x. Rep ModalPolarity x -> ModalPolarity)
    -> Generic ModalPolarity
    forall x. Rep ModalPolarity x -> ModalPolarity
    forall x. ModalPolarity -> Rep ModalPolarity x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ModalPolarity -> Rep ModalPolarity x
    from :: forall x. ModalPolarity -> Rep ModalPolarity x
    $cto :: forall x. Rep ModalPolarity x -> ModalPolarity
    to :: forall x. Rep ModalPolarity x -> ModalPolarity
    Generic)

    allModalPolarities :: [ModalPolarity]
    allModalPolarities :: [ModalPolarity]
    allModalPolarities = [ModalPolarity
    forall a. Bounded a => a
    minBound..ModalPolarity
    forall a. Bounded a => a
    maxBound]

    -- | The derived Ord instance for ModalPolarity is just used for
    --   serialisation and has no particular meaning. The actual order on
    --   modalities is a partial order.
    instance PartialOrd ModalPolarity where
      comparable :: Comparable ModalPolarity
    comparable ModalPolarity
    x ModalPolarity
    y | ModalPolarity
    x ModalPolarity -> ModalPolarity -> Bool
    forall a. Eq a => a -> a -> Bool
    == ModalPolarity
    y = PartialOrdering
    POEQ
      comparable ModalPolarity
    _ ModalPolarity
    UnusedPolarity = PartialOrdering
    POLT
      comparable ModalPolarity
    UnusedPolarity ModalPolarity
    _ = PartialOrdering
    POGT
      comparable ModalPolarity
    _ ModalPolarity
    MixedPolarity = PartialOrdering
    POGT
      comparable ModalPolarity
    MixedPolarity ModalPolarity
    _ = PartialOrdering
    POLT
      comparable ModalPolarity
    _ ModalPolarity
    Negative = PartialOrdering
    POAny
      comparable ModalPolarity
    Negative ModalPolarity
    _ = PartialOrdering
    POAny
      comparable ModalPolarity
    Positive ModalPolarity
    StrictlyPositive = PartialOrdering
    POLT
      comparable ModalPolarity
    StrictlyPositive ModalPolarity
    Positive = PartialOrdering
    POGT
      comparable ModalPolarity
    _ ModalPolarity
    _ = PartialOrdering
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    instance Pretty ModalPolarity where
      pretty :: ModalPolarity -> Doc
    pretty ModalPolarity
    p = case ModalPolarity
    p of
        ModalPolarity
    UnusedPolarity -> Doc
    "@unused"
        ModalPolarity
    StrictlyPositive -> Doc
    "@++"
        ModalPolarity
    Positive -> Doc
    "@+"
        ModalPolarity
    Negative -> Doc
    "@-"
        ModalPolarity
    MixedPolarity -> Doc
    forall a. Monoid a => a
    mempty

    -- | @morePolarity' x y@ is True whenever a variable of polarity x can be
    --   used anywhere where a variable of polarity y is expected.
    --   Note that @morePolarity' x y@ actually means x <= y.
    morePolarity' :: ModalPolarity -> ModalPolarity -> Bool
    morePolarity' :: ModalPolarity -> ModalPolarity -> Bool
    morePolarity' ModalPolarity
    x ModalPolarity
    y = case Comparable ModalPolarity
    forall a. PartialOrd a => Comparable a
    comparable ModalPolarity
    x ModalPolarity
    y of
      PartialOrdering
    POLT -> Bool
    True
      PartialOrdering
    POLE -> Bool
    True
      PartialOrdering
    POEQ -> Bool
    True
      PartialOrdering
    _    -> Bool
    False

    -- | @splittablePolarity pol == False@ iff we cannot split on a variable of @pol@.
    splittablePolarity :: LensModalPolarity a => a -> Bool
    splittablePolarity :: forall a. LensModalPolarity a => a -> Bool
    splittablePolarity a
    a = PolarityModality -> ModalPolarity
    modPolarityAnn (a -> PolarityModality
    forall a. LensModalPolarity a => a -> PolarityModality
    getModalPolarity a
    a) ModalPolarity -> ModalPolarity -> Bool
    `morePolarity'` ModalPolarity
    MixedPolarity

    -- | 'ModalPolarity' composition.
    --   'UnusedPolarity' is dominant, 'StrictlyPositive' is neutral.
    composePolarity' :: ModalPolarity -> ModalPolarity -> ModalPolarity
    composePolarity' :: ModalPolarity -> ModalPolarity -> ModalPolarity
    composePolarity' ModalPolarity
    p ModalPolarity
    p' =
      case (ModalPolarity
    p, ModalPolarity
    p') of
        (ModalPolarity
    UnusedPolarity, ModalPolarity
    _)  -> ModalPolarity
    UnusedPolarity
        (ModalPolarity
    _, ModalPolarity
    UnusedPolarity)  -> ModalPolarity
    UnusedPolarity
        (ModalPolarity
    MixedPolarity, ModalPolarity
    _)   -> ModalPolarity
    MixedPolarity
        (ModalPolarity
    _, ModalPolarity
    MixedPolarity)   -> ModalPolarity
    MixedPolarity
        (ModalPolarity
    Negative, ModalPolarity
    Negative) -> ModalPolarity
    Positive
        (ModalPolarity
    Negative, ModalPolarity
    _) -> ModalPolarity
    Negative
        (ModalPolarity
    _, ModalPolarity
    Negative) -> ModalPolarity
    Negative
        (ModalPolarity
    StrictlyPositive, ModalPolarity
    StrictlyPositive) -> ModalPolarity
    StrictlyPositive
        (ModalPolarity
    _, ModalPolarity
    _) -> ModalPolarity
    Positive

    -- | @inverseComposePolarity r x@ returns the least @y@
    --   such that forall @x@, @y@ we have
    --   @x \`morePolarity'\` (r \`composePolarity\` y)@
    --   iff
    --   @(r \`inverseComposePolarity\` x) \`morePolarity'\` y@ (Galois connection).
    inverseComposePolarity' :: ModalPolarity -> ModalPolarity -> ModalPolarity
    inverseComposePolarity' :: ModalPolarity -> ModalPolarity -> ModalPolarity
    inverseComposePolarity' ModalPolarity
    p ModalPolarity
    x =
      case (ModalPolarity
    p, ModalPolarity
    x) of
        (ModalPolarity
    MixedPolarity, ModalPolarity
    MixedPolarity) -> ModalPolarity
    MixedPolarity
        (ModalPolarity
    MixedPolarity, ModalPolarity
    _) -> ModalPolarity
    UnusedPolarity
        (ModalPolarity
    StrictlyPositive , ModalPolarity
    x) -> ModalPolarity
    x
        (ModalPolarity
    UnusedPolarity, ModalPolarity
    _) -> ModalPolarity
    MixedPolarity
        (ModalPolarity
    Positive, ModalPolarity
    StrictlyPositive) -> ModalPolarity
    UnusedPolarity
        (ModalPolarity
    Positive, ModalPolarity
    x) -> ModalPolarity
    x
        (ModalPolarity
    Negative, ModalPolarity
    Positive) -> ModalPolarity
    Negative
        (ModalPolarity
    Negative, ModalPolarity
    Negative) -> ModalPolarity
    Positive
        (ModalPolarity
    Negative, ModalPolarity
    MixedPolarity) -> ModalPolarity
    MixedPolarity
        (ModalPolarity
    Negative, ModalPolarity
    _) -> ModalPolarity
    UnusedPolarity

    -- | Combine inferred 'ModalPolarity'.
    --   The unit is 'UnusedPolarity'.
    addPolarity' :: ModalPolarity -> ModalPolarity -> ModalPolarity
    addPolarity' :: ModalPolarity -> ModalPolarity -> ModalPolarity
    addPolarity' ModalPolarity
    p ModalPolarity
    p' = case (ModalPolarity
    p, ModalPolarity
    p') of
      (ModalPolarity
    MixedPolarity, ModalPolarity
    _) -> ModalPolarity
    MixedPolarity
      (ModalPolarity
    _, ModalPolarity
    MixedPolarity) -> ModalPolarity
    MixedPolarity
      (ModalPolarity
    UnusedPolarity, ModalPolarity
    x) -> ModalPolarity
    x
      (ModalPolarity
    x, ModalPolarity
    UnusedPolarity) -> ModalPolarity
    x
      (ModalPolarity
    Negative, ModalPolarity
    Negative) -> ModalPolarity
    Negative
      (ModalPolarity
    Negative, ModalPolarity
    _) -> ModalPolarity
    MixedPolarity
      (ModalPolarity
    _, ModalPolarity
    Negative) -> ModalPolarity
    MixedPolarity
      (ModalPolarity
    Positive, ModalPolarity
    _) -> ModalPolarity
    Positive
      (ModalPolarity
    _, ModalPolarity
    Positive) -> ModalPolarity
    Positive
      (ModalPolarity
    StrictlyPositive, ModalPolarity
    StrictlyPositive) -> ModalPolarity
    StrictlyPositive

    data PolarityModality = PolarityModality
      { PolarityModality -> ModalPolarity
    modPolarityAnn :: ModalPolarity    -- ^ The actual polarity of the variable
      , PolarityModality -> ModalPolarity
    modPolarityOrigin :: ModalPolarity -- ^ The original polarity annotation by the user
      , PolarityModality -> ModalPolarity
    modPolarityLock :: ModalPolarity   -- ^ The locks of the variable (= composition of all denominators the variable has been left divided by)
      } deriving (Int -> PolarityModality -> ShowS
    [PolarityModality] -> ShowS
    PolarityModality -> ArgName
    (Int -> PolarityModality -> ShowS)
    -> (PolarityModality -> ArgName)
    -> ([PolarityModality] -> ShowS)
    -> Show PolarityModality
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PolarityModality -> ShowS
    showsPrec :: Int -> PolarityModality -> ShowS
    $cshow :: PolarityModality -> ArgName
    show :: PolarityModality -> ArgName
    $cshowList :: [PolarityModality] -> ShowS
    showList :: [PolarityModality] -> ShowS
    Show, Eq PolarityModality
    Eq PolarityModality =>
    (PolarityModality -> PolarityModality -> Ordering)
    -> (PolarityModality -> PolarityModality -> Bool)
    -> (PolarityModality -> PolarityModality -> Bool)
    -> (PolarityModality -> PolarityModality -> Bool)
    -> (PolarityModality -> PolarityModality -> Bool)
    -> (PolarityModality -> PolarityModality -> PolarityModality)
    -> (PolarityModality -> PolarityModality -> PolarityModality)
    -> Ord PolarityModality
    PolarityModality -> PolarityModality -> Bool
    PolarityModality -> PolarityModality -> Ordering
    PolarityModality -> PolarityModality -> PolarityModality
    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
    $ccompare :: PolarityModality -> PolarityModality -> Ordering
    compare :: PolarityModality -> PolarityModality -> Ordering
    $c< :: PolarityModality -> PolarityModality -> Bool
    < :: PolarityModality -> PolarityModality -> Bool
    $c<= :: PolarityModality -> PolarityModality -> Bool
    <= :: PolarityModality -> PolarityModality -> Bool
    $c> :: PolarityModality -> PolarityModality -> Bool
    > :: PolarityModality -> PolarityModality -> Bool
    $c>= :: PolarityModality -> PolarityModality -> Bool
    >= :: PolarityModality -> PolarityModality -> Bool
    $cmax :: PolarityModality -> PolarityModality -> PolarityModality
    max :: PolarityModality -> PolarityModality -> PolarityModality
    $cmin :: PolarityModality -> PolarityModality -> PolarityModality
    min :: PolarityModality -> PolarityModality -> PolarityModality
    Ord, PolarityModality
    PolarityModality -> PolarityModality -> Bounded PolarityModality
    forall a. a -> a -> Bounded a
    $cminBound :: PolarityModality
    minBound :: PolarityModality
    $cmaxBound :: PolarityModality
    maxBound :: PolarityModality
    Bounded, (forall x. PolarityModality -> Rep PolarityModality x)
    -> (forall x. Rep PolarityModality x -> PolarityModality)
    -> Generic PolarityModality
    forall x. Rep PolarityModality x -> PolarityModality
    forall x. PolarityModality -> Rep PolarityModality x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. PolarityModality -> Rep PolarityModality x
    from :: forall x. PolarityModality -> Rep PolarityModality x
    $cto :: forall x. Rep PolarityModality x -> PolarityModality
    to :: forall x. Rep PolarityModality x -> PolarityModality
    Generic)

    instance Eq PolarityModality where
      (PolarityModality ModalPolarity
    p ModalPolarity
    o ModalPolarity
    l) == :: PolarityModality -> PolarityModality -> Bool
    == (PolarityModality ModalPolarity
    p' ModalPolarity
    o' ModalPolarity
    l') = ModalPolarity
    p ModalPolarity -> ModalPolarity -> Bool
    forall a. Eq a => a -> a -> Bool
    == ModalPolarity
    p'

    withStandardLock :: ModalPolarity -> PolarityModality
    withStandardLock :: ModalPolarity -> PolarityModality
    withStandardLock ModalPolarity
    p = ModalPolarity -> ModalPolarity -> ModalPolarity -> PolarityModality
    PolarityModality ModalPolarity
    p ModalPolarity
    p ModalPolarity
    StrictlyPositive

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

    instance SetRange PolarityModality where
      setRange :: Range -> PolarityModality -> PolarityModality
    setRange Range
    _ = PolarityModality -> PolarityModality
    forall a. a -> a
    id

    instance KillRange PolarityModality where
      killRange :: PolarityModality -> PolarityModality
    killRange PolarityModality
    rel = PolarityModality
    rel -- no range to kill

    instance NFData PolarityModality where
      rnf :: PolarityModality -> ()
    rnf (PolarityModality ModalPolarity
    p ModalPolarity
    o ModalPolarity
    l) = ()

    instance Pretty PolarityModality where
      pretty :: PolarityModality -> Doc
    pretty (PolarityModality ModalPolarity
    p ModalPolarity
    _ ModalPolarity
    _) = ModalPolarity -> Doc
    forall a. Pretty a => a -> Doc
    pretty ModalPolarity
    p

    instance PartialOrd PolarityModality where
      comparable :: Comparable PolarityModality
    comparable (PolarityModality ModalPolarity
    p ModalPolarity
    _ ModalPolarity
    _) (PolarityModality ModalPolarity
    p' ModalPolarity
    _ ModalPolarity
    _) = Comparable ModalPolarity
    forall a. PartialOrd a => Comparable a
    comparable ModalPolarity
    p ModalPolarity
    p'

    -- | A lens to access the 'PolarityModality' attribute in data structures.
    --   Minimal implementation: @getModalPolarity@ and @mapModalPolarity@ or @LensModality@.
    class LensModalPolarity a where

      getModalPolarity :: a -> PolarityModality

      setModalPolarity :: PolarityModality -> a -> a
      setModalPolarity PolarityModality
    h = (PolarityModality -> PolarityModality) -> a -> a
    forall a.
    LensModalPolarity a =>
    (PolarityModality -> PolarityModality) -> a -> a
    mapModalPolarity (PolarityModality -> PolarityModality -> PolarityModality
    forall a b. a -> b -> a
    const PolarityModality
    h)

      mapModalPolarity :: (PolarityModality -> PolarityModality) -> a -> a

      default getModalPolarity :: LensModality a => a -> PolarityModality
      getModalPolarity = Modality -> PolarityModality
    modPolarity (Modality -> PolarityModality)
    -> (a -> Modality) -> a -> PolarityModality
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Modality
    forall a. LensModality a => a -> Modality
    getModality

      default mapModalPolarity :: LensModality a => (PolarityModality -> PolarityModality) -> a -> a
      mapModalPolarity PolarityModality -> PolarityModality
    f = (Modality -> Modality) -> a -> a
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Modality -> Modality) -> a -> a)
    -> (Modality -> Modality) -> a -> a
    forall a b. (a -> b) -> a -> b
    $ \ Modality
    ai -> Modality
    ai { modPolarity = f $ modPolarity ai }

    instance LensModalPolarity PolarityModality where
      getModalPolarity :: PolarityModality -> PolarityModality
    getModalPolarity = PolarityModality -> PolarityModality
    forall a. a -> a
    id
      setModalPolarity :: PolarityModality -> PolarityModality -> PolarityModality
    setModalPolarity = PolarityModality -> PolarityModality -> PolarityModality
    forall a b. a -> b -> a
    const
      mapModalPolarity :: (PolarityModality -> PolarityModality)
    -> PolarityModality -> PolarityModality
    mapModalPolarity = (PolarityModality -> PolarityModality)
    -> PolarityModality -> PolarityModality
    forall a. a -> a
    id

    -- | Equality for polarities.
    samePolarity :: PolarityModality -> PolarityModality -> Bool
    samePolarity :: PolarityModality -> PolarityModality -> Bool
    samePolarity (PolarityModality ModalPolarity
    p ModalPolarity
    _ ModalPolarity
    _) (PolarityModality ModalPolarity
    p' ModalPolarity
    _ ModalPolarity
    _) = ModalPolarity
    p ModalPolarity -> ModalPolarity -> Bool
    forall a. Eq a => a -> a -> Bool
    == ModalPolarity
    p'

    morePolarity :: PolarityModality -> PolarityModality -> Bool
    morePolarity :: PolarityModality -> PolarityModality -> Bool
    morePolarity (PolarityModality ModalPolarity
    p ModalPolarity
    _ ModalPolarity
    _) (PolarityModality ModalPolarity
    p' ModalPolarity
    _ ModalPolarity
    _) = ModalPolarity -> ModalPolarity -> Bool
    morePolarity' ModalPolarity
    p ModalPolarity
    p'

    -- | @usablePolarity pol == False@ iff we cannot use a variable of @pol@.
    usablePolarity :: LensModalPolarity a => a -> Bool
    usablePolarity :: forall a. LensModalPolarity a => a -> Bool
    usablePolarity a
    a = PolarityModality -> ModalPolarity
    modPolarityAnn PolarityModality
    pol ModalPolarity -> ModalPolarity -> Bool
    `morePolarity'` ModalPolarity
    StrictlyPositive
      where
        pol :: PolarityModality
    pol = a -> PolarityModality
    forall a. LensModalPolarity a => a -> PolarityModality
    getModalPolarity a
    a

    -- | 'PolarityModality' composition.
    --
    composePolarity :: PolarityModality -> PolarityModality -> PolarityModality
    composePolarity :: PolarityModality -> PolarityModality -> PolarityModality
    composePolarity (PolarityModality ModalPolarity
    p ModalPolarity
    o ModalPolarity
    l) (PolarityModality ModalPolarity
    p' ModalPolarity
    o' ModalPolarity
    l') =
      ModalPolarity -> ModalPolarity -> ModalPolarity -> PolarityModality
    PolarityModality (ModalPolarity -> ModalPolarity -> ModalPolarity
    composePolarity' ModalPolarity
    p ModalPolarity
    p') ModalPolarity
    o' ModalPolarity
    l'

    -- | Compose with polarity flag from the left.
    --   This function is e.g. used to update the polarity information
    --   on pattern variables @a@ after a match against something of polarity @pol@.
    applyPolarity :: LensModalPolarity a => PolarityModality -> a -> a
    applyPolarity :: forall a. LensModalPolarity a => PolarityModality -> a -> a
    applyPolarity PolarityModality
    pol = (PolarityModality -> PolarityModality) -> a -> a
    forall a.
    LensModalPolarity a =>
    (PolarityModality -> PolarityModality) -> a -> a
    mapModalPolarity (PolarityModality
    pol PolarityModality -> PolarityModality -> PolarityModality
    `composePolarity`)

    -- | @inverseComposePolarity r x@ returns the least @y@
    --   such that forall @x@, @y@ we have
    --   @x \`morePolarity'\` (r \`composePolarity\` y)@
    --   iff
    --   @(r \`inverseComposePolarity\` x) \`morePolarity'\` y@ (Galois connection).
    inverseComposePolarity :: PolarityModality -> PolarityModality -> PolarityModality
    inverseComposePolarity :: PolarityModality -> PolarityModality -> PolarityModality
    inverseComposePolarity (PolarityModality ModalPolarity
    p ModalPolarity
    o ModalPolarity
    l) (PolarityModality ModalPolarity
    p' ModalPolarity
    o' ModalPolarity
    l') =
      ModalPolarity -> ModalPolarity -> ModalPolarity -> PolarityModality
    PolarityModality (ModalPolarity -> ModalPolarity -> ModalPolarity
    inverseComposePolarity' ModalPolarity
    p ModalPolarity
    p') ModalPolarity
    o' (ModalPolarity -> ModalPolarity -> ModalPolarity
    composePolarity' ModalPolarity
    l' ModalPolarity
    p)

    -- | Left division by a 'PolarityModality'.
    --   Used e.g. to modify context when going into a @pol@ argument.
    inverseApplyPolarity :: LensModalPolarity a => PolarityModality -> a -> a
    inverseApplyPolarity :: forall a. LensModalPolarity a => PolarityModality -> a -> a
    inverseApplyPolarity PolarityModality
    pol = (PolarityModality -> PolarityModality) -> a -> a
    forall a.
    LensModalPolarity a =>
    (PolarityModality -> PolarityModality) -> a -> a
    mapModalPolarity (PolarityModality
    pol PolarityModality -> PolarityModality -> PolarityModality
    `inverseComposePolarity`)

    -- | 'ModalPolarity' forms a semigroup under composition.
    instance Semigroup (UnderComposition PolarityModality) where
      <> :: UnderComposition PolarityModality
    -> UnderComposition PolarityModality
    -> UnderComposition PolarityModality
    (<>) = (PolarityModality -> PolarityModality -> PolarityModality)
    -> UnderComposition PolarityModality
    -> UnderComposition PolarityModality
    -> UnderComposition PolarityModality
    forall a b c.
    (a -> b -> c)
    -> UnderComposition a -> UnderComposition b -> UnderComposition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 PolarityModality -> PolarityModality -> PolarityModality
    composePolarity

    -- | 'Continous' is the multiplicative unit.
    instance Monoid (UnderComposition PolarityModality) where
      mempty :: UnderComposition PolarityModality
    mempty  = PolarityModality -> UnderComposition PolarityModality
    forall a. a -> UnderComposition a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure PolarityModality
    unitPolarity
      mappend :: UnderComposition PolarityModality
    -> UnderComposition PolarityModality
    -> UnderComposition PolarityModality
    mappend = UnderComposition PolarityModality
    -> UnderComposition PolarityModality
    -> UnderComposition PolarityModality
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance POSemigroup (UnderComposition PolarityModality) where
    instance POMonoid (UnderComposition PolarityModality) where

    instance LeftClosedPOMonoid (UnderComposition PolarityModality) where
      inverseCompose :: UnderComposition PolarityModality
    -> UnderComposition PolarityModality
    -> UnderComposition PolarityModality
    inverseCompose = (PolarityModality -> PolarityModality -> PolarityModality)
    -> UnderComposition PolarityModality
    -> UnderComposition PolarityModality
    -> UnderComposition PolarityModality
    forall a b c.
    (a -> b -> c)
    -> UnderComposition a -> UnderComposition b -> UnderComposition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 PolarityModality -> PolarityModality -> PolarityModality
    inverseComposePolarity

    -- | 'ModalPolarity' forms a semigroup under addition.
    instance Semigroup (UnderAddition PolarityModality) where
      <> :: UnderAddition PolarityModality
    -> UnderAddition PolarityModality -> UnderAddition PolarityModality
    (<>) = (PolarityModality -> PolarityModality -> PolarityModality)
    -> UnderAddition PolarityModality
    -> UnderAddition PolarityModality
    -> UnderAddition PolarityModality
    forall a b c.
    (a -> b -> c)
    -> UnderAddition a -> UnderAddition b -> UnderAddition c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 PolarityModality -> PolarityModality -> PolarityModality
    addPolarity

    -- | '' is the additive unit.
    instance Monoid (UnderAddition PolarityModality) where
      mempty :: UnderAddition PolarityModality
    mempty  = PolarityModality -> UnderAddition PolarityModality
    forall a. a -> UnderAddition a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure PolarityModality
    zeroPolarity
      mappend :: UnderAddition PolarityModality
    -> UnderAddition PolarityModality -> UnderAddition PolarityModality
    mappend = UnderAddition PolarityModality
    -> UnderAddition PolarityModality -> UnderAddition PolarityModality
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance POSemigroup (UnderAddition PolarityModality) where
    instance POMonoid (UnderAddition PolarityModality) where

    -- | Combine inferred 'PolarityModality'.
    --
    addPolarity :: PolarityModality -> PolarityModality -> PolarityModality
    addPolarity :: PolarityModality -> PolarityModality -> PolarityModality
    addPolarity (PolarityModality ModalPolarity
    p ModalPolarity
    o ModalPolarity
    l) (PolarityModality ModalPolarity
    p' ModalPolarity
    o' ModalPolarity
    l') =
      ModalPolarity -> ModalPolarity -> ModalPolarity -> PolarityModality
    PolarityModality (ModalPolarity -> ModalPolarity -> ModalPolarity
    addPolarity' ModalPolarity
    p ModalPolarity
    p') ModalPolarity
    o' ModalPolarity
    l'

    -- | 'ModalPolarity' forms a monoid under addition, and even a semiring.
    zeroPolarity :: PolarityModality
    zeroPolarity :: PolarityModality
    zeroPolarity = ModalPolarity -> PolarityModality
    withStandardLock ModalPolarity
    UnusedPolarity

    -- | Identity under composition.
    unitPolarity :: PolarityModality
    unitPolarity :: PolarityModality
    unitPolarity = ModalPolarity -> PolarityModality
    withStandardLock ModalPolarity
    StrictlyPositive

    -- | Alias for 'Negative' polarity.
    negativePolarity :: PolarityModality
    negativePolarity :: PolarityModality
    negativePolarity = ModalPolarity -> PolarityModality
    withStandardLock ModalPolarity
    Negative

    -- | Alias for 'Mixed' polarity.
    mixedPolarity :: PolarityModality
    mixedPolarity :: PolarityModality
    mixedPolarity = ModalPolarity -> PolarityModality
    withStandardLock ModalPolarity
    MixedPolarity

    -- | Absorptive element under addition.
    topPolarity :: PolarityModality
    topPolarity :: PolarityModality
    topPolarity = PolarityModality
    mixedPolarity

    -- | Default used when not caring about polarity
    defaultPolarity :: PolarityModality
    defaultPolarity :: PolarityModality
    defaultPolarity = PolarityModality
    mixedPolarity

    instance Null PolarityModality where
      empty :: PolarityModality
    empty = PolarityModality
    defaultPolarity

    prettyPolarity :: LensModalPolarity a => a -> Doc -> Doc
    prettyPolarity :: forall a. LensModalPolarity a => a -> Doc -> Doc
    prettyPolarity a
    a = (PolarityModality -> Doc
    forall a. Pretty a => a -> Doc
    pretty (a -> PolarityModality
    forall a. LensModalPolarity a => a -> PolarityModality
    getModalPolarity a
    a) Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+>)

    ---------------------------------------------------------------------------
    -- * Origin of arguments (user-written, inserted or reflected)
    ---------------------------------------------------------------------------

    -- | Origin of arguments.
    data Origin
      = UserWritten     -- ^ From the source file / user input.  (Preserve!)
      | Inserted        -- ^ E.g. inserted hidden arguments.
      | Reflected       -- ^ Produced by the reflection machinery.
      | CaseSplit       -- ^ Produced by an interactive case split.
      | Substitution    -- ^ Named application produced to represent a substitution. E.g. "?0 (x = n)" instead of "?0 n"
      | ExpandedPun     -- ^ An expanded hidden argument pun.
      | Generalization  -- ^ Inserted by the generalization process
      deriving (Int -> Origin -> ShowS
    [Origin] -> ShowS
    Origin -> ArgName
    (Int -> Origin -> ShowS)
    -> (Origin -> ArgName) -> ([Origin] -> ShowS) -> Show Origin
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Origin -> ShowS
    showsPrec :: Int -> Origin -> ShowS
    $cshow :: Origin -> ArgName
    show :: Origin -> ArgName
    $cshowList :: [Origin] -> ShowS
    showList :: [Origin] -> ShowS
    Show, Origin -> Origin -> Bool
    (Origin -> Origin -> Bool)
    -> (Origin -> Origin -> Bool) -> Eq Origin
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Origin -> Origin -> Bool
    == :: Origin -> Origin -> Bool
    $c/= :: Origin -> Origin -> Bool
    /= :: Origin -> Origin -> Bool
    Eq, Eq Origin
    Eq Origin =>
    (Origin -> Origin -> Ordering)
    -> (Origin -> Origin -> Bool)
    -> (Origin -> Origin -> Bool)
    -> (Origin -> Origin -> Bool)
    -> (Origin -> Origin -> Bool)
    -> (Origin -> Origin -> Origin)
    -> (Origin -> Origin -> Origin)
    -> Ord Origin
    Origin -> Origin -> Bool
    Origin -> Origin -> Ordering
    Origin -> Origin -> Origin
    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
    $ccompare :: Origin -> Origin -> Ordering
    compare :: Origin -> Origin -> Ordering
    $c< :: Origin -> Origin -> Bool
    < :: Origin -> Origin -> Bool
    $c<= :: Origin -> Origin -> Bool
    <= :: Origin -> Origin -> Bool
    $c> :: Origin -> Origin -> Bool
    > :: Origin -> Origin -> Bool
    $c>= :: Origin -> Origin -> Bool
    >= :: Origin -> Origin -> Bool
    $cmax :: Origin -> Origin -> Origin
    max :: Origin -> Origin -> Origin
    $cmin :: Origin -> Origin -> Origin
    min :: Origin -> Origin -> Origin
    Ord)

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

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

    instance NFData Origin where
      rnf :: Origin -> ()
    rnf Origin
    UserWritten = ()
      rnf Origin
    Inserted = ()
      rnf Origin
    Reflected = ()
      rnf Origin
    CaseSplit = ()
      rnf Origin
    Substitution = ()
      rnf Origin
    ExpandedPun = ()
      rnf Origin
    Generalization = ()

    -- | Decorating something with 'Origin' information.
    data WithOrigin a = WithOrigin
      { forall a. WithOrigin a -> Origin
    woOrigin :: !Origin
      , forall a. WithOrigin a -> a
    woThing  :: a
      }
      deriving (WithOrigin a -> WithOrigin a -> Bool
    (WithOrigin a -> WithOrigin a -> Bool)
    -> (WithOrigin a -> WithOrigin a -> Bool) -> Eq (WithOrigin a)
    forall a. Eq a => WithOrigin a -> WithOrigin a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => WithOrigin a -> WithOrigin a -> Bool
    == :: WithOrigin a -> WithOrigin a -> Bool
    $c/= :: forall a. Eq a => WithOrigin a -> WithOrigin a -> Bool
    /= :: WithOrigin a -> WithOrigin a -> Bool
    Eq, Eq (WithOrigin a)
    Eq (WithOrigin a) =>
    (WithOrigin a -> WithOrigin a -> Ordering)
    -> (WithOrigin a -> WithOrigin a -> Bool)
    -> (WithOrigin a -> WithOrigin a -> Bool)
    -> (WithOrigin a -> WithOrigin a -> Bool)
    -> (WithOrigin a -> WithOrigin a -> Bool)
    -> (WithOrigin a -> WithOrigin a -> WithOrigin a)
    -> (WithOrigin a -> WithOrigin a -> WithOrigin a)
    -> Ord (WithOrigin a)
    WithOrigin a -> WithOrigin a -> Bool
    WithOrigin a -> WithOrigin a -> Ordering
    WithOrigin a -> WithOrigin a -> WithOrigin 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 (WithOrigin a)
    forall a. Ord a => WithOrigin a -> WithOrigin a -> Bool
    forall a. Ord a => WithOrigin a -> WithOrigin a -> Ordering
    forall a. Ord a => WithOrigin a -> WithOrigin a -> WithOrigin a
    $ccompare :: forall a. Ord a => WithOrigin a -> WithOrigin a -> Ordering
    compare :: WithOrigin a -> WithOrigin a -> Ordering
    $c< :: forall a. Ord a => WithOrigin a -> WithOrigin a -> Bool
    < :: WithOrigin a -> WithOrigin a -> Bool
    $c<= :: forall a. Ord a => WithOrigin a -> WithOrigin a -> Bool
    <= :: WithOrigin a -> WithOrigin a -> Bool
    $c> :: forall a. Ord a => WithOrigin a -> WithOrigin a -> Bool
    > :: WithOrigin a -> WithOrigin a -> Bool
    $c>= :: forall a. Ord a => WithOrigin a -> WithOrigin a -> Bool
    >= :: WithOrigin a -> WithOrigin a -> Bool
    $cmax :: forall a. Ord a => WithOrigin a -> WithOrigin a -> WithOrigin a
    max :: WithOrigin a -> WithOrigin a -> WithOrigin a
    $cmin :: forall a. Ord a => WithOrigin a -> WithOrigin a -> WithOrigin a
    min :: WithOrigin a -> WithOrigin a -> WithOrigin a
    Ord, Int -> WithOrigin a -> ShowS
    [WithOrigin a] -> ShowS
    WithOrigin a -> ArgName
    (Int -> WithOrigin a -> ShowS)
    -> (WithOrigin a -> ArgName)
    -> ([WithOrigin a] -> ShowS)
    -> Show (WithOrigin a)
    forall a. Show a => Int -> WithOrigin a -> ShowS
    forall a. Show a => [WithOrigin a] -> ShowS
    forall a. Show a => WithOrigin a -> ArgName
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> WithOrigin a -> ShowS
    showsPrec :: Int -> WithOrigin a -> ShowS
    $cshow :: forall a. Show a => WithOrigin a -> ArgName
    show :: WithOrigin a -> ArgName
    $cshowList :: forall a. Show a => [WithOrigin a] -> ShowS
    showList :: [WithOrigin a] -> ShowS
    Show, (forall a b. (a -> b) -> WithOrigin a -> WithOrigin b)
    -> (forall a b. a -> WithOrigin b -> WithOrigin a)
    -> Functor WithOrigin
    forall a b. a -> WithOrigin b -> WithOrigin a
    forall a b. (a -> b) -> WithOrigin a -> WithOrigin b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> WithOrigin a -> WithOrigin b
    fmap :: forall a b. (a -> b) -> WithOrigin a -> WithOrigin b
    $c<$ :: forall a b. a -> WithOrigin b -> WithOrigin a
    <$ :: forall a b. a -> WithOrigin b -> WithOrigin a
    Functor, (forall m. Monoid m => WithOrigin m -> m)
    -> (forall m a. Monoid m => (a -> m) -> WithOrigin a -> m)
    -> (forall m a. Monoid m => (a -> m) -> WithOrigin a -> m)
    -> (forall a b. (a -> b -> b) -> b -> WithOrigin a -> b)
    -> (forall a b. (a -> b -> b) -> b -> WithOrigin a -> b)
    -> (forall b a. (b -> a -> b) -> b -> WithOrigin a -> b)
    -> (forall b a. (b -> a -> b) -> b -> WithOrigin a -> b)
    -> (forall a. (a -> a -> a) -> WithOrigin a -> a)
    -> (forall a. (a -> a -> a) -> WithOrigin a -> a)
    -> (forall a. WithOrigin a -> [a])
    -> (forall a. WithOrigin a -> Bool)
    -> (forall a. WithOrigin a -> Int)
    -> (forall a. Eq a => a -> WithOrigin a -> Bool)
    -> (forall a. Ord a => WithOrigin a -> a)
    -> (forall a. Ord a => WithOrigin a -> a)
    -> (forall a. Num a => WithOrigin a -> a)
    -> (forall a. Num a => WithOrigin a -> a)
    -> Foldable WithOrigin
    forall a. Eq a => a -> WithOrigin a -> Bool
    forall a. Num a => WithOrigin a -> a
    forall a. Ord a => WithOrigin a -> a
    forall m. Monoid m => WithOrigin m -> m
    forall a. WithOrigin a -> Bool
    forall a. WithOrigin a -> Int
    forall a. WithOrigin a -> [a]
    forall a. (a -> a -> a) -> WithOrigin a -> a
    forall m a. Monoid m => (a -> m) -> WithOrigin a -> m
    forall b a. (b -> a -> b) -> b -> WithOrigin a -> b
    forall a b. (a -> b -> b) -> b -> WithOrigin 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
    $cfold :: forall m. Monoid m => WithOrigin m -> m
    fold :: forall m. Monoid m => WithOrigin m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> WithOrigin a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> WithOrigin a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> WithOrigin a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> WithOrigin a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> WithOrigin a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> WithOrigin a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> WithOrigin a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> WithOrigin a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> WithOrigin a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> WithOrigin a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> WithOrigin a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> WithOrigin a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> WithOrigin a -> a
    foldr1 :: forall a. (a -> a -> a) -> WithOrigin a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> WithOrigin a -> a
    foldl1 :: forall a. (a -> a -> a) -> WithOrigin a -> a
    $ctoList :: forall a. WithOrigin a -> [a]
    toList :: forall a. WithOrigin a -> [a]
    $cnull :: forall a. WithOrigin a -> Bool
    null :: forall a. WithOrigin a -> Bool
    $clength :: forall a. WithOrigin a -> Int
    length :: forall a. WithOrigin a -> Int
    $celem :: forall a. Eq a => a -> WithOrigin a -> Bool
    elem :: forall a. Eq a => a -> WithOrigin a -> Bool
    $cmaximum :: forall a. Ord a => WithOrigin a -> a
    maximum :: forall a. Ord a => WithOrigin a -> a
    $cminimum :: forall a. Ord a => WithOrigin a -> a
    minimum :: forall a. Ord a => WithOrigin a -> a
    $csum :: forall a. Num a => WithOrigin a -> a
    sum :: forall a. Num a => WithOrigin a -> a
    $cproduct :: forall a. Num a => WithOrigin a -> a
    product :: forall a. Num a => WithOrigin a -> a
    Foldable, Functor WithOrigin
    Foldable WithOrigin
    (Functor WithOrigin, Foldable WithOrigin) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> WithOrigin a -> f (WithOrigin b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        WithOrigin (f a) -> f (WithOrigin a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> WithOrigin a -> m (WithOrigin b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        WithOrigin (m a) -> m (WithOrigin a))
    -> Traversable WithOrigin
    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 =>
    WithOrigin (m a) -> m (WithOrigin a)
    forall (f :: * -> *) a.
    Applicative f =>
    WithOrigin (f a) -> f (WithOrigin a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> WithOrigin a -> m (WithOrigin b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> WithOrigin a -> f (WithOrigin b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> WithOrigin a -> f (WithOrigin b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> WithOrigin a -> f (WithOrigin b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    WithOrigin (f a) -> f (WithOrigin a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    WithOrigin (f a) -> f (WithOrigin a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> WithOrigin a -> m (WithOrigin b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> WithOrigin a -> m (WithOrigin b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    WithOrigin (m a) -> m (WithOrigin a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    WithOrigin (m a) -> m (WithOrigin a)
    Traversable)

    instance Decoration WithOrigin where
      traverseF :: forall (m :: * -> *) a b.
    Functor m =>
    (a -> m b) -> WithOrigin a -> m (WithOrigin b)
    traverseF a -> m b
    f (WithOrigin Origin
    h a
    a) = Origin -> b -> WithOrigin b
    forall a. Origin -> a -> WithOrigin a
    WithOrigin Origin
    h (b -> WithOrigin b) -> m b -> m (WithOrigin b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> m b
    f a
    a

    instance Pretty a => Pretty (WithOrigin a) where
      prettyPrec :: Int -> WithOrigin a -> Doc
    prettyPrec Int
    p = Int -> a -> Doc
    forall a. Pretty a => Int -> a -> Doc
    prettyPrec Int
    p (a -> Doc) -> (WithOrigin a -> a) -> WithOrigin a -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . WithOrigin a -> a
    forall a. WithOrigin a -> a
    woThing

    instance HasRange a => HasRange (WithOrigin a) where
      getRange :: WithOrigin a -> Range
    getRange = a -> Range
    forall a. HasRange a => a -> Range
    getRange (a -> Range) -> (WithOrigin a -> a) -> WithOrigin a -> Range
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . WithOrigin a -> a
    forall (t :: * -> *) a. Decoration t => t a -> a
    dget

    instance SetRange a => SetRange (WithOrigin a) where
      setRange :: Range -> WithOrigin a -> WithOrigin a
    setRange = (a -> a) -> WithOrigin a -> WithOrigin a
    forall a b. (a -> b) -> WithOrigin a -> WithOrigin b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((a -> a) -> WithOrigin a -> WithOrigin a)
    -> (Range -> a -> a) -> Range -> WithOrigin a -> WithOrigin a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Range -> a -> a
    forall a. SetRange a => Range -> a -> a
    setRange

    instance KillRange a => KillRange (WithOrigin a) where
      killRange :: KillRangeT (WithOrigin a)
    killRange = (a -> a) -> KillRangeT (WithOrigin a)
    forall a b. (a -> b) -> WithOrigin a -> WithOrigin b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> a
    forall a. KillRange a => KillRangeT a
    killRange

    instance NFData a => NFData (WithOrigin a) where
      rnf :: WithOrigin a -> ()
    rnf (WithOrigin Origin
    _ a
    a) = a -> ()
    forall a. NFData a => a -> ()
    rnf a
    a

    -- | A lens to access the 'Origin' attribute in data structures.
    --   Minimal implementation: @getOrigin@ and @mapOrigin@ or @LensArgInfo@.

    class LensOrigin a where

      getOrigin :: a -> Origin

      setOrigin :: Origin -> a -> a
      setOrigin Origin
    o = (Origin -> Origin) -> a -> a
    forall a. LensOrigin a => (Origin -> Origin) -> a -> a
    mapOrigin (Origin -> Origin -> Origin
    forall a b. a -> b -> a
    const Origin
    o)

      mapOrigin :: (Origin -> Origin) -> a -> a

      default getOrigin :: LensArgInfo a => a -> Origin
      getOrigin = ArgInfo -> Origin
    argInfoOrigin (ArgInfo -> Origin) -> (a -> ArgInfo) -> a -> Origin
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo

      default mapOrigin :: LensArgInfo a => (Origin -> Origin) -> a -> a
      mapOrigin Origin -> Origin
    f = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a) -> (ArgInfo -> ArgInfo) -> a -> a
    forall a b. (a -> b) -> a -> b
    $ \ ArgInfo
    ai -> ArgInfo
    ai { argInfoOrigin = f $ argInfoOrigin ai }

    instance LensOrigin Origin where
      getOrigin :: Origin -> Origin
    getOrigin = Origin -> Origin
    forall a. a -> a
    id
      setOrigin :: Origin -> Origin -> Origin
    setOrigin = Origin -> Origin -> Origin
    forall a b. a -> b -> a
    const
      mapOrigin :: (Origin -> Origin) -> Origin -> Origin
    mapOrigin = (Origin -> Origin) -> Origin -> Origin
    forall a. a -> a
    id

    instance LensOrigin (WithOrigin a) where
      getOrigin :: WithOrigin a -> Origin
    getOrigin   (WithOrigin Origin
    h a
    _) = Origin
    h
      setOrigin :: Origin -> WithOrigin a -> WithOrigin a
    setOrigin Origin
    h (WithOrigin Origin
    _ a
    a) = Origin -> a -> WithOrigin a
    forall a. Origin -> a -> WithOrigin a
    WithOrigin Origin
    h a
    a
      mapOrigin :: (Origin -> Origin) -> WithOrigin a -> WithOrigin a
    mapOrigin Origin -> Origin
    f (WithOrigin Origin
    h a
    a) = Origin -> a -> WithOrigin a
    forall a. Origin -> a -> WithOrigin a
    WithOrigin (Origin -> Origin
    f Origin
    h) a
    a

    ------------------------------------------------------------------------
    -- Origin of binder names
    ------------------------------------------------------------------------

    data BinderNameOrigin
      = UserBinderName
      | InsertedBinderName
      deriving (Int -> BinderNameOrigin -> ShowS
    [BinderNameOrigin] -> ShowS
    BinderNameOrigin -> ArgName
    (Int -> BinderNameOrigin -> ShowS)
    -> (BinderNameOrigin -> ArgName)
    -> ([BinderNameOrigin] -> ShowS)
    -> Show BinderNameOrigin
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BinderNameOrigin -> ShowS
    showsPrec :: Int -> BinderNameOrigin -> ShowS
    $cshow :: BinderNameOrigin -> ArgName
    show :: BinderNameOrigin -> ArgName
    $cshowList :: [BinderNameOrigin] -> ShowS
    showList :: [BinderNameOrigin] -> ShowS
    Show, BinderNameOrigin -> BinderNameOrigin -> Bool
    (BinderNameOrigin -> BinderNameOrigin -> Bool)
    -> (BinderNameOrigin -> BinderNameOrigin -> Bool)
    -> Eq BinderNameOrigin
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BinderNameOrigin -> BinderNameOrigin -> Bool
    == :: BinderNameOrigin -> BinderNameOrigin -> Bool
    $c/= :: BinderNameOrigin -> BinderNameOrigin -> Bool
    /= :: BinderNameOrigin -> BinderNameOrigin -> Bool
    Eq, (forall x. BinderNameOrigin -> Rep BinderNameOrigin x)
    -> (forall x. Rep BinderNameOrigin x -> BinderNameOrigin)
    -> Generic BinderNameOrigin
    forall x. Rep BinderNameOrigin x -> BinderNameOrigin
    forall x. BinderNameOrigin -> Rep BinderNameOrigin x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. BinderNameOrigin -> Rep BinderNameOrigin x
    from :: forall x. BinderNameOrigin -> Rep BinderNameOrigin x
    $cto :: forall x. Rep BinderNameOrigin x -> BinderNameOrigin
    to :: forall x. Rep BinderNameOrigin x -> BinderNameOrigin
    Generic)

    instance KillRange BinderNameOrigin where
      killRange :: KillRangeT BinderNameOrigin
    killRange = \case
        BinderNameOrigin
    InsertedBinderName -> BinderNameOrigin
    InsertedBinderName
        BinderNameOrigin
    UserBinderName     -> BinderNameOrigin
    UserBinderName

    instance NFData BinderNameOrigin

    -----------------------------------------------------------------------------
    -- * Free variable annotations
    -----------------------------------------------------------------------------

    data FreeVariables = UnknownFVs | KnownFVs IntSet
      deriving (FreeVariables -> FreeVariables -> Bool
    (FreeVariables -> FreeVariables -> Bool)
    -> (FreeVariables -> FreeVariables -> Bool) -> Eq FreeVariables
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FreeVariables -> FreeVariables -> Bool
    == :: FreeVariables -> FreeVariables -> Bool
    $c/= :: FreeVariables -> FreeVariables -> Bool
    /= :: FreeVariables -> FreeVariables -> Bool
    Eq, Eq FreeVariables
    Eq FreeVariables =>
    (FreeVariables -> FreeVariables -> Ordering)
    -> (FreeVariables -> FreeVariables -> Bool)
    -> (FreeVariables -> FreeVariables -> Bool)
    -> (FreeVariables -> FreeVariables -> Bool)
    -> (FreeVariables -> FreeVariables -> Bool)
    -> (FreeVariables -> FreeVariables -> FreeVariables)
    -> (FreeVariables -> FreeVariables -> FreeVariables)
    -> Ord FreeVariables
    FreeVariables -> FreeVariables -> Bool
    FreeVariables -> FreeVariables -> Ordering
    FreeVariables -> FreeVariables -> FreeVariables
    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
    $ccompare :: FreeVariables -> FreeVariables -> Ordering
    compare :: FreeVariables -> FreeVariables -> Ordering
    $c< :: FreeVariables -> FreeVariables -> Bool
    < :: FreeVariables -> FreeVariables -> Bool
    $c<= :: FreeVariables -> FreeVariables -> Bool
    <= :: FreeVariables -> FreeVariables -> Bool
    $c> :: FreeVariables -> FreeVariables -> Bool
    > :: FreeVariables -> FreeVariables -> Bool
    $c>= :: FreeVariables -> FreeVariables -> Bool
    >= :: FreeVariables -> FreeVariables -> Bool
    $cmax :: FreeVariables -> FreeVariables -> FreeVariables
    max :: FreeVariables -> FreeVariables -> FreeVariables
    $cmin :: FreeVariables -> FreeVariables -> FreeVariables
    min :: FreeVariables -> FreeVariables -> FreeVariables
    Ord, Int -> FreeVariables -> ShowS
    [FreeVariables] -> ShowS
    FreeVariables -> ArgName
    (Int -> FreeVariables -> ShowS)
    -> (FreeVariables -> ArgName)
    -> ([FreeVariables] -> ShowS)
    -> Show FreeVariables
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FreeVariables -> ShowS
    showsPrec :: Int -> FreeVariables -> ShowS
    $cshow :: FreeVariables -> ArgName
    show :: FreeVariables -> ArgName
    $cshowList :: [FreeVariables] -> ShowS
    showList :: [FreeVariables] -> ShowS
    Show)

    instance Semigroup FreeVariables where
      FreeVariables
    UnknownFVs   <> :: FreeVariables -> FreeVariables -> FreeVariables
    <> FreeVariables
    _            = FreeVariables
    UnknownFVs
      FreeVariables
    _            <> FreeVariables
    UnknownFVs   = FreeVariables
    UnknownFVs
      KnownFVs IntSet
    vs1 <> KnownFVs IntSet
    vs2 = IntSet -> FreeVariables
    KnownFVs (IntSet -> IntSet -> IntSet
    IntSet.union IntSet
    vs1 IntSet
    vs2)

    instance Monoid FreeVariables where
      mempty :: FreeVariables
    mempty  = IntSet -> FreeVariables
    KnownFVs IntSet
    IntSet.empty
      mappend :: FreeVariables -> FreeVariables -> FreeVariables
    mappend = FreeVariables -> FreeVariables -> FreeVariables
    forall a. Semigroup a => a -> a -> a
    (<>)

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

    instance NFData FreeVariables where
      rnf :: FreeVariables -> ()
    rnf FreeVariables
    UnknownFVs    = ()
      rnf (KnownFVs IntSet
    fv) = IntSet -> ()
    forall a. NFData a => a -> ()
    rnf IntSet
    fv

    unknownFreeVariables :: FreeVariables
    unknownFreeVariables :: FreeVariables
    unknownFreeVariables = FreeVariables
    UnknownFVs

    noFreeVariables :: FreeVariables
    noFreeVariables :: FreeVariables
    noFreeVariables = FreeVariables
    forall a. Monoid a => a
    mempty

    oneFreeVariable :: Int -> FreeVariables
    oneFreeVariable :: Int -> FreeVariables
    oneFreeVariable = IntSet -> FreeVariables
    KnownFVs (IntSet -> FreeVariables)
    -> (Int -> IntSet) -> Int -> FreeVariables
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> IntSet
    IntSet.singleton

    freeVariablesFromList :: [Int] -> FreeVariables
    freeVariablesFromList :: [Int] -> FreeVariables
    freeVariablesFromList = [FreeVariables] -> FreeVariables
    forall a. Monoid a => [a] -> a
    mconcat ([FreeVariables] -> FreeVariables)
    -> ([Int] -> [FreeVariables]) -> [Int] -> FreeVariables
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Int -> FreeVariables) -> [Int] -> [FreeVariables]
    forall a b. (a -> b) -> [a] -> [b]
    map Int -> FreeVariables
    oneFreeVariable

    -- | A lens to access the 'FreeVariables' attribute in data structures.
    --   Minimal implementation: @getFreeVariables@ and @mapFreeVariables@ or @LensArgInfo@.
    class LensFreeVariables a where

      getFreeVariables :: a -> FreeVariables

      setFreeVariables :: FreeVariables -> a -> a
      setFreeVariables FreeVariables
    o = (FreeVariables -> FreeVariables) -> a -> a
    forall a.
    LensFreeVariables a =>
    (FreeVariables -> FreeVariables) -> a -> a
    mapFreeVariables (FreeVariables -> FreeVariables -> FreeVariables
    forall a b. a -> b -> a
    const FreeVariables
    o)

      mapFreeVariables :: (FreeVariables -> FreeVariables) -> a -> a

      default getFreeVariables :: LensArgInfo a => a -> FreeVariables
      getFreeVariables = ArgInfo -> FreeVariables
    argInfoFreeVariables (ArgInfo -> FreeVariables) -> (a -> ArgInfo) -> a -> FreeVariables
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo

      default mapFreeVariables :: LensArgInfo a => (FreeVariables -> FreeVariables) -> a -> a
      mapFreeVariables FreeVariables -> FreeVariables
    f = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a) -> (ArgInfo -> ArgInfo) -> a -> a
    forall a b. (a -> b) -> a -> b
    $ \ ArgInfo
    ai -> ArgInfo
    ai { argInfoFreeVariables = f $ argInfoFreeVariables ai }

    instance LensFreeVariables FreeVariables where
      getFreeVariables :: FreeVariables -> FreeVariables
    getFreeVariables = FreeVariables -> FreeVariables
    forall a. a -> a
    id
      setFreeVariables :: FreeVariables -> FreeVariables -> FreeVariables
    setFreeVariables = FreeVariables -> FreeVariables -> FreeVariables
    forall a b. a -> b -> a
    const
      mapFreeVariables :: (FreeVariables -> FreeVariables) -> FreeVariables -> FreeVariables
    mapFreeVariables = (FreeVariables -> FreeVariables) -> FreeVariables -> FreeVariables
    forall a. a -> a
    id

    hasNoFreeVariables :: LensFreeVariables a => a -> Bool
    hasNoFreeVariables :: forall a. LensFreeVariables a => a -> Bool
    hasNoFreeVariables a
    x =
      case a -> FreeVariables
    forall a. LensFreeVariables a => a -> FreeVariables
    getFreeVariables a
    x of
        FreeVariables
    UnknownFVs  -> Bool
    False
        KnownFVs IntSet
    fv -> IntSet -> Bool
    IntSet.null IntSet
    fv

    ---------------------------------------------------------------------------
    -- * Argument decoration
    ---------------------------------------------------------------------------

    -- | A function argument can be hidden and/or irrelevant.

    data ArgInfo = ArgInfo
      { ArgInfo -> Hiding
    argInfoHiding        :: Hiding
      , ArgInfo -> Modality
    argInfoModality      :: Modality
      , ArgInfo -> Origin
    argInfoOrigin        :: Origin
      , ArgInfo -> FreeVariables
    argInfoFreeVariables :: FreeVariables
      , ArgInfo -> Annotation
    argInfoAnnotation    :: Annotation
        -- ^ Sometimes we want a different kind of binder/pi-type, without it
        --   supporting any of the @Modality@ interface.
      } deriving (ArgInfo -> ArgInfo -> Bool
    (ArgInfo -> ArgInfo -> Bool)
    -> (ArgInfo -> ArgInfo -> Bool) -> Eq ArgInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ArgInfo -> ArgInfo -> Bool
    == :: ArgInfo -> ArgInfo -> Bool
    $c/= :: ArgInfo -> ArgInfo -> Bool
    /= :: ArgInfo -> ArgInfo -> Bool
    Eq, Eq ArgInfo
    Eq ArgInfo =>
    (ArgInfo -> ArgInfo -> Ordering)
    -> (ArgInfo -> ArgInfo -> Bool)
    -> (ArgInfo -> ArgInfo -> Bool)
    -> (ArgInfo -> ArgInfo -> Bool)
    -> (ArgInfo -> ArgInfo -> Bool)
    -> (ArgInfo -> ArgInfo -> ArgInfo)
    -> (ArgInfo -> ArgInfo -> ArgInfo)
    -> Ord ArgInfo
    ArgInfo -> ArgInfo -> Bool
    ArgInfo -> ArgInfo -> Ordering
    ArgInfo -> ArgInfo -> ArgInfo
    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
    $ccompare :: ArgInfo -> ArgInfo -> Ordering
    compare :: ArgInfo -> ArgInfo -> Ordering
    $c< :: ArgInfo -> ArgInfo -> Bool
    < :: ArgInfo -> ArgInfo -> Bool
    $c<= :: ArgInfo -> ArgInfo -> Bool
    <= :: ArgInfo -> ArgInfo -> Bool
    $c> :: ArgInfo -> ArgInfo -> Bool
    > :: ArgInfo -> ArgInfo -> Bool
    $c>= :: ArgInfo -> ArgInfo -> Bool
    >= :: ArgInfo -> ArgInfo -> Bool
    $cmax :: ArgInfo -> ArgInfo -> ArgInfo
    max :: ArgInfo -> ArgInfo -> ArgInfo
    $cmin :: ArgInfo -> ArgInfo -> ArgInfo
    min :: ArgInfo -> ArgInfo -> ArgInfo
    Ord, Int -> ArgInfo -> ShowS
    [ArgInfo] -> ShowS
    ArgInfo -> ArgName
    (Int -> ArgInfo -> ShowS)
    -> (ArgInfo -> ArgName) -> ([ArgInfo] -> ShowS) -> Show ArgInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ArgInfo -> ShowS
    showsPrec :: Int -> ArgInfo -> ShowS
    $cshow :: ArgInfo -> ArgName
    show :: ArgInfo -> ArgName
    $cshowList :: [ArgInfo] -> ShowS
    showList :: [ArgInfo] -> ShowS
    Show)

    instance HasRange ArgInfo where
      getRange :: ArgInfo -> Range
    getRange (ArgInfo Hiding
    h Modality
    m Origin
    o FreeVariables
    _fv Annotation
    a) = (Hiding, Modality, Origin, Annotation) -> Range
    forall a. HasRange a => a -> Range
    getRange (Hiding
    h, Modality
    m, Origin
    o, Annotation
    a)

    instance KillRange ArgInfo where
      killRange :: ArgInfo -> ArgInfo
    killRange (ArgInfo Hiding
    h Modality
    m Origin
    o FreeVariables
    fv Annotation
    a) = (Hiding
     -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo)
    -> Hiding
    -> Modality
    -> Origin
    -> FreeVariables
    -> Annotation
    -> ArgInfo
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN Hiding
    -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo
    ArgInfo Hiding
    h Modality
    m Origin
    o FreeVariables
    fv Annotation
    a

    class LensArgInfo a where
      getArgInfo :: a -> ArgInfo
      setArgInfo :: ArgInfo -> a -> a
      setArgInfo ArgInfo
    ai = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo (ArgInfo -> ArgInfo -> ArgInfo
    forall a b. a -> b -> a
    const ArgInfo
    ai)
      mapArgInfo :: (ArgInfo -> ArgInfo) -> a -> a
      mapArgInfo ArgInfo -> ArgInfo
    f a
    a = ArgInfo -> a -> a
    forall a. LensArgInfo a => ArgInfo -> a -> a
    setArgInfo (ArgInfo -> ArgInfo
    f (ArgInfo -> ArgInfo) -> ArgInfo -> ArgInfo
    forall a b. (a -> b) -> a -> b
    $ a -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo a
    a) a
    a
      {-# MINIMAL getArgInfo , (setArgInfo | mapArgInfo) #-}

    instance LensArgInfo ArgInfo where
      getArgInfo :: ArgInfo -> ArgInfo
    getArgInfo = ArgInfo -> ArgInfo
    forall a. a -> a
    id
      setArgInfo :: ArgInfo -> ArgInfo -> ArgInfo
    setArgInfo = ArgInfo -> ArgInfo -> ArgInfo
    forall a b. a -> b -> a
    const
      mapArgInfo :: (ArgInfo -> ArgInfo) -> ArgInfo -> ArgInfo
    mapArgInfo = (ArgInfo -> ArgInfo) -> ArgInfo -> ArgInfo
    forall a. a -> a
    id

    instance NFData ArgInfo where
      rnf :: ArgInfo -> ()
    rnf (ArgInfo Hiding
    a Modality
    b Origin
    c FreeVariables
    d Annotation
    e) = Hiding -> ()
    forall a. NFData a => a -> ()
    rnf Hiding
    a () -> () -> ()
    forall a b. a -> b -> b
    `seq` Modality -> ()
    forall a. NFData a => a -> ()
    rnf Modality
    b () -> () -> ()
    forall a b. a -> b -> b
    `seq` Origin -> ()
    forall a. NFData a => a -> ()
    rnf Origin
    c () -> () -> ()
    forall a b. a -> b -> b
    `seq` FreeVariables -> ()
    forall a. NFData a => a -> ()
    rnf FreeVariables
    d () -> () -> ()
    forall a b. a -> b -> b
    `seq` Annotation -> ()
    forall a. NFData a => a -> ()
    rnf Annotation
    e

    instance LensHiding ArgInfo where
      getHiding :: ArgInfo -> Hiding
    getHiding = ArgInfo -> Hiding
    argInfoHiding
      setHiding :: Hiding -> ArgInfo -> ArgInfo
    setHiding Hiding
    h ArgInfo
    ai = ArgInfo
    ai { argInfoHiding = h }
      mapHiding :: (Hiding -> Hiding) -> ArgInfo -> ArgInfo
    mapHiding Hiding -> Hiding
    f ArgInfo
    ai = ArgInfo
    ai { argInfoHiding = f (argInfoHiding ai) }

    instance LensModality ArgInfo where
      getModality :: ArgInfo -> Modality
    getModality = ArgInfo -> Modality
    argInfoModality
      setModality :: Modality -> ArgInfo -> ArgInfo
    setModality Modality
    m ArgInfo
    ai = ArgInfo
    ai { argInfoModality = m }
      mapModality :: (Modality -> Modality) -> ArgInfo -> ArgInfo
    mapModality Modality -> Modality
    f ArgInfo
    ai = ArgInfo
    ai { argInfoModality = f (argInfoModality ai) }

    instance LensOrigin ArgInfo where
      getOrigin :: ArgInfo -> Origin
    getOrigin = ArgInfo -> Origin
    argInfoOrigin
      setOrigin :: Origin -> ArgInfo -> ArgInfo
    setOrigin Origin
    o ArgInfo
    ai = ArgInfo
    ai { argInfoOrigin = o }
      mapOrigin :: (Origin -> Origin) -> ArgInfo -> ArgInfo
    mapOrigin Origin -> Origin
    f ArgInfo
    ai = ArgInfo
    ai { argInfoOrigin = f (argInfoOrigin ai) }

    instance LensFreeVariables ArgInfo where
      getFreeVariables :: ArgInfo -> FreeVariables
    getFreeVariables = ArgInfo -> FreeVariables
    argInfoFreeVariables
      setFreeVariables :: FreeVariables -> ArgInfo -> ArgInfo
    setFreeVariables FreeVariables
    o ArgInfo
    ai = ArgInfo
    ai { argInfoFreeVariables = o }
      mapFreeVariables :: (FreeVariables -> FreeVariables) -> ArgInfo -> ArgInfo
    mapFreeVariables FreeVariables -> FreeVariables
    f ArgInfo
    ai = ArgInfo
    ai { argInfoFreeVariables = f (argInfoFreeVariables ai) }

    instance LensAnnotation ArgInfo where
      getAnnotation :: ArgInfo -> Annotation
    getAnnotation = ArgInfo -> Annotation
    argInfoAnnotation
      setAnnotation :: Annotation -> ArgInfo -> ArgInfo
    setAnnotation Annotation
    m ArgInfo
    ai = ArgInfo
    ai { argInfoAnnotation = m }
      mapAnnotation :: (Annotation -> Annotation) -> ArgInfo -> ArgInfo
    mapAnnotation Annotation -> Annotation
    f ArgInfo
    ai = ArgInfo
    ai { argInfoAnnotation = f (argInfoAnnotation ai) }

    -- inherited instances

    instance LensRelevance ArgInfo where
      getRelevance :: ArgInfo -> Relevance
    getRelevance = ArgInfo -> Relevance
    forall a. LensModality a => LensGet a Relevance
    getRelevanceMod
      setRelevance :: Relevance -> ArgInfo -> ArgInfo
    setRelevance = Relevance -> ArgInfo -> ArgInfo
    forall a. LensModality a => LensSet a Relevance
    setRelevanceMod
      mapRelevance :: (Relevance -> Relevance) -> ArgInfo -> ArgInfo
    mapRelevance = (Relevance -> Relevance) -> ArgInfo -> ArgInfo
    forall a. LensModality a => LensMap a Relevance
    mapRelevanceMod

    instance LensQuantity ArgInfo where
      getQuantity :: ArgInfo -> Quantity
    getQuantity = ArgInfo -> Quantity
    forall a. LensModality a => LensGet a Quantity
    getQuantityMod
      setQuantity :: Quantity -> ArgInfo -> ArgInfo
    setQuantity = Quantity -> ArgInfo -> ArgInfo
    forall a. LensModality a => LensSet a Quantity
    setQuantityMod
      mapQuantity :: (Quantity -> Quantity) -> ArgInfo -> ArgInfo
    mapQuantity = (Quantity -> Quantity) -> ArgInfo -> ArgInfo
    forall a. LensModality a => LensMap a Quantity
    mapQuantityMod

    instance LensCohesion ArgInfo where
      getCohesion :: ArgInfo -> Cohesion
    getCohesion = ArgInfo -> Cohesion
    forall a. LensModality a => LensGet a Cohesion
    getCohesionMod
      setCohesion :: Cohesion -> ArgInfo -> ArgInfo
    setCohesion = Cohesion -> ArgInfo -> ArgInfo
    forall a. LensModality a => LensSet a Cohesion
    setCohesionMod
      mapCohesion :: (Cohesion -> Cohesion) -> ArgInfo -> ArgInfo
    mapCohesion = (Cohesion -> Cohesion) -> ArgInfo -> ArgInfo
    forall a. LensModality a => LensMap a Cohesion
    mapCohesionMod

    instance LensModalPolarity ArgInfo where
      getModalPolarity :: ArgInfo -> PolarityModality
    getModalPolarity = ArgInfo -> PolarityModality
    forall a. LensModality a => LensGet a PolarityModality
    getPolarityMod
      setModalPolarity :: PolarityModality -> ArgInfo -> ArgInfo
    setModalPolarity = PolarityModality -> ArgInfo -> ArgInfo
    forall a. LensModality a => LensSet a PolarityModality
    setPolarityMod
      mapModalPolarity :: (PolarityModality -> PolarityModality) -> ArgInfo -> ArgInfo
    mapModalPolarity = (PolarityModality -> PolarityModality) -> ArgInfo -> ArgInfo
    forall a. LensModality a => LensMap a PolarityModality
    mapPolarityMod

    instance Null ArgInfo where
      empty :: ArgInfo
    empty = ArgInfo
    defaultArgInfo
      null :: ArgInfo -> Bool
    null (ArgInfo Hiding
    h Modality
    m Origin
    _o FreeVariables
    _fv Annotation
    ann) = [Bool] -> Bool
    forall (t :: * -> *). Foldable t => t Bool -> Bool
    and [ Hiding -> Bool
    forall a. Null a => a -> Bool
    null Hiding
    h, Modality -> Bool
    forall a. Null a => a -> Bool
    null Modality
    m, Annotation -> Bool
    forall a. Null a => a -> Bool
    null Annotation
    ann ]

    defaultArgInfo :: ArgInfo
    defaultArgInfo :: ArgInfo
    defaultArgInfo =  ArgInfo
      { argInfoHiding :: Hiding
    argInfoHiding        = Hiding
    NotHidden
      , argInfoModality :: Modality
    argInfoModality      = Modality
    defaultModality
      , argInfoOrigin :: Origin
    argInfoOrigin        = Origin
    UserWritten
      , argInfoFreeVariables :: FreeVariables
    argInfoFreeVariables = FreeVariables
    UnknownFVs
      , argInfoAnnotation :: Annotation
    argInfoAnnotation    = Annotation
    defaultAnnotation
      }

    defaultIrrelevantArgInfo :: ArgInfo
    defaultIrrelevantArgInfo :: ArgInfo
    defaultIrrelevantArgInfo = Relevance -> ArgInfo -> ArgInfo
    forall a. LensRelevance a => Relevance -> a -> a
    setRelevance Relevance
    irrelevant ArgInfo
    defaultArgInfo

    -- Accessing through ArgInfo

    -- default accessors for Hiding

    getHidingArgInfo :: LensArgInfo a => LensGet a Hiding
    getHidingArgInfo :: forall a. LensArgInfo a => LensGet a Hiding
    getHidingArgInfo = ArgInfo -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding (ArgInfo -> Hiding) -> (a -> ArgInfo) -> a -> Hiding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo

    setHidingArgInfo :: LensArgInfo a => LensSet a Hiding
    setHidingArgInfo :: forall a. LensArgInfo a => LensSet a Hiding
    setHidingArgInfo = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a)
    -> (Hiding -> ArgInfo -> ArgInfo) -> Hiding -> a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Hiding -> ArgInfo -> ArgInfo
    forall a. LensHiding a => Hiding -> a -> a
    setHiding

    mapHidingArgInfo :: LensArgInfo a => LensMap a Hiding
    mapHidingArgInfo :: forall a. LensArgInfo a => LensMap a Hiding
    mapHidingArgInfo = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a)
    -> ((Hiding -> Hiding) -> ArgInfo -> ArgInfo)
    -> (Hiding -> Hiding)
    -> a
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Hiding -> Hiding) -> ArgInfo -> ArgInfo
    forall a. LensHiding a => (Hiding -> Hiding) -> a -> a
    mapHiding

    -- default accessors for Modality

    getModalityArgInfo :: LensArgInfo a => LensGet a Modality
    getModalityArgInfo :: forall a. LensArgInfo a => LensGet a Modality
    getModalityArgInfo = ArgInfo -> Modality
    forall a. LensModality a => a -> Modality
    getModality (ArgInfo -> Modality) -> (a -> ArgInfo) -> a -> Modality
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo

    setModalityArgInfo :: LensArgInfo a => LensSet a Modality
    setModalityArgInfo :: forall a. LensArgInfo a => LensSet a Modality
    setModalityArgInfo = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a)
    -> (Modality -> ArgInfo -> ArgInfo) -> Modality -> a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Modality -> ArgInfo -> ArgInfo
    forall a. LensModality a => Modality -> a -> a
    setModality

    mapModalityArgInfo :: LensArgInfo a => LensMap a Modality
    mapModalityArgInfo :: forall a. LensArgInfo a => LensMap a Modality
    mapModalityArgInfo = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a)
    -> ((Modality -> Modality) -> ArgInfo -> ArgInfo)
    -> (Modality -> Modality)
    -> a
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Modality -> Modality) -> ArgInfo -> ArgInfo
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality

    -- default accessors for Origin

    getOriginArgInfo :: LensArgInfo a => LensGet a Origin
    getOriginArgInfo :: forall a. LensArgInfo a => LensGet a Origin
    getOriginArgInfo = ArgInfo -> Origin
    forall a. LensOrigin a => a -> Origin
    getOrigin (ArgInfo -> Origin) -> (a -> ArgInfo) -> a -> Origin
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo

    setOriginArgInfo :: LensArgInfo a => LensSet a Origin
    setOriginArgInfo :: forall a. LensArgInfo a => LensSet a Origin
    setOriginArgInfo = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a)
    -> (Origin -> ArgInfo -> ArgInfo) -> Origin -> a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Origin -> ArgInfo -> ArgInfo
    forall a. LensOrigin a => Origin -> a -> a
    setOrigin

    mapOriginArgInfo :: LensArgInfo a => LensMap a Origin
    mapOriginArgInfo :: forall a. LensArgInfo a => LensMap a Origin
    mapOriginArgInfo = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a)
    -> ((Origin -> Origin) -> ArgInfo -> ArgInfo)
    -> (Origin -> Origin)
    -> a
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Origin -> Origin) -> ArgInfo -> ArgInfo
    forall a. LensOrigin a => (Origin -> Origin) -> a -> a
    mapOrigin

    -- default accessors for FreeVariables

    getFreeVariablesArgInfo :: LensArgInfo a => LensGet a FreeVariables
    getFreeVariablesArgInfo :: forall a. LensArgInfo a => LensGet a FreeVariables
    getFreeVariablesArgInfo = ArgInfo -> FreeVariables
    forall a. LensFreeVariables a => a -> FreeVariables
    getFreeVariables (ArgInfo -> FreeVariables) -> (a -> ArgInfo) -> a -> FreeVariables
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo

    setFreeVariablesArgInfo :: LensArgInfo a => LensSet a FreeVariables
    setFreeVariablesArgInfo :: forall a. LensArgInfo a => LensSet a FreeVariables
    setFreeVariablesArgInfo = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a)
    -> (FreeVariables -> ArgInfo -> ArgInfo) -> FreeVariables -> a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FreeVariables -> ArgInfo -> ArgInfo
    forall a. LensFreeVariables a => FreeVariables -> a -> a
    setFreeVariables

    mapFreeVariablesArgInfo :: LensArgInfo a => LensMap a FreeVariables
    mapFreeVariablesArgInfo :: forall a. LensArgInfo a => LensMap a FreeVariables
    mapFreeVariablesArgInfo = (ArgInfo -> ArgInfo) -> a -> a
    forall a. LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a
    mapArgInfo ((ArgInfo -> ArgInfo) -> a -> a)
    -> ((FreeVariables -> FreeVariables) -> ArgInfo -> ArgInfo)
    -> (FreeVariables -> FreeVariables)
    -> a
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (FreeVariables -> FreeVariables) -> ArgInfo -> ArgInfo
    forall a.
    LensFreeVariables a =>
    (FreeVariables -> FreeVariables) -> a -> a
    mapFreeVariables

    -- inserted hidden arguments

    isInsertedHidden :: (LensHiding a, LensOrigin a) => a -> Bool
    isInsertedHidden :: forall a. (LensHiding a, LensOrigin a) => a -> Bool
    isInsertedHidden a
    a = a -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding a
    a Hiding -> Hiding -> Bool
    forall a. Eq a => a -> a -> Bool
    == Hiding
    Hidden Bool -> Bool -> Bool
    && a -> Origin
    forall a. LensOrigin a => a -> Origin
    getOrigin a
    a Origin -> Origin -> Bool
    forall a. Eq a => a -> a -> Bool
    == Origin
    Inserted

    ---------------------------------------------------------------------------
    -- * Arguments
    ---------------------------------------------------------------------------

    data Arg e  = Arg
      { forall e. Arg e -> ArgInfo
    argInfo :: ArgInfo
      , forall e. Arg e -> e
    unArg :: e
      } deriving (Arg e -> Arg e -> Bool
    (Arg e -> Arg e -> Bool) -> (Arg e -> Arg e -> Bool) -> Eq (Arg e)
    forall e. Eq e => Arg e -> Arg e -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall e. Eq e => Arg e -> Arg e -> Bool
    == :: Arg e -> Arg e -> Bool
    $c/= :: forall e. Eq e => Arg e -> Arg e -> Bool
    /= :: Arg e -> Arg e -> Bool
    Eq, Eq (Arg e)
    Eq (Arg e) =>
    (Arg e -> Arg e -> Ordering)
    -> (Arg e -> Arg e -> Bool)
    -> (Arg e -> Arg e -> Bool)
    -> (Arg e -> Arg e -> Bool)
    -> (Arg e -> Arg e -> Bool)
    -> (Arg e -> Arg e -> Arg e)
    -> (Arg e -> Arg e -> Arg e)
    -> Ord (Arg e)
    Arg e -> Arg e -> Bool
    Arg e -> Arg e -> Ordering
    Arg e -> Arg e -> Arg e
    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 e. Ord e => Eq (Arg e)
    forall e. Ord e => Arg e -> Arg e -> Bool
    forall e. Ord e => Arg e -> Arg e -> Ordering
    forall e. Ord e => Arg e -> Arg e -> Arg e
    $ccompare :: forall e. Ord e => Arg e -> Arg e -> Ordering
    compare :: Arg e -> Arg e -> Ordering
    $c< :: forall e. Ord e => Arg e -> Arg e -> Bool
    < :: Arg e -> Arg e -> Bool
    $c<= :: forall e. Ord e => Arg e -> Arg e -> Bool
    <= :: Arg e -> Arg e -> Bool
    $c> :: forall e. Ord e => Arg e -> Arg e -> Bool
    > :: Arg e -> Arg e -> Bool
    $c>= :: forall e. Ord e => Arg e -> Arg e -> Bool
    >= :: Arg e -> Arg e -> Bool
    $cmax :: forall e. Ord e => Arg e -> Arg e -> Arg e
    max :: Arg e -> Arg e -> Arg e
    $cmin :: forall e. Ord e => Arg e -> Arg e -> Arg e
    min :: Arg e -> Arg e -> Arg e
    Ord, Int -> Arg e -> ShowS
    [Arg e] -> ShowS
    Arg e -> ArgName
    (Int -> Arg e -> ShowS)
    -> (Arg e -> ArgName) -> ([Arg e] -> ShowS) -> Show (Arg e)
    forall e. Show e => Int -> Arg e -> ShowS
    forall e. Show e => [Arg e] -> ShowS
    forall e. Show e => Arg e -> ArgName
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall e. Show e => Int -> Arg e -> ShowS
    showsPrec :: Int -> Arg e -> ShowS
    $cshow :: forall e. Show e => Arg e -> ArgName
    show :: Arg e -> ArgName
    $cshowList :: forall e. Show e => [Arg e] -> ShowS
    showList :: [Arg e] -> ShowS
    Show, (forall a b. (a -> b) -> Arg a -> Arg b)
    -> (forall a b. a -> Arg b -> Arg a) -> Functor Arg
    forall a b. a -> Arg b -> Arg a
    forall a b. (a -> b) -> Arg a -> Arg b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Arg a -> Arg b
    fmap :: forall a b. (a -> b) -> Arg a -> Arg b
    $c<$ :: forall a b. a -> Arg b -> Arg a
    <$ :: forall a b. a -> Arg b -> Arg a
    Functor, (forall m. Monoid m => Arg m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Arg a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Arg a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Arg a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Arg a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Arg a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Arg a -> b)
    -> (forall a. (a -> a -> a) -> Arg a -> a)
    -> (forall a. (a -> a -> a) -> Arg a -> a)
    -> (forall a. Arg a -> [a])
    -> (forall a. Arg a -> Bool)
    -> (forall a. Arg a -> Int)
    -> (forall a. Eq a => a -> Arg a -> Bool)
    -> (forall a. Ord a => Arg a -> a)
    -> (forall a. Ord a => Arg a -> a)
    -> (forall a. Num a => Arg a -> a)
    -> (forall a. Num a => Arg a -> a)
    -> Foldable Arg
    forall a. Eq a => a -> Arg a -> Bool
    forall a. Num a => Arg a -> a
    forall a. Ord a => Arg a -> a
    forall m. Monoid m => Arg m -> m
    forall a. Arg a -> Bool
    forall a. Arg a -> Int
    forall a. Arg a -> [a]
    forall a. (a -> a -> a) -> Arg a -> a
    forall m a. Monoid m => (a -> m) -> Arg a -> m
    forall b a. (b -> a -> b) -> b -> Arg a -> b
    forall a b. (a -> b -> b) -> b -> Arg 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
    $cfold :: forall m. Monoid m => Arg m -> m
    fold :: forall m. Monoid m => Arg m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Arg a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Arg a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Arg a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Arg a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Arg a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Arg a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Arg a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Arg a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Arg a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Arg a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Arg a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Arg a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Arg a -> a
    foldr1 :: forall a. (a -> a -> a) -> Arg a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Arg a -> a
    foldl1 :: forall a. (a -> a -> a) -> Arg a -> a
    $ctoList :: forall a. Arg a -> [a]
    toList :: forall a. Arg a -> [a]
    $cnull :: forall a. Arg a -> Bool
    null :: forall a. Arg a -> Bool
    $clength :: forall a. Arg a -> Int
    length :: forall a. Arg a -> Int
    $celem :: forall a. Eq a => a -> Arg a -> Bool
    elem :: forall a. Eq a => a -> Arg a -> Bool
    $cmaximum :: forall a. Ord a => Arg a -> a
    maximum :: forall a. Ord a => Arg a -> a
    $cminimum :: forall a. Ord a => Arg a -> a
    minimum :: forall a. Ord a => Arg a -> a
    $csum :: forall a. Num a => Arg a -> a
    sum :: forall a. Num a => Arg a -> a
    $cproduct :: forall a. Num a => Arg a -> a
    product :: forall a. Num a => Arg a -> a
    Foldable, Functor Arg
    Foldable Arg
    (Functor Arg, Foldable Arg) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Arg a -> f (Arg b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Arg (f a) -> f (Arg a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Arg a -> m (Arg b))
    -> (forall (m :: * -> *) a. Monad m => Arg (m a) -> m (Arg a))
    -> Traversable Arg
    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 => Arg (m a) -> m (Arg a)
    forall (f :: * -> *) a. Applicative f => Arg (f a) -> f (Arg a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Arg a -> m (Arg b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Arg a -> f (Arg b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Arg a -> f (Arg b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Arg a -> f (Arg b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Arg (f a) -> f (Arg a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Arg (f a) -> f (Arg a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Arg a -> m (Arg b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Arg a -> m (Arg b)
    $csequence :: forall (m :: * -> *) a. Monad m => Arg (m a) -> m (Arg a)
    sequence :: forall (m :: * -> *) a. Monad m => Arg (m a) -> m (Arg a)
    Traversable)

    instance Decoration Arg where
      traverseF :: forall (m :: * -> *) a b.
    Functor m =>
    (a -> m b) -> Arg a -> m (Arg b)
    traverseF a -> m b
    f (Arg ArgInfo
    ai a
    a) = ArgInfo -> b -> Arg b
    forall e. ArgInfo -> e -> Arg e
    Arg ArgInfo
    ai (b -> Arg b) -> m b -> m (Arg b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> m b
    f a
    a

    instance HasRange a => HasRange (Arg a) where
        getRange :: Arg a -> Range
    getRange = a -> Range
    forall a. HasRange a => a -> Range
    getRange (a -> Range) -> (Arg a -> a) -> Arg a -> Range
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Arg a -> a
    forall e. Arg e -> e
    unArg

    instance SetRange a => SetRange (Arg a) where
      setRange :: Range -> Arg a -> Arg a
    setRange Range
    r = (a -> a) -> Arg a -> Arg a
    forall a b. (a -> b) -> Arg a -> Arg b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((a -> a) -> Arg a -> Arg a) -> (a -> a) -> Arg a -> Arg a
    forall a b. (a -> b) -> a -> b
    $ Range -> a -> a
    forall a. SetRange a => Range -> a -> a
    setRange Range
    r

    instance KillRange a => KillRange (Arg a) where
      killRange :: KillRangeT (Arg a)
    killRange (Arg ArgInfo
    info a
    a) = (ArgInfo -> a -> Arg a) -> ArgInfo -> a -> Arg a
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN ArgInfo -> a -> Arg a
    forall e. ArgInfo -> e -> Arg e
    Arg ArgInfo
    info a
    a

    -- Andreas, 2019-07-05, issue #3889
    -- A dedicated equality for with-abstraction now exists,
    -- thus, we can use intensional equality for Arg.
    --
    -- -- | Ignores 'Quantity', 'Relevance', 'Origin', and 'FreeVariables'.
    -- --   Ignores content of argument if 'Irrelevant'.
    -- --
    -- instance Eq a => Eq (Arg a) where
    --   Arg (ArgInfo h1 m1 _ _) x1 == Arg (ArgInfo h2 m2 _ _) x2 =
    --     h1 == h2 && (isIrrelevant m1 || isIrrelevant m2 || x1 == x2)
    --     -- Andreas, 2017-10-04, issue #2775, ignore irrelevant arguments during with-abstraction.
    --     -- This is a hack, we should not use '(==)' in with-abstraction
    --     -- and more generally not use it on Syntax.
    --     -- Andrea: except for caching.

    -- instance Show a => Show (Arg a) where
    --     show (Arg (ArgInfo h (Modality r q) o fv) a) = showFVs fv $ showQ q $ showR r $ showO o $ showH h $ show a
    --       where
    --         showH Hidden       s = "{" ++ s ++ "}"
    --         showH NotHidden    s = "(" ++ s ++ ")"
    --         showH (Instance o) s = showOv o ++ "{{" ++ s ++ "}}"
    --           where showOv YesOverlap = "overlap "
    --                 showOv NoOverlap  = ""
    --         showR r s = case r of
    --           Irrelevant      -> "." ++ s
    --           ShapeIrrelevant -> "?" ++ s
    --           Relevant        -> "r" ++ s -- Andreas: I want to see it explicitly
    --         showQ q s = case q of
    --           Quantity0   -> "0" ++ s
    --           Quantity1   -> "1" ++ s
    --           Quantityω   -> "ω" ++ s
    --         showO o s = case o of
    --           UserWritten -> "u" ++ s
    --           Inserted    -> "i" ++ s
    --           Reflected   -> "g" ++ s -- generated by reflection
    --           CaseSplit   -> "c" ++ s -- generated by case split
    --           Substitution -> "s" ++ s
    --         showFVs UnknownFVs    s = s
    --         showFVs (KnownFVs fv) s = "fv" ++ show (IntSet.toList fv) ++ s

    -- Andreas 2010-09-21: do not print relevance in general, only in function types!
    -- Andreas 2010-09-24: and in record fields
    instance Pretty a => Pretty (Arg a) where
      prettyPrec :: Int -> Arg a -> Doc
    prettyPrec Int
    p (Arg ArgInfo
    ai a
    e) = ArgInfo -> (Doc -> Doc) -> Doc -> Doc
    forall a. LensHiding a => a -> (Doc -> Doc) -> Doc -> Doc
    prettyHiding ArgInfo
    ai Doc -> Doc
    localParens (Doc -> Doc) -> Doc -> Doc
    forall a b. (a -> b) -> a -> b
    $ Int -> a -> Doc
    forall a. Pretty a => Int -> a -> Doc
    prettyPrec Int
    p' a
    e
          where p' :: Int
    p' | ArgInfo -> Bool
    forall a. LensHiding a => a -> Bool
    visible ArgInfo
    ai = Int
    p
                   | Bool
    otherwise  = Int
    0
                localParens :: Doc -> Doc
    localParens | ArgInfo -> Origin
    forall a. LensOrigin a => a -> Origin
    getOrigin ArgInfo
    ai Origin -> Origin -> Bool
    forall a. Eq a => a -> a -> Bool
    == Origin
    Substitution = Doc -> Doc
    parens
                            | Bool
    otherwise = Doc -> Doc
    forall a. a -> a
    id

    instance NFData e => NFData (Arg e) where
      rnf :: Arg e -> ()
    rnf (Arg ArgInfo
    a e
    b) = ArgInfo -> ()
    forall a. NFData a => a -> ()
    rnf ArgInfo
    a () -> () -> ()
    forall a b. a -> b -> b
    `seq` e -> ()
    forall a. NFData a => a -> ()
    rnf e
    b

    instance LensArgInfo (Arg a) where
      getArgInfo :: Arg a -> ArgInfo
    getArgInfo        = Arg a -> ArgInfo
    forall e. Arg e -> ArgInfo
    argInfo
      setArgInfo :: ArgInfo -> Arg a -> Arg a
    setArgInfo ArgInfo
    ai Arg a
    arg = Arg a
    arg { argInfo = ai }
      mapArgInfo :: (ArgInfo -> ArgInfo) -> Arg a -> Arg a
    mapArgInfo ArgInfo -> ArgInfo
    f Arg a
    arg  = Arg a
    arg { argInfo = f $ argInfo arg }

    -- The other lenses are defined through LensArgInfo

    instance LensHiding (Arg e) where
      getHiding :: Arg e -> Hiding
    getHiding = Arg e -> Hiding
    forall a. LensArgInfo a => LensGet a Hiding
    getHidingArgInfo
      setHiding :: Hiding -> Arg e -> Arg e
    setHiding = Hiding -> Arg e -> Arg e
    forall a. LensArgInfo a => LensSet a Hiding
    setHidingArgInfo
      mapHiding :: (Hiding -> Hiding) -> Arg e -> Arg e
    mapHiding = (Hiding -> Hiding) -> Arg e -> Arg e
    forall a. LensArgInfo a => LensMap a Hiding
    mapHidingArgInfo

    instance LensModality (Arg e) where
      getModality :: Arg e -> Modality
    getModality = Arg e -> Modality
    forall a. LensArgInfo a => LensGet a Modality
    getModalityArgInfo
      setModality :: Modality -> Arg e -> Arg e
    setModality = Modality -> Arg e -> Arg e
    forall a. LensArgInfo a => LensSet a Modality
    setModalityArgInfo
      mapModality :: (Modality -> Modality) -> Arg e -> Arg e
    mapModality = (Modality -> Modality) -> Arg e -> Arg e
    forall a. LensArgInfo a => LensMap a Modality
    mapModalityArgInfo

    instance LensOrigin (Arg e) where
      getOrigin :: Arg e -> Origin
    getOrigin = Arg e -> Origin
    forall a. LensArgInfo a => LensGet a Origin
    getOriginArgInfo
      setOrigin :: Origin -> Arg e -> Arg e
    setOrigin = Origin -> Arg e -> Arg e
    forall a. LensArgInfo a => LensSet a Origin
    setOriginArgInfo
      mapOrigin :: (Origin -> Origin) -> Arg e -> Arg e
    mapOrigin = (Origin -> Origin) -> Arg e -> Arg e
    forall a. LensArgInfo a => LensMap a Origin
    mapOriginArgInfo

    instance LensFreeVariables (Arg e) where
      getFreeVariables :: Arg e -> FreeVariables
    getFreeVariables = Arg e -> FreeVariables
    forall a. LensArgInfo a => LensGet a FreeVariables
    getFreeVariablesArgInfo
      setFreeVariables :: FreeVariables -> Arg e -> Arg e
    setFreeVariables = FreeVariables -> Arg e -> Arg e
    forall a. LensArgInfo a => LensSet a FreeVariables
    setFreeVariablesArgInfo
      mapFreeVariables :: (FreeVariables -> FreeVariables) -> Arg e -> Arg e
    mapFreeVariables = (FreeVariables -> FreeVariables) -> Arg e -> Arg e
    forall a. LensArgInfo a => LensMap a FreeVariables
    mapFreeVariablesArgInfo

    -- Since we have LensModality, we get relevance and quantity by default

    instance LensRelevance (Arg e) where
      getRelevance :: Arg e -> Relevance
    getRelevance = Arg e -> Relevance
    forall a. LensModality a => LensGet a Relevance
    getRelevanceMod
      setRelevance :: Relevance -> Arg e -> Arg e
    setRelevance = Relevance -> Arg e -> Arg e
    forall a. LensModality a => LensSet a Relevance
    setRelevanceMod
      mapRelevance :: (Relevance -> Relevance) -> Arg e -> Arg e
    mapRelevance = (Relevance -> Relevance) -> Arg e -> Arg e
    forall a. LensModality a => LensMap a Relevance
    mapRelevanceMod

    instance LensQuantity (Arg e) where
      getQuantity :: Arg e -> Quantity
    getQuantity = Arg e -> Quantity
    forall a. LensModality a => LensGet a Quantity
    getQuantityMod
      setQuantity :: Quantity -> Arg e -> Arg e
    setQuantity = Quantity -> Arg e -> Arg e
    forall a. LensModality a => LensSet a Quantity
    setQuantityMod
      mapQuantity :: (Quantity -> Quantity) -> Arg e -> Arg e
    mapQuantity = (Quantity -> Quantity) -> Arg e -> Arg e
    forall a. LensModality a => LensMap a Quantity
    mapQuantityMod

    instance LensCohesion (Arg e) where
      getCohesion :: Arg e -> Cohesion
    getCohesion = Arg e -> Cohesion
    forall a. LensModality a => LensGet a Cohesion
    getCohesionMod
      setCohesion :: Cohesion -> Arg e -> Arg e
    setCohesion = Cohesion -> Arg e -> Arg e
    forall a. LensModality a => LensSet a Cohesion
    setCohesionMod
      mapCohesion :: (Cohesion -> Cohesion) -> Arg e -> Arg e
    mapCohesion = (Cohesion -> Cohesion) -> Arg e -> Arg e
    forall a. LensModality a => LensMap a Cohesion
    mapCohesionMod

    instance LensModalPolarity (Arg e) where
      getModalPolarity :: Arg e -> PolarityModality
    getModalPolarity = Arg e -> PolarityModality
    forall a. LensModality a => LensGet a PolarityModality
    getPolarityMod
      setModalPolarity :: PolarityModality -> Arg e -> Arg e
    setModalPolarity = PolarityModality -> Arg e -> Arg e
    forall a. LensModality a => LensSet a PolarityModality
    setPolarityMod
      mapModalPolarity :: (PolarityModality -> PolarityModality) -> Arg e -> Arg e
    mapModalPolarity = (PolarityModality -> PolarityModality) -> Arg e -> Arg e
    forall a. LensModality a => LensMap a PolarityModality
    mapPolarityMod

    defaultArg :: a -> Arg a
    defaultArg :: forall a. a -> Arg a
    defaultArg = ArgInfo -> a -> Arg a
    forall e. ArgInfo -> e -> Arg e
    Arg ArgInfo
    defaultArgInfo

    -- | @xs \`withArgsFrom\` args@ translates @xs@ into a list of 'Arg's,
    -- using the elements in @args@ to fill in the non-'unArg' fields.
    --
    -- Precondition: The two lists should have equal length.

    withArgsFrom :: [a] -> [Arg b] -> [Arg a]
    [a]
    xs withArgsFrom :: forall a b. [a] -> [Arg b] -> [Arg a]
    `withArgsFrom` [Arg b]
    args =
      (a -> Arg b -> Arg a) -> [a] -> [Arg b] -> [Arg a]
    forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
    zipWith (\a
    x Arg b
    arg -> (b -> a) -> Arg b -> Arg a
    forall a b. (a -> b) -> Arg a -> Arg b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (a -> b -> a
    forall a b. a -> b -> a
    const a
    x) Arg b
    arg) [a]
    xs [Arg b]
    args

    withNamedArgsFrom :: [a] -> [NamedArg b] -> [NamedArg a]
    [a]
    xs withNamedArgsFrom :: forall a b. [a] -> [NamedArg b] -> [NamedArg a]
    `withNamedArgsFrom` [NamedArg b]
    args =
      (a -> NamedArg b -> NamedArg a)
    -> [a] -> [NamedArg b] -> [NamedArg a]
    forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
    zipWith (\a
    x -> (Named NamedName b -> Named_ a) -> NamedArg b -> NamedArg a
    forall a b. (a -> b) -> Arg a -> Arg b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (a
    x a -> Named NamedName b -> Named_ a
    forall a b. a -> Named NamedName b -> Named NamedName a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$)) [a]
    xs [NamedArg b]
    args

    ---------------------------------------------------------------------------
    -- * Names
    ---------------------------------------------------------------------------

    class Eq a => Underscore a where
      underscore   :: a
      isUnderscore :: a -> Bool
      isUnderscore = (a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    == a
    forall a. Underscore a => a
    underscore)

    instance Underscore String where
      underscore :: ArgName
    underscore = ArgName
    "_"

    instance Underscore ByteString where
      underscore :: ByteString
    underscore = ArgName -> ByteString
    ByteString.pack ArgName
    forall a. Underscore a => a
    underscore

    instance Underscore Doc where
      underscore :: Doc
    underscore = ArgName -> Doc
    forall a. ArgName -> Doc a
    text ArgName
    forall a. Underscore a => a
    underscore

    ---------------------------------------------------------------------------
    -- * Named arguments
    ---------------------------------------------------------------------------

    -- | Something potentially carrying a name.
    data Named name a =
        Named { forall name a. Named name a -> Maybe name
    nameOf     :: Maybe name
              , forall name a. Named name a -> a
    namedThing :: a
              }
        deriving (Named name a -> Named name a -> Bool
    (Named name a -> Named name a -> Bool)
    -> (Named name a -> Named name a -> Bool) -> Eq (Named name a)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall name a.
    (Eq name, Eq a) =>
    Named name a -> Named name a -> Bool
    $c== :: forall name a.
    (Eq name, Eq a) =>
    Named name a -> Named name a -> Bool
    == :: Named name a -> Named name a -> Bool
    $c/= :: forall name a.
    (Eq name, Eq a) =>
    Named name a -> Named name a -> Bool
    /= :: Named name a -> Named name a -> Bool
    Eq, Eq (Named name a)
    Eq (Named name a) =>
    (Named name a -> Named name a -> Ordering)
    -> (Named name a -> Named name a -> Bool)
    -> (Named name a -> Named name a -> Bool)
    -> (Named name a -> Named name a -> Bool)
    -> (Named name a -> Named name a -> Bool)
    -> (Named name a -> Named name a -> Named name a)
    -> (Named name a -> Named name a -> Named name a)
    -> Ord (Named name a)
    Named name a -> Named name a -> Bool
    Named name a -> Named name a -> Ordering
    Named name a -> Named name a -> Named name 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 name a. (Ord name, Ord a) => Eq (Named name a)
    forall name a.
    (Ord name, Ord a) =>
    Named name a -> Named name a -> Bool
    forall name a.
    (Ord name, Ord a) =>
    Named name a -> Named name a -> Ordering
    forall name a.
    (Ord name, Ord a) =>
    Named name a -> Named name a -> Named name a
    $ccompare :: forall name a.
    (Ord name, Ord a) =>
    Named name a -> Named name a -> Ordering
    compare :: Named name a -> Named name a -> Ordering
    $c< :: forall name a.
    (Ord name, Ord a) =>
    Named name a -> Named name a -> Bool
    < :: Named name a -> Named name a -> Bool
    $c<= :: forall name a.
    (Ord name, Ord a) =>
    Named name a -> Named name a -> Bool
    <= :: Named name a -> Named name a -> Bool
    $c> :: forall name a.
    (Ord name, Ord a) =>
    Named name a -> Named name a -> Bool
    > :: Named name a -> Named name a -> Bool
    $c>= :: forall name a.
    (Ord name, Ord a) =>
    Named name a -> Named name a -> Bool
    >= :: Named name a -> Named name a -> Bool
    $cmax :: forall name a.
    (Ord name, Ord a) =>
    Named name a -> Named name a -> Named name a
    max :: Named name a -> Named name a -> Named name a
    $cmin :: forall name a.
    (Ord name, Ord a) =>
    Named name a -> Named name a -> Named name a
    min :: Named name a -> Named name a -> Named name a
    Ord, Int -> Named name a -> ShowS
    [Named name a] -> ShowS
    Named name a -> ArgName
    (Int -> Named name a -> ShowS)
    -> (Named name a -> ArgName)
    -> ([Named name a] -> ShowS)
    -> Show (Named name a)
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    forall name a. (Show name, Show a) => Int -> Named name a -> ShowS
    forall name a. (Show name, Show a) => [Named name a] -> ShowS
    forall name a. (Show name, Show a) => Named name a -> ArgName
    $cshowsPrec :: forall name a. (Show name, Show a) => Int -> Named name a -> ShowS
    showsPrec :: Int -> Named name a -> ShowS
    $cshow :: forall name a. (Show name, Show a) => Named name a -> ArgName
    show :: Named name a -> ArgName
    $cshowList :: forall name a. (Show name, Show a) => [Named name a] -> ShowS
    showList :: [Named name a] -> ShowS
    Show, (forall a b. (a -> b) -> Named name a -> Named name b)
    -> (forall a b. a -> Named name b -> Named name a)
    -> Functor (Named name)
    forall a b. a -> Named name b -> Named name a
    forall a b. (a -> b) -> Named name a -> Named name b
    forall name a b. a -> Named name b -> Named name a
    forall name a b. (a -> b) -> Named name a -> Named name b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall name a b. (a -> b) -> Named name a -> Named name b
    fmap :: forall a b. (a -> b) -> Named name a -> Named name b
    $c<$ :: forall name a b. a -> Named name b -> Named name a
    <$ :: forall a b. a -> Named name b -> Named name a
    Functor, (forall m. Monoid m => Named name m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Named name a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Named name a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Named name a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Named name a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Named name a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Named name a -> b)
    -> (forall a. (a -> a -> a) -> Named name a -> a)
    -> (forall a. (a -> a -> a) -> Named name a -> a)
    -> (forall a. Named name a -> [a])
    -> (forall a. Named name a -> Bool)
    -> (forall a. Named name a -> Int)
    -> (forall a. Eq a => a -> Named name a -> Bool)
    -> (forall a. Ord a => Named name a -> a)
    -> (forall a. Ord a => Named name a -> a)
    -> (forall a. Num a => Named name a -> a)
    -> (forall a. Num a => Named name a -> a)
    -> Foldable (Named name)
    forall a. Eq a => a -> Named name a -> Bool
    forall a. Num a => Named name a -> a
    forall a. Ord a => Named name a -> a
    forall m. Monoid m => Named name m -> m
    forall a. Named name a -> Bool
    forall a. Named name a -> Int
    forall a. Named name a -> [a]
    forall a. (a -> a -> a) -> Named name a -> a
    forall name a. Eq a => a -> Named name a -> Bool
    forall name a. Num a => Named name a -> a
    forall name a. Ord a => Named name a -> a
    forall m a. Monoid m => (a -> m) -> Named name a -> m
    forall name m. Monoid m => Named name m -> m
    forall name a. Named name a -> Bool
    forall name a. Named name a -> Int
    forall name a. Named name a -> [a]
    forall b a. (b -> a -> b) -> b -> Named name a -> b
    forall a b. (a -> b -> b) -> b -> Named name a -> b
    forall name a. (a -> a -> a) -> Named name a -> a
    forall name m a. Monoid m => (a -> m) -> Named name a -> m
    forall name b a. (b -> a -> b) -> b -> Named name a -> b
    forall name a b. (a -> b -> b) -> b -> Named name 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
    $cfold :: forall name m. Monoid m => Named name m -> m
    fold :: forall m. Monoid m => Named name m -> m
    $cfoldMap :: forall name m a. Monoid m => (a -> m) -> Named name a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Named name a -> m
    $cfoldMap' :: forall name m a. Monoid m => (a -> m) -> Named name a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Named name a -> m
    $cfoldr :: forall name a b. (a -> b -> b) -> b -> Named name a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Named name a -> b
    $cfoldr' :: forall name a b. (a -> b -> b) -> b -> Named name a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Named name a -> b
    $cfoldl :: forall name b a. (b -> a -> b) -> b -> Named name a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Named name a -> b
    $cfoldl' :: forall name b a. (b -> a -> b) -> b -> Named name a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Named name a -> b
    $cfoldr1 :: forall name a. (a -> a -> a) -> Named name a -> a
    foldr1 :: forall a. (a -> a -> a) -> Named name a -> a
    $cfoldl1 :: forall name a. (a -> a -> a) -> Named name a -> a
    foldl1 :: forall a. (a -> a -> a) -> Named name a -> a
    $ctoList :: forall name a. Named name a -> [a]
    toList :: forall a. Named name a -> [a]
    $cnull :: forall name a. Named name a -> Bool
    null :: forall a. Named name a -> Bool
    $clength :: forall name a. Named name a -> Int
    length :: forall a. Named name a -> Int
    $celem :: forall name a. Eq a => a -> Named name a -> Bool
    elem :: forall a. Eq a => a -> Named name a -> Bool
    $cmaximum :: forall name a. Ord a => Named name a -> a
    maximum :: forall a. Ord a => Named name a -> a
    $cminimum :: forall name a. Ord a => Named name a -> a
    minimum :: forall a. Ord a => Named name a -> a
    $csum :: forall name a. Num a => Named name a -> a
    sum :: forall a. Num a => Named name a -> a
    $cproduct :: forall name a. Num a => Named name a -> a
    product :: forall a. Num a => Named name a -> a
    Foldable, Functor (Named name)
    Foldable (Named name)
    (Functor (Named name), Foldable (Named name)) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Named name a -> f (Named name b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Named name (f a) -> f (Named name a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Named name a -> m (Named name b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Named name (m a) -> m (Named name a))
    -> Traversable (Named name)
    forall name. Functor (Named name)
    forall name. Foldable (Named name)
    forall name (m :: * -> *) a.
    Monad m =>
    Named name (m a) -> m (Named name a)
    forall name (f :: * -> *) a.
    Applicative f =>
    Named name (f a) -> f (Named name a)
    forall name (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Named name a -> m (Named name b)
    forall name (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Named name a -> f (Named name b)
    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 =>
    Named name (m a) -> m (Named name a)
    forall (f :: * -> *) a.
    Applicative f =>
    Named name (f a) -> f (Named name a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Named name a -> m (Named name b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Named name a -> f (Named name b)
    $ctraverse :: forall name (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Named name a -> f (Named name b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Named name a -> f (Named name b)
    $csequenceA :: forall name (f :: * -> *) a.
    Applicative f =>
    Named name (f a) -> f (Named name a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Named name (f a) -> f (Named name a)
    $cmapM :: forall name (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Named name a -> m (Named name b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Named name a -> m (Named name b)
    $csequence :: forall name (m :: * -> *) a.
    Monad m =>
    Named name (m a) -> m (Named name a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    Named name (m a) -> m (Named name a)
    Traversable)

    -- | Standard naming.
    type Named_ = Named NamedName

    -- | Standard argument names.
    type NamedName = WithOrigin (Ranged ArgName)

    -- | Equality of argument names of things modulo 'Range' and 'Origin'.
    sameName :: NamedName -> NamedName -> Bool
    sameName :: NamedName -> NamedName -> Bool
    sameName = ArgName -> ArgName -> Bool
    forall a. Eq a => a -> a -> Bool
    (==) (ArgName -> ArgName -> Bool)
    -> (NamedName -> ArgName) -> NamedName -> NamedName -> Bool
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` (Ranged ArgName -> ArgName
    forall a. Ranged a -> a
    rangedThing (Ranged ArgName -> ArgName)
    -> (NamedName -> Ranged ArgName) -> NamedName -> ArgName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NamedName -> Ranged ArgName
    forall a. WithOrigin a -> a
    woThing)

    unnamed :: a -> Named name a
    unnamed :: forall a name. a -> Named name a
    unnamed = Maybe name -> a -> Named name a
    forall name a. Maybe name -> a -> Named name a
    Named Maybe name
    forall a. Maybe a
    Nothing

    isUnnamed :: Named name a -> Maybe a
    isUnnamed :: forall name a. Named name a -> Maybe a
    isUnnamed = \case
      Named Maybe name
    Nothing a
    a -> a -> Maybe a
    forall a. a -> Maybe a
    Just a
    a
      Named Just{}  a
    a -> Maybe a
    forall a. Maybe a
    Nothing

    named :: name -> a -> Named name a
    named :: forall name a. name -> a -> Named name a
    named = Maybe name -> a -> Named name a
    forall name a. Maybe name -> a -> Named name a
    Named (Maybe name -> a -> Named name a)
    -> (name -> Maybe name) -> name -> a -> Named name a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . name -> Maybe name
    forall a. a -> Maybe a
    Just

    userNamed :: Ranged ArgName -> a -> Named_ a
    userNamed :: forall a. Ranged ArgName -> a -> Named_ a
    userNamed = Maybe NamedName -> a -> Named NamedName a
    forall name a. Maybe name -> a -> Named name a
    Named (Maybe NamedName -> a -> Named NamedName a)
    -> (Ranged ArgName -> Maybe NamedName)
    -> Ranged ArgName
    -> a
    -> Named NamedName a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NamedName -> Maybe NamedName
    forall a. a -> Maybe a
    Just (NamedName -> Maybe NamedName)
    -> (Ranged ArgName -> NamedName)
    -> Ranged ArgName
    -> Maybe NamedName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Origin -> Ranged ArgName -> NamedName
    forall a. Origin -> a -> WithOrigin a
    WithOrigin Origin
    UserWritten

    -- | Accessor/editor for the 'nameOf' component.
    class LensNamed a where
      -- | The type of the name
      type NameOf a
      lensNamed :: Lens' a (Maybe (NameOf a))

      -- Lenses lift through decorations:
      default lensNamed :: (Decoration f, LensNamed b, NameOf b ~ NameOf a, f b ~ a) => Lens' a (Maybe (NameOf a))
      lensNamed = (b -> f b) -> a -> f a
    (b -> f b) -> f b -> f (f b)
    forall (t :: * -> *) (m :: * -> *) a b.
    (Decoration t, Functor m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Functor m => (a -> m b) -> f a -> m (f b)
    traverseF ((b -> f b) -> a -> f a)
    -> ((Maybe (NameOf b) -> f (Maybe (NameOf b))) -> b -> f b)
    -> (Maybe (NameOf b) -> f (Maybe (NameOf b)))
    -> a
    -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Maybe (NameOf b) -> f (Maybe (NameOf b))) -> b -> f b
    forall a. LensNamed a => Lens' a (Maybe (NameOf a))
    Lens' b (Maybe (NameOf b))
    lensNamed

    instance LensNamed a => LensNamed (Arg a) where
      type NameOf (Arg a) = NameOf a

    instance LensNamed (Maybe a) where
      type NameOf (Maybe a) = a
      lensNamed :: Lens' (Maybe a) (Maybe (NameOf (Maybe a)))
    lensNamed = (Maybe a -> f (Maybe a)) -> Maybe a -> f (Maybe a)
    (Maybe (NameOf (Maybe a)) -> f (Maybe (NameOf (Maybe a))))
    -> Maybe a -> f (Maybe a)
    forall a. a -> a
    id

    instance LensNamed (Named name a) where
      type NameOf (Named name a) = name

      lensNamed :: Lens' (Named name a) (Maybe (NameOf (Named name a)))
    lensNamed Maybe (NameOf (Named name a)) -> f (Maybe (NameOf (Named name a)))
    f (Named Maybe name
    mn a
    a) = Maybe (NameOf (Named name a)) -> f (Maybe (NameOf (Named name a)))
    f Maybe name
    Maybe (NameOf (Named name a))
    mn f (Maybe name) -> (Maybe name -> Named name a) -> f (Named name a)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \ Maybe name
    mn' -> Maybe name -> a -> Named name a
    forall name a. Maybe name -> a -> Named name a
    Named Maybe name
    mn' a
    a

    getNameOf :: LensNamed a => a -> Maybe (NameOf a)
    getNameOf :: forall a. LensNamed a => a -> Maybe (NameOf a)
    getNameOf a
    a = a
    a a -> Lens' a (Maybe (NameOf a)) -> Maybe (NameOf a)
    forall o i. o -> Lens' o i -> i
    ^. (Maybe (NameOf a) -> f (Maybe (NameOf a))) -> a -> f a
    forall a. LensNamed a => Lens' a (Maybe (NameOf a))
    Lens' a (Maybe (NameOf a))
    lensNamed

    setNameOf :: LensNamed a => Maybe (NameOf a) -> a -> a
    setNameOf :: forall a. LensNamed a => Maybe (NameOf a) -> a -> a
    setNameOf = Lens' a (Maybe (NameOf a)) -> Maybe (NameOf a) -> a -> a
    forall o i. Lens' o i -> LensSet o i
    set (Maybe (NameOf a) -> f (Maybe (NameOf a))) -> a -> f a
    forall a. LensNamed a => Lens' a (Maybe (NameOf a))
    Lens' a (Maybe (NameOf a))
    lensNamed

    mapNameOf :: LensNamed a => (Maybe (NameOf a) -> Maybe (NameOf a)) -> a -> a
    mapNameOf :: forall a.
    LensNamed a =>
    (Maybe (NameOf a) -> Maybe (NameOf a)) -> a -> a
    mapNameOf = Lens' a (Maybe (NameOf a))
    -> (Maybe (NameOf a) -> Maybe (NameOf a)) -> a -> a
    forall o i. Lens' o i -> LensMap o i
    over (Maybe (NameOf a) -> f (Maybe (NameOf a))) -> a -> f a
    forall a. LensNamed a => Lens' a (Maybe (NameOf a))
    Lens' a (Maybe (NameOf a))
    lensNamed

    bareNameOf :: (LensNamed a, NameOf a ~ NamedName) => a -> Maybe ArgName
    bareNameOf :: forall a. (LensNamed a, NameOf a ~ NamedName) => a -> Maybe ArgName
    bareNameOf a
    a = Ranged ArgName -> ArgName
    forall a. Ranged a -> a
    rangedThing (Ranged ArgName -> ArgName)
    -> (NamedName -> Ranged ArgName) -> NamedName -> ArgName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NamedName -> Ranged ArgName
    forall a. WithOrigin a -> a
    woThing (NamedName -> ArgName) -> Maybe NamedName -> Maybe ArgName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> Maybe (NameOf a)
    forall a. LensNamed a => a -> Maybe (NameOf a)
    getNameOf a
    a

    bareNameWithDefault :: (LensNamed a, NameOf a ~ NamedName) => ArgName -> a -> ArgName
    bareNameWithDefault :: forall a.
    (LensNamed a, NameOf a ~ NamedName) =>
    ArgName -> a -> ArgName
    bareNameWithDefault ArgName
    x a
    a = ArgName -> (NamedName -> ArgName) -> Maybe NamedName -> ArgName
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe ArgName
    x (Ranged ArgName -> ArgName
    forall a. Ranged a -> a
    rangedThing (Ranged ArgName -> ArgName)
    -> (NamedName -> Ranged ArgName) -> NamedName -> ArgName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NamedName -> Ranged ArgName
    forall a. WithOrigin a -> a
    woThing) (Maybe NamedName -> ArgName) -> Maybe NamedName -> ArgName
    forall a b. (a -> b) -> a -> b
    $ a -> Maybe (NameOf a)
    forall a. LensNamed a => a -> Maybe (NameOf a)
    getNameOf a
    a

    -- | Equality of argument names of things modulo 'Range' and 'Origin'.
    namedSame :: (LensNamed a, LensNamed b, NameOf a ~ NamedName, NameOf b ~ NamedName) => a -> b -> Bool
    namedSame :: forall a b.
    (LensNamed a, LensNamed b, NameOf a ~ NamedName,
     NameOf b ~ NamedName) =>
    a -> b -> Bool
    namedSame a
    a b
    b = case (a -> Maybe (NameOf a)
    forall a. LensNamed a => a -> Maybe (NameOf a)
    getNameOf a
    a, b -> Maybe (NameOf b)
    forall a. LensNamed a => a -> Maybe (NameOf a)
    getNameOf b
    b) of
      (Maybe NamedName
    Nothing, Maybe NamedName
    Nothing) -> Bool
    True
      (Just NamedName
    x , Just NamedName
    y ) -> NamedName -> NamedName -> Bool
    sameName NamedName
    x NamedName
    y
      (Maybe NamedName, Maybe NamedName)
    _ -> Bool
    False

    -- | Does an argument @arg@ fit the shape @dom@ of the next expected argument?
    --
    --   The hiding has to match, and if the argument has a name, it should match
    --   the name of the domain.
    --
    --   'Nothing' should be '__IMPOSSIBLE__', so use as
    --   @@
    --     fromMaybe __IMPOSSIBLE__ $ fittingNamedArg arg dom
    --   @@
    --
    fittingNamedArg
      :: ( LensNamed arg, NameOf arg ~ NamedName, LensHiding arg
         , LensNamed dom, NameOf dom ~ NamedName, LensHiding dom )
      => arg -> dom -> Maybe Bool
    fittingNamedArg :: forall arg dom.
    (LensNamed arg, NameOf arg ~ NamedName, LensHiding arg,
     LensNamed dom, NameOf dom ~ NamedName, LensHiding dom) =>
    arg -> dom -> Maybe Bool
    fittingNamedArg arg
    arg dom
    dom
        | Bool -> Bool
    not (Bool -> Bool) -> Bool -> Bool
    forall a b. (a -> b) -> a -> b
    $ arg -> dom -> Bool
    forall a b. (LensHiding a, LensHiding b) => a -> b -> Bool
    sameHiding arg
    arg dom
    dom = Maybe Bool
    no
        | arg -> Bool
    forall a. LensHiding a => a -> Bool
    visible arg
    arg              = Maybe Bool
    yes
        | Bool
    otherwise =
            Maybe ArgName
    -> Maybe Bool -> (ArgName -> Maybe Bool) -> Maybe Bool
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe (arg -> Maybe ArgName
    forall a. (LensNamed a, NameOf a ~ NamedName) => a -> Maybe ArgName
    bareNameOf arg
    arg) Maybe Bool
    yes        ((ArgName -> Maybe Bool) -> Maybe Bool)
    -> (ArgName -> Maybe Bool) -> Maybe Bool
    forall a b. (a -> b) -> a -> b
    $ \ ArgName
    x ->
            Maybe ArgName
    -> Maybe Bool -> (ArgName -> Maybe Bool) -> Maybe Bool
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe (dom -> Maybe ArgName
    forall a. (LensNamed a, NameOf a ~ NamedName) => a -> Maybe ArgName
    bareNameOf dom
    dom) Maybe Bool
    forall a. Maybe a
    impossible ((ArgName -> Maybe Bool) -> Maybe Bool)
    -> (ArgName -> Maybe Bool) -> Maybe Bool
    forall a b. (a -> b) -> a -> b
    $ \ ArgName
    y ->
            Bool -> Maybe Bool
    forall a. a -> Maybe a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Bool -> Maybe Bool) -> Bool -> Maybe Bool
    forall a b. (a -> b) -> a -> b
    $ ArgName
    x ArgName -> ArgName -> Bool
    forall a. Eq a => a -> a -> Bool
    == ArgName
    y
      where
        yes :: Maybe Bool
    yes = Bool -> Maybe Bool
    forall a. a -> Maybe a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    True
        no :: Maybe Bool
    no  = Bool -> Maybe Bool
    forall a. a -> Maybe a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    False
        impossible :: Maybe a
    impossible = Maybe a
    forall a. Maybe a
    Nothing

    -- Standard instances for 'Named':

    instance Decoration (Named name) where
      traverseF :: forall (m :: * -> *) a b.
    Functor m =>
    (a -> m b) -> Named name a -> m (Named name b)
    traverseF a -> m b
    f (Named Maybe name
    n a
    a) = Maybe name -> b -> Named name b
    forall name a. Maybe name -> a -> Named name a
    Named Maybe name
    n (b -> Named name b) -> m b -> m (Named name b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> m b
    f a
    a

    instance HasRange a => HasRange (Named name a) where
        getRange :: Named name a -> Range
    getRange = a -> Range
    forall a. HasRange a => a -> Range
    getRange (a -> Range) -> (Named name a -> a) -> Named name a -> Range
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Named name a -> a
    forall name a. Named name a -> a
    namedThing

    instance SetRange a => SetRange (Named name a) where
      setRange :: Range -> Named name a -> Named name a
    setRange Range
    r = (a -> a) -> Named name a -> Named name a
    forall a b. (a -> b) -> Named name a -> Named name b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((a -> a) -> Named name a -> Named name a)
    -> (a -> a) -> Named name a -> Named name a
    forall a b. (a -> b) -> a -> b
    $ Range -> a -> a
    forall a. SetRange a => Range -> a -> a
    setRange Range
    r

    instance (KillRange name, KillRange a) => KillRange (Named name a) where
      killRange :: KillRangeT (Named name a)
    killRange (Named Maybe name
    n a
    a) = Maybe name -> a -> Named name a
    forall name a. Maybe name -> a -> Named name a
    Named (KillRangeT (Maybe name)
    forall a. KillRange a => KillRangeT a
    killRange Maybe name
    n) (KillRangeT a
    forall a. KillRange a => KillRangeT a
    killRange a
    a)

    -- instance Show a => Show (Named_ a) where
    --     show (Named Nothing a)  = show a
    --     show (Named (Just n) a) = rawNameToString (rangedThing n) ++ " = " ++ show a

    -- -- Defined in Concrete.Pretty
    -- instance Pretty a => Pretty (Named_ a) where
    --     pretty (Named Nothing a)  = pretty a
    --     pretty (Named (Just n) a) = text (rawNameToString (rangedThing n)) <+> "=" <+> pretty a

    instance (NFData name, NFData a) => NFData (Named name a) where
      rnf :: Named name a -> ()
    rnf (Named Maybe name
    a a
    b) = Maybe name -> ()
    forall a. NFData a => a -> ()
    rnf Maybe name
    a () -> () -> ()
    forall a b. a -> b -> b
    `seq` a -> ()
    forall a. NFData a => a -> ()
    rnf a
    b

    instance Pretty e => Pretty (Named_ e) where
      prettyPrec :: Int -> Named_ e -> Doc
    prettyPrec Int
    p (Named Maybe NamedName
    nm e
    e)
        | Just ArgName
    s <- Maybe NamedName -> Maybe ArgName
    forall a. (LensNamed a, NameOf a ~ NamedName) => a -> Maybe ArgName
    bareNameOf Maybe NamedName
    nm = Bool -> Doc -> Doc
    mparens (Int
    p Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    0) (Doc -> Doc) -> Doc -> Doc
    forall a b. (a -> b) -> a -> b
    $ [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    sep [ ArgName -> Doc
    forall a. ArgName -> Doc a
    text ArgName
    s Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+> Doc
    "=", e -> Doc
    forall a. Pretty a => a -> Doc
    pretty e
    e ]
        | Bool
    otherwise               = Int -> e -> Doc
    forall a. Pretty a => Int -> a -> Doc
    prettyPrec Int
    p e
    e

    -- | Only 'Hidden' arguments can have names.
    type NamedArg a = Arg (Named_ a)

    -- | Get the content of a 'NamedArg'.
    namedArg :: NamedArg a -> a
    namedArg :: forall a. NamedArg a -> a
    namedArg = Named NamedName a -> a
    forall name a. Named name a -> a
    namedThing (Named NamedName a -> a)
    -> (NamedArg a -> Named NamedName a) -> NamedArg a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NamedArg a -> Named NamedName a
    forall e. Arg e -> e
    unArg

    defaultNamedArg :: a -> NamedArg a
    defaultNamedArg :: forall a. a -> NamedArg a
    defaultNamedArg = ArgInfo -> a -> NamedArg a
    forall a. ArgInfo -> a -> NamedArg a
    unnamedArg ArgInfo
    defaultArgInfo

    unnamedArg :: ArgInfo -> a -> NamedArg a
    unnamedArg :: forall a. ArgInfo -> a -> NamedArg a
    unnamedArg ArgInfo
    info = ArgInfo -> Named_ a -> Arg (Named_ a)
    forall e. ArgInfo -> e -> Arg e
    Arg ArgInfo
    info (Named_ a -> Arg (Named_ a))
    -> (a -> Named_ a) -> a -> Arg (Named_ a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Named_ a
    forall a name. a -> Named name a
    unnamed

    -- | The functor instance for 'NamedArg' would be ambiguous,
    --   so we give it another name here.
    updateNamedArg :: (a -> b) -> NamedArg a -> NamedArg b
    updateNamedArg :: forall a b. (a -> b) -> NamedArg a -> NamedArg b
    updateNamedArg = (Named_ a -> Named_ b) -> Arg (Named_ a) -> Arg (Named_ b)
    forall a b. (a -> b) -> Arg a -> Arg b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((Named_ a -> Named_ b) -> Arg (Named_ a) -> Arg (Named_ b))
    -> ((a -> b) -> Named_ a -> Named_ b)
    -> (a -> b)
    -> Arg (Named_ a)
    -> Arg (Named_ b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> b) -> Named_ a -> Named_ b
    forall a b. (a -> b) -> Named NamedName a -> Named NamedName b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    updateNamedArgA :: Applicative f => (a -> f b) -> NamedArg a -> f (NamedArg b)
    updateNamedArgA :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> NamedArg a -> f (NamedArg b)
    updateNamedArgA = (Named_ a -> f (Named_ b)) -> Arg (Named_ a) -> f (Arg (Named_ b))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Arg a -> f (Arg b)
    traverse ((Named_ a -> f (Named_ b))
     -> Arg (Named_ a) -> f (Arg (Named_ b)))
    -> ((a -> f b) -> Named_ a -> f (Named_ b))
    -> (a -> f b)
    -> Arg (Named_ a)
    -> f (Arg (Named_ b))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> f b) -> Named_ a -> f (Named_ b)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Named NamedName a -> f (Named NamedName b)
    traverse

    -- | @setNamedArg a b = updateNamedArg (const b) a@
    setNamedArg :: NamedArg a -> b -> NamedArg b
    setNamedArg :: forall a b. NamedArg a -> b -> NamedArg b
    setNamedArg NamedArg a
    a b
    b = (b
    b b -> Named NamedName a -> Named NamedName b
    forall a b. a -> Named NamedName b -> Named NamedName a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$) (Named NamedName a -> Named NamedName b)
    -> NamedArg a -> Arg (Named NamedName b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamedArg a
    a

    -- ** ArgName

    -- | Names in binders and arguments.
    type ArgName = String

    argNameToString :: ArgName -> String
    argNameToString :: ShowS
    argNameToString = ShowS
    forall a. a -> a
    id

    stringToArgName :: String -> ArgName
    stringToArgName :: ShowS
    stringToArgName = ShowS
    forall a. a -> a
    id

    appendArgNames :: ArgName -> ArgName -> ArgName
    appendArgNames :: ArgName -> ShowS
    appendArgNames = ArgName -> ShowS
    forall a. [a] -> [a] -> [a]
    (++)

    ---------------------------------------------------------------------------
    -- * Range decoration.
    ---------------------------------------------------------------------------

    -- | Thing with range info.
    data Ranged a = Ranged
      { forall a. Ranged a -> Range
    rangeOf     :: Range
      , forall a. Ranged a -> a
    rangedThing :: a
      }
      deriving (Int -> Ranged a -> ShowS
    [Ranged a] -> ShowS
    Ranged a -> ArgName
    (Int -> Ranged a -> ShowS)
    -> (Ranged a -> ArgName)
    -> ([Ranged a] -> ShowS)
    -> Show (Ranged a)
    forall a. Show a => Int -> Ranged a -> ShowS
    forall a. Show a => [Ranged a] -> ShowS
    forall a. Show a => Ranged a -> ArgName
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> Ranged a -> ShowS
    showsPrec :: Int -> Ranged a -> ShowS
    $cshow :: forall a. Show a => Ranged a -> ArgName
    show :: Ranged a -> ArgName
    $cshowList :: forall a. Show a => [Ranged a] -> ShowS
    showList :: [Ranged a] -> ShowS
    Show, (forall a b. (a -> b) -> Ranged a -> Ranged b)
    -> (forall a b. a -> Ranged b -> Ranged a) -> Functor Ranged
    forall a b. a -> Ranged b -> Ranged a
    forall a b. (a -> b) -> Ranged a -> Ranged b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Ranged a -> Ranged b
    fmap :: forall a b. (a -> b) -> Ranged a -> Ranged b
    $c<$ :: forall a b. a -> Ranged b -> Ranged a
    <$ :: forall a b. a -> Ranged b -> Ranged a
    Functor, (forall m. Monoid m => Ranged m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Ranged a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Ranged a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Ranged a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Ranged a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Ranged a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Ranged a -> b)
    -> (forall a. (a -> a -> a) -> Ranged a -> a)
    -> (forall a. (a -> a -> a) -> Ranged a -> a)
    -> (forall a. Ranged a -> [a])
    -> (forall a. Ranged a -> Bool)
    -> (forall a. Ranged a -> Int)
    -> (forall a. Eq a => a -> Ranged a -> Bool)
    -> (forall a. Ord a => Ranged a -> a)
    -> (forall a. Ord a => Ranged a -> a)
    -> (forall a. Num a => Ranged a -> a)
    -> (forall a. Num a => Ranged a -> a)
    -> Foldable Ranged
    forall a. Eq a => a -> Ranged a -> Bool
    forall a. Num a => Ranged a -> a
    forall a. Ord a => Ranged a -> a
    forall m. Monoid m => Ranged m -> m
    forall a. Ranged a -> Bool
    forall a. Ranged a -> Int
    forall a. Ranged a -> [a]
    forall a. (a -> a -> a) -> Ranged a -> a
    forall m a. Monoid m => (a -> m) -> Ranged a -> m
    forall b a. (b -> a -> b) -> b -> Ranged a -> b
    forall a b. (a -> b -> b) -> b -> Ranged 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
    $cfold :: forall m. Monoid m => Ranged m -> m
    fold :: forall m. Monoid m => Ranged m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Ranged a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Ranged a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Ranged a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Ranged a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Ranged a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Ranged a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Ranged a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Ranged a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Ranged a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Ranged a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Ranged a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Ranged a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Ranged a -> a
    foldr1 :: forall a. (a -> a -> a) -> Ranged a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Ranged a -> a
    foldl1 :: forall a. (a -> a -> a) -> Ranged a -> a
    $ctoList :: forall a. Ranged a -> [a]
    toList :: forall a. Ranged a -> [a]
    $cnull :: forall a. Ranged a -> Bool
    null :: forall a. Ranged a -> Bool
    $clength :: forall a. Ranged a -> Int
    length :: forall a. Ranged a -> Int
    $celem :: forall a. Eq a => a -> Ranged a -> Bool
    elem :: forall a. Eq a => a -> Ranged a -> Bool
    $cmaximum :: forall a. Ord a => Ranged a -> a
    maximum :: forall a. Ord a => Ranged a -> a
    $cminimum :: forall a. Ord a => Ranged a -> a
    minimum :: forall a. Ord a => Ranged a -> a
    $csum :: forall a. Num a => Ranged a -> a
    sum :: forall a. Num a => Ranged a -> a
    $cproduct :: forall a. Num a => Ranged a -> a
    product :: forall a. Num a => Ranged a -> a
    Foldable, Functor Ranged
    Foldable Ranged
    (Functor Ranged, Foldable Ranged) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Ranged a -> f (Ranged b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Ranged (f a) -> f (Ranged a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Ranged a -> m (Ranged b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Ranged (m a) -> m (Ranged a))
    -> Traversable Ranged
    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 => Ranged (m a) -> m (Ranged a)
    forall (f :: * -> *) a.
    Applicative f =>
    Ranged (f a) -> f (Ranged a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Ranged a -> m (Ranged b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Ranged a -> f (Ranged b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Ranged a -> f (Ranged b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Ranged a -> f (Ranged b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Ranged (f a) -> f (Ranged a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Ranged (f a) -> f (Ranged a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Ranged a -> m (Ranged b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Ranged a -> m (Ranged b)
    $csequence :: forall (m :: * -> *) a. Monad m => Ranged (m a) -> m (Ranged a)
    sequence :: forall (m :: * -> *) a. Monad m => Ranged (m a) -> m (Ranged a)
    Traversable)

    -- | Thing with no range info.
    unranged :: a -> Ranged a
    unranged :: forall a. a -> Ranged a
    unranged = Range -> a -> Ranged a
    forall a. Range -> a -> Ranged a
    Ranged Range
    forall a. Range' a
    noRange

    -- | Ignores range.
    instance Pretty a => Pretty (Ranged a) where
      pretty :: Ranged a -> Doc
    pretty = a -> Doc
    forall a. Pretty a => a -> Doc
    pretty (a -> Doc) -> (Ranged a -> a) -> Ranged a -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Ranged a -> a
    forall a. Ranged a -> a
    rangedThing

    -- | Ignores range.
    instance Eq a => Eq (Ranged a) where
      == :: Ranged a -> Ranged a -> Bool
    (==) = a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    (==) (a -> a -> Bool) -> (Ranged a -> a) -> Ranged a -> Ranged a -> Bool
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` Ranged a -> a
    forall a. Ranged a -> a
    rangedThing

    -- | Ignores range.
    instance Ord a => Ord (Ranged a) where
      compare :: Ranged a -> Ranged a -> Ordering
    compare = a -> a -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare (a -> a -> Ordering)
    -> (Ranged a -> a) -> Ranged a -> Ranged a -> Ordering
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` Ranged a -> a
    forall a. Ranged a -> a
    rangedThing

    instance HasRange (Ranged a) where
      getRange :: Ranged a -> Range
    getRange = Ranged a -> Range
    forall a. Ranged a -> Range
    rangeOf

    instance KillRange (Ranged a) where
      killRange :: KillRangeT (Ranged a)
    killRange (Ranged Range
    _ a
    x) = Range -> a -> Ranged a
    forall a. Range -> a -> Ranged a
    Ranged Range
    forall a. Range' a
    noRange a
    x

    instance Decoration Ranged where
      traverseF :: forall (m :: * -> *) a b.
    Functor m =>
    (a -> m b) -> Ranged a -> m (Ranged b)
    traverseF a -> m b
    f (Ranged Range
    r a
    x) = Range -> b -> Ranged b
    forall a. Range -> a -> Ranged a
    Ranged Range
    r (b -> Ranged b) -> m b -> m (Ranged b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> m b
    f a
    x

    -- | Ranges are not forced.

    instance NFData a => NFData (Ranged a) where
      rnf :: Ranged a -> ()
    rnf (Ranged Range
    _ a
    a) = a -> ()
    forall a. NFData a => a -> ()
    rnf a
    a

    ---------------------------------------------------------------------------
    -- * Raw names (before parsing into name parts).
    ---------------------------------------------------------------------------

    -- | A @RawName@ is some sort of string.
    type RawName = String

    rawNameToString :: RawName -> String
    rawNameToString :: ShowS
    rawNameToString = ShowS
    forall a. a -> a
    id

    stringToRawName :: String -> RawName
    stringToRawName :: ShowS
    stringToRawName = ShowS
    forall a. a -> a
    id

    -- | String with range info.
    type RString = Ranged RawName

    ---------------------------------------------------------------------------
    -- * Further constructor and projection info
    ---------------------------------------------------------------------------

    -- | Where does the 'ConP' or 'Con' come from?
    data ConOrigin
      = ConOSystem  -- ^ Inserted by system or expanded from an implicit pattern.
      | ConOCon     -- ^ User wrote a constructor (pattern).
      | ConORec     -- ^ User wrote a record (pattern).
      | ConOSplit   -- ^ Generated by interactive case splitting.
      deriving (Int -> ConOrigin -> ShowS
    [ConOrigin] -> ShowS
    ConOrigin -> ArgName
    (Int -> ConOrigin -> ShowS)
    -> (ConOrigin -> ArgName)
    -> ([ConOrigin] -> ShowS)
    -> Show ConOrigin
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ConOrigin -> ShowS
    showsPrec :: Int -> ConOrigin -> ShowS
    $cshow :: ConOrigin -> ArgName
    show :: ConOrigin -> ArgName
    $cshowList :: [ConOrigin] -> ShowS
    showList :: [ConOrigin] -> ShowS
    Show, ConOrigin -> ConOrigin -> Bool
    (ConOrigin -> ConOrigin -> Bool)
    -> (ConOrigin -> ConOrigin -> Bool) -> Eq ConOrigin
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ConOrigin -> ConOrigin -> Bool
    == :: ConOrigin -> ConOrigin -> Bool
    $c/= :: ConOrigin -> ConOrigin -> Bool
    /= :: ConOrigin -> ConOrigin -> Bool
    Eq, Eq ConOrigin
    Eq ConOrigin =>
    (ConOrigin -> ConOrigin -> Ordering)
    -> (ConOrigin -> ConOrigin -> Bool)
    -> (ConOrigin -> ConOrigin -> Bool)
    -> (ConOrigin -> ConOrigin -> Bool)
    -> (ConOrigin -> ConOrigin -> Bool)
    -> (ConOrigin -> ConOrigin -> ConOrigin)
    -> (ConOrigin -> ConOrigin -> ConOrigin)
    -> Ord ConOrigin
    ConOrigin -> ConOrigin -> Bool
    ConOrigin -> ConOrigin -> Ordering
    ConOrigin -> ConOrigin -> ConOrigin
    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
    $ccompare :: ConOrigin -> ConOrigin -> Ordering
    compare :: ConOrigin -> ConOrigin -> Ordering
    $c< :: ConOrigin -> ConOrigin -> Bool
    < :: ConOrigin -> ConOrigin -> Bool
    $c<= :: ConOrigin -> ConOrigin -> Bool
    <= :: ConOrigin -> ConOrigin -> Bool
    $c> :: ConOrigin -> ConOrigin -> Bool
    > :: ConOrigin -> ConOrigin -> Bool
    $c>= :: ConOrigin -> ConOrigin -> Bool
    >= :: ConOrigin -> ConOrigin -> Bool
    $cmax :: ConOrigin -> ConOrigin -> ConOrigin
    max :: ConOrigin -> ConOrigin -> ConOrigin
    $cmin :: ConOrigin -> ConOrigin -> ConOrigin
    min :: ConOrigin -> ConOrigin -> ConOrigin
    Ord, Int -> ConOrigin
    ConOrigin -> Int
    ConOrigin -> [ConOrigin]
    ConOrigin -> ConOrigin
    ConOrigin -> ConOrigin -> [ConOrigin]
    ConOrigin -> ConOrigin -> ConOrigin -> [ConOrigin]
    (ConOrigin -> ConOrigin)
    -> (ConOrigin -> ConOrigin)
    -> (Int -> ConOrigin)
    -> (ConOrigin -> Int)
    -> (ConOrigin -> [ConOrigin])
    -> (ConOrigin -> ConOrigin -> [ConOrigin])
    -> (ConOrigin -> ConOrigin -> [ConOrigin])
    -> (ConOrigin -> ConOrigin -> ConOrigin -> [ConOrigin])
    -> Enum ConOrigin
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: ConOrigin -> ConOrigin
    succ :: ConOrigin -> ConOrigin
    $cpred :: ConOrigin -> ConOrigin
    pred :: ConOrigin -> ConOrigin
    $ctoEnum :: Int -> ConOrigin
    toEnum :: Int -> ConOrigin
    $cfromEnum :: ConOrigin -> Int
    fromEnum :: ConOrigin -> Int
    $cenumFrom :: ConOrigin -> [ConOrigin]
    enumFrom :: ConOrigin -> [ConOrigin]
    $cenumFromThen :: ConOrigin -> ConOrigin -> [ConOrigin]
    enumFromThen :: ConOrigin -> ConOrigin -> [ConOrigin]
    $cenumFromTo :: ConOrigin -> ConOrigin -> [ConOrigin]
    enumFromTo :: ConOrigin -> ConOrigin -> [ConOrigin]
    $cenumFromThenTo :: ConOrigin -> ConOrigin -> ConOrigin -> [ConOrigin]
    enumFromThenTo :: ConOrigin -> ConOrigin -> ConOrigin -> [ConOrigin]
    Enum, ConOrigin
    ConOrigin -> ConOrigin -> Bounded ConOrigin
    forall a. a -> a -> Bounded a
    $cminBound :: ConOrigin
    minBound :: ConOrigin
    $cmaxBound :: ConOrigin
    maxBound :: ConOrigin
    Bounded, (forall x. ConOrigin -> Rep ConOrigin x)
    -> (forall x. Rep ConOrigin x -> ConOrigin) -> Generic ConOrigin
    forall x. Rep ConOrigin x -> ConOrigin
    forall x. ConOrigin -> Rep ConOrigin x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ConOrigin -> Rep ConOrigin x
    from :: forall x. ConOrigin -> Rep ConOrigin x
    $cto :: forall x. Rep ConOrigin x -> ConOrigin
    to :: forall x. Rep ConOrigin x -> ConOrigin
    Generic)

    instance NFData ConOrigin

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

    -- | Prefer user-written over system-inserted.
    bestConInfo :: ConOrigin -> ConOrigin -> ConOrigin
    bestConInfo :: ConOrigin -> ConOrigin -> ConOrigin
    bestConInfo ConOrigin
    ConOSystem ConOrigin
    o = ConOrigin
    o
    bestConInfo ConOrigin
    o ConOrigin
    _ = ConOrigin
    o

    -- | Where does a projection come from?
    data ProjOrigin
      = ProjPrefix    -- ^ User wrote a prefix projection.
      | ProjPostfix   -- ^ User wrote a postfix projection.
      | ProjSystem    -- ^ Projection was generated by the system.
      deriving (Int -> ProjOrigin -> ShowS
    [ProjOrigin] -> ShowS
    ProjOrigin -> ArgName
    (Int -> ProjOrigin -> ShowS)
    -> (ProjOrigin -> ArgName)
    -> ([ProjOrigin] -> ShowS)
    -> Show ProjOrigin
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ProjOrigin -> ShowS
    showsPrec :: Int -> ProjOrigin -> ShowS
    $cshow :: ProjOrigin -> ArgName
    show :: ProjOrigin -> ArgName
    $cshowList :: [ProjOrigin] -> ShowS
    showList :: [ProjOrigin] -> ShowS
    Show, ProjOrigin -> ProjOrigin -> Bool
    (ProjOrigin -> ProjOrigin -> Bool)
    -> (ProjOrigin -> ProjOrigin -> Bool) -> Eq ProjOrigin
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ProjOrigin -> ProjOrigin -> Bool
    == :: ProjOrigin -> ProjOrigin -> Bool
    $c/= :: ProjOrigin -> ProjOrigin -> Bool
    /= :: ProjOrigin -> ProjOrigin -> Bool
    Eq, Eq ProjOrigin
    Eq ProjOrigin =>
    (ProjOrigin -> ProjOrigin -> Ordering)
    -> (ProjOrigin -> ProjOrigin -> Bool)
    -> (ProjOrigin -> ProjOrigin -> Bool)
    -> (ProjOrigin -> ProjOrigin -> Bool)
    -> (ProjOrigin -> ProjOrigin -> Bool)
    -> (ProjOrigin -> ProjOrigin -> ProjOrigin)
    -> (ProjOrigin -> ProjOrigin -> ProjOrigin)
    -> Ord ProjOrigin
    ProjOrigin -> ProjOrigin -> Bool
    ProjOrigin -> ProjOrigin -> Ordering
    ProjOrigin -> ProjOrigin -> ProjOrigin
    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
    $ccompare :: ProjOrigin -> ProjOrigin -> Ordering
    compare :: ProjOrigin -> ProjOrigin -> Ordering
    $c< :: ProjOrigin -> ProjOrigin -> Bool
    < :: ProjOrigin -> ProjOrigin -> Bool
    $c<= :: ProjOrigin -> ProjOrigin -> Bool
    <= :: ProjOrigin -> ProjOrigin -> Bool
    $c> :: ProjOrigin -> ProjOrigin -> Bool
    > :: ProjOrigin -> ProjOrigin -> Bool
    $c>= :: ProjOrigin -> ProjOrigin -> Bool
    >= :: ProjOrigin -> ProjOrigin -> Bool
    $cmax :: ProjOrigin -> ProjOrigin -> ProjOrigin
    max :: ProjOrigin -> ProjOrigin -> ProjOrigin
    $cmin :: ProjOrigin -> ProjOrigin -> ProjOrigin
    min :: ProjOrigin -> ProjOrigin -> ProjOrigin
    Ord, Int -> ProjOrigin
    ProjOrigin -> Int
    ProjOrigin -> [ProjOrigin]
    ProjOrigin -> ProjOrigin
    ProjOrigin -> ProjOrigin -> [ProjOrigin]
    ProjOrigin -> ProjOrigin -> ProjOrigin -> [ProjOrigin]
    (ProjOrigin -> ProjOrigin)
    -> (ProjOrigin -> ProjOrigin)
    -> (Int -> ProjOrigin)
    -> (ProjOrigin -> Int)
    -> (ProjOrigin -> [ProjOrigin])
    -> (ProjOrigin -> ProjOrigin -> [ProjOrigin])
    -> (ProjOrigin -> ProjOrigin -> [ProjOrigin])
    -> (ProjOrigin -> ProjOrigin -> ProjOrigin -> [ProjOrigin])
    -> Enum ProjOrigin
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: ProjOrigin -> ProjOrigin
    succ :: ProjOrigin -> ProjOrigin
    $cpred :: ProjOrigin -> ProjOrigin
    pred :: ProjOrigin -> ProjOrigin
    $ctoEnum :: Int -> ProjOrigin
    toEnum :: Int -> ProjOrigin
    $cfromEnum :: ProjOrigin -> Int
    fromEnum :: ProjOrigin -> Int
    $cenumFrom :: ProjOrigin -> [ProjOrigin]
    enumFrom :: ProjOrigin -> [ProjOrigin]
    $cenumFromThen :: ProjOrigin -> ProjOrigin -> [ProjOrigin]
    enumFromThen :: ProjOrigin -> ProjOrigin -> [ProjOrigin]
    $cenumFromTo :: ProjOrigin -> ProjOrigin -> [ProjOrigin]
    enumFromTo :: ProjOrigin -> ProjOrigin -> [ProjOrigin]
    $cenumFromThenTo :: ProjOrigin -> ProjOrigin -> ProjOrigin -> [ProjOrigin]
    enumFromThenTo :: ProjOrigin -> ProjOrigin -> ProjOrigin -> [ProjOrigin]
    Enum, ProjOrigin
    ProjOrigin -> ProjOrigin -> Bounded ProjOrigin
    forall a. a -> a -> Bounded a
    $cminBound :: ProjOrigin
    minBound :: ProjOrigin
    $cmaxBound :: ProjOrigin
    maxBound :: ProjOrigin
    Bounded, (forall x. ProjOrigin -> Rep ProjOrigin x)
    -> (forall x. Rep ProjOrigin x -> ProjOrigin) -> Generic ProjOrigin
    forall x. Rep ProjOrigin x -> ProjOrigin
    forall x. ProjOrigin -> Rep ProjOrigin x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ProjOrigin -> Rep ProjOrigin x
    from :: forall x. ProjOrigin -> Rep ProjOrigin x
    $cto :: forall x. Rep ProjOrigin x -> ProjOrigin
    to :: forall x. Rep ProjOrigin x -> ProjOrigin
    Generic)

    instance NFData ProjOrigin

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

    ---------------------------------------------------------------------------
    -- * Infixity, access, abstract, etc.
    ---------------------------------------------------------------------------

    -- | Functions can be defined in both infix and prefix style. See
    --   'Agda.Syntax.Concrete.LHS'.
    data IsInfix = InfixDef | PrefixDef
        deriving (Int -> IsInfix -> ShowS
    [IsInfix] -> ShowS
    IsInfix -> ArgName
    (Int -> IsInfix -> ShowS)
    -> (IsInfix -> ArgName) -> ([IsInfix] -> ShowS) -> Show IsInfix
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IsInfix -> ShowS
    showsPrec :: Int -> IsInfix -> ShowS
    $cshow :: IsInfix -> ArgName
    show :: IsInfix -> ArgName
    $cshowList :: [IsInfix] -> ShowS
    showList :: [IsInfix] -> ShowS
    Show, IsInfix -> IsInfix -> Bool
    (IsInfix -> IsInfix -> Bool)
    -> (IsInfix -> IsInfix -> Bool) -> Eq IsInfix
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IsInfix -> IsInfix -> Bool
    == :: IsInfix -> IsInfix -> Bool
    $c/= :: IsInfix -> IsInfix -> Bool
    /= :: IsInfix -> IsInfix -> Bool
    Eq, Eq IsInfix
    Eq IsInfix =>
    (IsInfix -> IsInfix -> Ordering)
    -> (IsInfix -> IsInfix -> Bool)
    -> (IsInfix -> IsInfix -> Bool)
    -> (IsInfix -> IsInfix -> Bool)
    -> (IsInfix -> IsInfix -> Bool)
    -> (IsInfix -> IsInfix -> IsInfix)
    -> (IsInfix -> IsInfix -> IsInfix)
    -> Ord IsInfix
    IsInfix -> IsInfix -> Bool
    IsInfix -> IsInfix -> Ordering
    IsInfix -> IsInfix -> IsInfix
    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
    $ccompare :: IsInfix -> IsInfix -> Ordering
    compare :: IsInfix -> IsInfix -> Ordering
    $c< :: IsInfix -> IsInfix -> Bool
    < :: IsInfix -> IsInfix -> Bool
    $c<= :: IsInfix -> IsInfix -> Bool
    <= :: IsInfix -> IsInfix -> Bool
    $c> :: IsInfix -> IsInfix -> Bool
    > :: IsInfix -> IsInfix -> Bool
    $c>= :: IsInfix -> IsInfix -> Bool
    >= :: IsInfix -> IsInfix -> Bool
    $cmax :: IsInfix -> IsInfix -> IsInfix
    max :: IsInfix -> IsInfix -> IsInfix
    $cmin :: IsInfix -> IsInfix -> IsInfix
    min :: IsInfix -> IsInfix -> IsInfix
    Ord)

    -- ** private blocks, public imports

    -- | Access modifier.
    data Access
      = PrivateAccess KwRange Origin
          -- ^ Store the 'Origin' of the private block that lead to this qualifier.
          --   This is needed for more faithful printing of declarations.
          --   'KwRange' is the range of the @private@ keyword.
      | PublicAccess
        deriving (Int -> Access -> ShowS
    [Access] -> ShowS
    Access -> ArgName
    (Int -> Access -> ShowS)
    -> (Access -> ArgName) -> ([Access] -> ShowS) -> Show Access
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Access -> ShowS
    showsPrec :: Int -> Access -> ShowS
    $cshow :: Access -> ArgName
    show :: Access -> ArgName
    $cshowList :: [Access] -> ShowS
    showList :: [Access] -> ShowS
    Show, Access -> Access -> Bool
    (Access -> Access -> Bool)
    -> (Access -> Access -> Bool) -> Eq Access
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Access -> Access -> Bool
    == :: Access -> Access -> Bool
    $c/= :: Access -> Access -> Bool
    /= :: Access -> Access -> Bool
    Eq, Eq Access
    Eq Access =>
    (Access -> Access -> Ordering)
    -> (Access -> Access -> Bool)
    -> (Access -> Access -> Bool)
    -> (Access -> Access -> Bool)
    -> (Access -> Access -> Bool)
    -> (Access -> Access -> Access)
    -> (Access -> Access -> Access)
    -> Ord Access
    Access -> Access -> Bool
    Access -> Access -> Ordering
    Access -> Access -> Access
    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
    $ccompare :: Access -> Access -> Ordering
    compare :: Access -> Access -> Ordering
    $c< :: Access -> Access -> Bool
    < :: Access -> Access -> Bool
    $c<= :: Access -> Access -> Bool
    <= :: Access -> Access -> Bool
    $c> :: Access -> Access -> Bool
    > :: Access -> Access -> Bool
    $c>= :: Access -> Access -> Bool
    >= :: Access -> Access -> Bool
    $cmax :: Access -> Access -> Access
    max :: Access -> Access -> Access
    $cmin :: Access -> Access -> Access
    min :: Access -> Access -> Access
    Ord)

    instance Pretty Access where
      pretty :: Access -> Doc
    pretty = ArgName -> Doc
    forall a. ArgName -> Doc a
    text (ArgName -> Doc) -> (Access -> ArgName) -> Access -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . \case
        PrivateAccess KwRange
    _ Origin
    _ -> ArgName
    "private"
        Access
    PublicAccess      -> ArgName
    "public"

    instance NFData Access where
      rnf :: Access -> ()
    rnf Access
    _ = ()

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

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

    privateAccessInserted :: Access
    privateAccessInserted :: Access
    privateAccessInserted = KwRange -> Origin -> Access
    PrivateAccess KwRange
    forall a. Null a => a
    empty Origin
    Inserted

    -- ** abstract blocks

    -- | Abstract or concrete.
    data IsAbstract = AbstractDef | ConcreteDef
        deriving (Int -> IsAbstract -> ShowS
    [IsAbstract] -> ShowS
    IsAbstract -> ArgName
    (Int -> IsAbstract -> ShowS)
    -> (IsAbstract -> ArgName)
    -> ([IsAbstract] -> ShowS)
    -> Show IsAbstract
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IsAbstract -> ShowS
    showsPrec :: Int -> IsAbstract -> ShowS
    $cshow :: IsAbstract -> ArgName
    show :: IsAbstract -> ArgName
    $cshowList :: [IsAbstract] -> ShowS
    showList :: [IsAbstract] -> ShowS
    Show, IsAbstract -> IsAbstract -> Bool
    (IsAbstract -> IsAbstract -> Bool)
    -> (IsAbstract -> IsAbstract -> Bool) -> Eq IsAbstract
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IsAbstract -> IsAbstract -> Bool
    == :: IsAbstract -> IsAbstract -> Bool
    $c/= :: IsAbstract -> IsAbstract -> Bool
    /= :: IsAbstract -> IsAbstract -> Bool
    Eq, Eq IsAbstract
    Eq IsAbstract =>
    (IsAbstract -> IsAbstract -> Ordering)
    -> (IsAbstract -> IsAbstract -> Bool)
    -> (IsAbstract -> IsAbstract -> Bool)
    -> (IsAbstract -> IsAbstract -> Bool)
    -> (IsAbstract -> IsAbstract -> Bool)
    -> (IsAbstract -> IsAbstract -> IsAbstract)
    -> (IsAbstract -> IsAbstract -> IsAbstract)
    -> Ord IsAbstract
    IsAbstract -> IsAbstract -> Bool
    IsAbstract -> IsAbstract -> Ordering
    IsAbstract -> IsAbstract -> IsAbstract
    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
    $ccompare :: IsAbstract -> IsAbstract -> Ordering
    compare :: IsAbstract -> IsAbstract -> Ordering
    $c< :: IsAbstract -> IsAbstract -> Bool
    < :: IsAbstract -> IsAbstract -> Bool
    $c<= :: IsAbstract -> IsAbstract -> Bool
    <= :: IsAbstract -> IsAbstract -> Bool
    $c> :: IsAbstract -> IsAbstract -> Bool
    > :: IsAbstract -> IsAbstract -> Bool
    $c>= :: IsAbstract -> IsAbstract -> Bool
    >= :: IsAbstract -> IsAbstract -> Bool
    $cmax :: IsAbstract -> IsAbstract -> IsAbstract
    max :: IsAbstract -> IsAbstract -> IsAbstract
    $cmin :: IsAbstract -> IsAbstract -> IsAbstract
    min :: IsAbstract -> IsAbstract -> IsAbstract
    Ord, (forall x. IsAbstract -> Rep IsAbstract x)
    -> (forall x. Rep IsAbstract x -> IsAbstract) -> Generic IsAbstract
    forall x. Rep IsAbstract x -> IsAbstract
    forall x. IsAbstract -> Rep IsAbstract x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. IsAbstract -> Rep IsAbstract x
    from :: forall x. IsAbstract -> Rep IsAbstract x
    $cto :: forall x. Rep IsAbstract x -> IsAbstract
    to :: forall x. Rep IsAbstract x -> IsAbstract
    Generic)

    -- | Semigroup computes if any of several is an 'AbstractDef'.
    instance Semigroup IsAbstract where
      IsAbstract
    AbstractDef <> :: IsAbstract -> IsAbstract -> IsAbstract
    <> IsAbstract
    _ = IsAbstract
    AbstractDef
      IsAbstract
    ConcreteDef <> IsAbstract
    a = IsAbstract
    a

    -- | Default is 'ConcreteDef'.
    instance Monoid IsAbstract where
      mempty :: IsAbstract
    mempty  = IsAbstract
    ConcreteDef
      mappend :: IsAbstract -> IsAbstract -> IsAbstract
    mappend = IsAbstract -> IsAbstract -> IsAbstract
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance Boolean IsAbstract where
      fromBool :: Bool -> IsAbstract
    fromBool Bool
    True  = IsAbstract
    AbstractDef
      fromBool Bool
    False = IsAbstract
    ConcreteDef

    instance IsBool IsAbstract where
      toBool :: IsAbstract -> Bool
    toBool IsAbstract
    AbstractDef = Bool
    True
      toBool IsAbstract
    ConcreteDef = Bool
    False

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

    instance NFData IsAbstract

    class LensIsAbstract a where
      lensIsAbstract :: Lens' a IsAbstract

    instance LensIsAbstract IsAbstract where
      lensIsAbstract :: Lens' IsAbstract IsAbstract
    lensIsAbstract = (IsAbstract -> f IsAbstract) -> IsAbstract -> f IsAbstract
    forall a. a -> a
    id

    -- | Is any element of a collection an 'AbstractDef'.
    class AnyIsAbstract a where
      anyIsAbstract :: a -> IsAbstract

      default anyIsAbstract :: (Foldable t, AnyIsAbstract b, t b ~ a) => a -> IsAbstract
      anyIsAbstract = (b -> IsAbstract) -> t b -> IsAbstract
    forall m a. Monoid m => (a -> m) -> t a -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    Fold.foldMap b -> IsAbstract
    forall a. AnyIsAbstract a => a -> IsAbstract
    anyIsAbstract

    instance AnyIsAbstract IsAbstract where
      anyIsAbstract :: IsAbstract -> IsAbstract
    anyIsAbstract = IsAbstract -> IsAbstract
    forall a. a -> a
    id

    instance AnyIsAbstract a => AnyIsAbstract [a] where
    instance AnyIsAbstract a => AnyIsAbstract (Maybe a) where

    -- ** instance blocks

    -- | Is this definition eligible for instance search?
    data IsInstance
      = InstanceDef KwRange  -- ^ Range of the @instance@ keyword.
      | NotInstanceDef
        deriving (Int -> IsInstance -> ShowS
    [IsInstance] -> ShowS
    IsInstance -> ArgName
    (Int -> IsInstance -> ShowS)
    -> (IsInstance -> ArgName)
    -> ([IsInstance] -> ShowS)
    -> Show IsInstance
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IsInstance -> ShowS
    showsPrec :: Int -> IsInstance -> ShowS
    $cshow :: IsInstance -> ArgName
    show :: IsInstance -> ArgName
    $cshowList :: [IsInstance] -> ShowS
    showList :: [IsInstance] -> ShowS
    Show, IsInstance -> IsInstance -> Bool
    (IsInstance -> IsInstance -> Bool)
    -> (IsInstance -> IsInstance -> Bool) -> Eq IsInstance
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IsInstance -> IsInstance -> Bool
    == :: IsInstance -> IsInstance -> Bool
    $c/= :: IsInstance -> IsInstance -> Bool
    /= :: IsInstance -> IsInstance -> Bool
    Eq, Eq IsInstance
    Eq IsInstance =>
    (IsInstance -> IsInstance -> Ordering)
    -> (IsInstance -> IsInstance -> Bool)
    -> (IsInstance -> IsInstance -> Bool)
    -> (IsInstance -> IsInstance -> Bool)
    -> (IsInstance -> IsInstance -> Bool)
    -> (IsInstance -> IsInstance -> IsInstance)
    -> (IsInstance -> IsInstance -> IsInstance)
    -> Ord IsInstance
    IsInstance -> IsInstance -> Bool
    IsInstance -> IsInstance -> Ordering
    IsInstance -> IsInstance -> IsInstance
    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
    $ccompare :: IsInstance -> IsInstance -> Ordering
    compare :: IsInstance -> IsInstance -> Ordering
    $c< :: IsInstance -> IsInstance -> Bool
    < :: IsInstance -> IsInstance -> Bool
    $c<= :: IsInstance -> IsInstance -> Bool
    <= :: IsInstance -> IsInstance -> Bool
    $c> :: IsInstance -> IsInstance -> Bool
    > :: IsInstance -> IsInstance -> Bool
    $c>= :: IsInstance -> IsInstance -> Bool
    >= :: IsInstance -> IsInstance -> Bool
    $cmax :: IsInstance -> IsInstance -> IsInstance
    max :: IsInstance -> IsInstance -> IsInstance
    $cmin :: IsInstance -> IsInstance -> IsInstance
    min :: IsInstance -> IsInstance -> IsInstance
    Ord)

    instance KillRange IsInstance where
      killRange :: IsInstance -> IsInstance
    killRange = \case
        InstanceDef KwRange
    _    -> KwRange -> IsInstance
    InstanceDef KwRange
    forall a. Null a => a
    empty
        i :: IsInstance
    i@IsInstance
    NotInstanceDef -> IsInstance
    i

    instance HasRange IsInstance where
      getRange :: IsInstance -> Range
    getRange = \case
        InstanceDef KwRange
    r  -> KwRange -> Range
    forall a. HasRange a => a -> Range
    getRange KwRange
    r
        IsInstance
    NotInstanceDef -> Range
    forall a. Range' a
    noRange

    instance NFData IsInstance where
      rnf :: IsInstance -> ()
    rnf (InstanceDef KwRange
    _) = ()
      rnf IsInstance
    NotInstanceDef  = ()

    -- ** macro blocks

    -- | Is this a macro definition?
    data IsMacro = MacroDef | NotMacroDef
      deriving (Int -> IsMacro -> ShowS
    [IsMacro] -> ShowS
    IsMacro -> ArgName
    (Int -> IsMacro -> ShowS)
    -> (IsMacro -> ArgName) -> ([IsMacro] -> ShowS) -> Show IsMacro
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IsMacro -> ShowS
    showsPrec :: Int -> IsMacro -> ShowS
    $cshow :: IsMacro -> ArgName
    show :: IsMacro -> ArgName
    $cshowList :: [IsMacro] -> ShowS
    showList :: [IsMacro] -> ShowS
    Show, IsMacro -> IsMacro -> Bool
    (IsMacro -> IsMacro -> Bool)
    -> (IsMacro -> IsMacro -> Bool) -> Eq IsMacro
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IsMacro -> IsMacro -> Bool
    == :: IsMacro -> IsMacro -> Bool
    $c/= :: IsMacro -> IsMacro -> Bool
    /= :: IsMacro -> IsMacro -> Bool
    Eq, Eq IsMacro
    Eq IsMacro =>
    (IsMacro -> IsMacro -> Ordering)
    -> (IsMacro -> IsMacro -> Bool)
    -> (IsMacro -> IsMacro -> Bool)
    -> (IsMacro -> IsMacro -> Bool)
    -> (IsMacro -> IsMacro -> Bool)
    -> (IsMacro -> IsMacro -> IsMacro)
    -> (IsMacro -> IsMacro -> IsMacro)
    -> Ord IsMacro
    IsMacro -> IsMacro -> Bool
    IsMacro -> IsMacro -> Ordering
    IsMacro -> IsMacro -> IsMacro
    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
    $ccompare :: IsMacro -> IsMacro -> Ordering
    compare :: IsMacro -> IsMacro -> Ordering
    $c< :: IsMacro -> IsMacro -> Bool
    < :: IsMacro -> IsMacro -> Bool
    $c<= :: IsMacro -> IsMacro -> Bool
    <= :: IsMacro -> IsMacro -> Bool
    $c> :: IsMacro -> IsMacro -> Bool
    > :: IsMacro -> IsMacro -> Bool
    $c>= :: IsMacro -> IsMacro -> Bool
    >= :: IsMacro -> IsMacro -> Bool
    $cmax :: IsMacro -> IsMacro -> IsMacro
    max :: IsMacro -> IsMacro -> IsMacro
    $cmin :: IsMacro -> IsMacro -> IsMacro
    min :: IsMacro -> IsMacro -> IsMacro
    Ord, (forall x. IsMacro -> Rep IsMacro x)
    -> (forall x. Rep IsMacro x -> IsMacro) -> Generic IsMacro
    forall x. Rep IsMacro x -> IsMacro
    forall x. IsMacro -> Rep IsMacro x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. IsMacro -> Rep IsMacro x
    from :: forall x. IsMacro -> Rep IsMacro x
    $cto :: forall x. Rep IsMacro x -> IsMacro
    to :: forall x. Rep IsMacro x -> IsMacro
    Generic)

    instance KillRange IsMacro where killRange :: IsMacro -> IsMacro
    killRange = IsMacro -> IsMacro
    forall a. a -> a
    id
    instance HasRange  IsMacro where getRange :: IsMacro -> Range
    getRange IsMacro
    _ = Range
    forall a. Range' a
    noRange

    instance NFData IsMacro

    -- ** opaque blocks

    -- | Opaque or transparent.
    data IsOpaque
      = OpaqueDef {-# UNPACK #-} !OpaqueId
        -- ^ This definition is opaque, and it is guarded by the given
        -- opaque block.
      | TransparentDef
      deriving (Int -> IsOpaque -> ShowS
    [IsOpaque] -> ShowS
    IsOpaque -> ArgName
    (Int -> IsOpaque -> ShowS)
    -> (IsOpaque -> ArgName) -> ([IsOpaque] -> ShowS) -> Show IsOpaque
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IsOpaque -> ShowS
    showsPrec :: Int -> IsOpaque -> ShowS
    $cshow :: IsOpaque -> ArgName
    show :: IsOpaque -> ArgName
    $cshowList :: [IsOpaque] -> ShowS
    showList :: [IsOpaque] -> ShowS
    Show, IsOpaque -> IsOpaque -> Bool
    (IsOpaque -> IsOpaque -> Bool)
    -> (IsOpaque -> IsOpaque -> Bool) -> Eq IsOpaque
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IsOpaque -> IsOpaque -> Bool
    == :: IsOpaque -> IsOpaque -> Bool
    $c/= :: IsOpaque -> IsOpaque -> Bool
    /= :: IsOpaque -> IsOpaque -> Bool
    Eq, Eq IsOpaque
    Eq IsOpaque =>
    (IsOpaque -> IsOpaque -> Ordering)
    -> (IsOpaque -> IsOpaque -> Bool)
    -> (IsOpaque -> IsOpaque -> Bool)
    -> (IsOpaque -> IsOpaque -> Bool)
    -> (IsOpaque -> IsOpaque -> Bool)
    -> (IsOpaque -> IsOpaque -> IsOpaque)
    -> (IsOpaque -> IsOpaque -> IsOpaque)
    -> Ord IsOpaque
    IsOpaque -> IsOpaque -> Bool
    IsOpaque -> IsOpaque -> Ordering
    IsOpaque -> IsOpaque -> IsOpaque
    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
    $ccompare :: IsOpaque -> IsOpaque -> Ordering
    compare :: IsOpaque -> IsOpaque -> Ordering
    $c< :: IsOpaque -> IsOpaque -> Bool
    < :: IsOpaque -> IsOpaque -> Bool
    $c<= :: IsOpaque -> IsOpaque -> Bool
    <= :: IsOpaque -> IsOpaque -> Bool
    $c> :: IsOpaque -> IsOpaque -> Bool
    > :: IsOpaque -> IsOpaque -> Bool
    $c>= :: IsOpaque -> IsOpaque -> Bool
    >= :: IsOpaque -> IsOpaque -> Bool
    $cmax :: IsOpaque -> IsOpaque -> IsOpaque
    max :: IsOpaque -> IsOpaque -> IsOpaque
    $cmin :: IsOpaque -> IsOpaque -> IsOpaque
    min :: IsOpaque -> IsOpaque -> IsOpaque
    Ord, (forall x. IsOpaque -> Rep IsOpaque x)
    -> (forall x. Rep IsOpaque x -> IsOpaque) -> Generic IsOpaque
    forall x. Rep IsOpaque x -> IsOpaque
    forall x. IsOpaque -> Rep IsOpaque x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. IsOpaque -> Rep IsOpaque x
    from :: forall x. IsOpaque -> Rep IsOpaque x
    $cto :: forall x. Rep IsOpaque x -> IsOpaque
    to :: forall x. Rep IsOpaque x -> IsOpaque
    Generic)

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

    instance NFData IsOpaque

    class LensIsOpaque a where
      lensIsOpaque :: Lens' a IsOpaque

    instance LensIsOpaque IsOpaque where
      lensIsOpaque :: Lens' IsOpaque IsOpaque
    lensIsOpaque = (IsOpaque -> f IsOpaque) -> IsOpaque -> f IsOpaque
    forall a. a -> a
    id

    -- | Monoid representing the combined opaque blocks of a 'Foldable'
    -- containing possibly-opaque declarations.
    data JointOpacity
      = UniqueOpaque    {-# UNPACK #-} !OpaqueId
      -- ^ Every definition agrees on what opaque block they belong to.
      | DifferentOpaque !(HashSet OpaqueId)
      -- ^ More than one opaque block was found.
      | NoOpaque
      -- ^ Nothing here is opaque.

    instance Semigroup JointOpacity where
      UniqueOpaque OpaqueId
    i <> :: JointOpacity -> JointOpacity -> JointOpacity
    <> UniqueOpaque OpaqueId
    j
        | OpaqueId
    i OpaqueId -> OpaqueId -> Bool
    forall a. Eq a => a -> a -> Bool
    == OpaqueId
    j    = OpaqueId -> JointOpacity
    UniqueOpaque OpaqueId
    i
        | Bool
    otherwise = HashSet OpaqueId -> JointOpacity
    DifferentOpaque ([OpaqueId] -> HashSet OpaqueId
    forall a. (Eq a, Hashable a) => [a] -> HashSet a
    HashSet.fromList [OpaqueId
    i, OpaqueId
    j])

      DifferentOpaque HashSet OpaqueId
    is <> UniqueOpaque OpaqueId
    j     = HashSet OpaqueId -> JointOpacity
    DifferentOpaque (OpaqueId -> HashSet OpaqueId -> HashSet OpaqueId
    forall a. (Eq a, Hashable a) => a -> HashSet a -> HashSet a
    HashSet.insert OpaqueId
    j HashSet OpaqueId
    is)
      UniqueOpaque OpaqueId
    i     <> DifferentOpaque HashSet OpaqueId
    js = HashSet OpaqueId -> JointOpacity
    DifferentOpaque (OpaqueId -> HashSet OpaqueId -> HashSet OpaqueId
    forall a. (Eq a, Hashable a) => a -> HashSet a -> HashSet a
    HashSet.insert OpaqueId
    i HashSet OpaqueId
    js)
      DifferentOpaque HashSet OpaqueId
    is <> DifferentOpaque HashSet OpaqueId
    js = HashSet OpaqueId -> JointOpacity
    DifferentOpaque (HashSet OpaqueId -> HashSet OpaqueId -> HashSet OpaqueId
    forall a. Eq a => HashSet a -> HashSet a -> HashSet a
    HashSet.union HashSet OpaqueId
    is HashSet OpaqueId
    js)

      JointOpacity
    NoOpaque <> JointOpacity
    x = JointOpacity
    x
      JointOpacity
    x <> JointOpacity
    NoOpaque = JointOpacity
    x

    instance Monoid JointOpacity where
      mappend :: JointOpacity -> JointOpacity -> JointOpacity
    mappend = JointOpacity -> JointOpacity -> JointOpacity
    forall a. Semigroup a => a -> a -> a
    (<>)
      mempty :: JointOpacity
    mempty = JointOpacity
    NoOpaque

    class AllAreOpaque a where
      jointOpacity :: a -> JointOpacity

      default jointOpacity :: (Foldable t, AllAreOpaque b, t b ~ a) => a -> JointOpacity
      jointOpacity = (b -> JointOpacity) -> t b -> JointOpacity
    forall m a. Monoid m => (a -> m) -> t a -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    Fold.foldMap b -> JointOpacity
    forall a. AllAreOpaque a => a -> JointOpacity
    jointOpacity

    instance AllAreOpaque IsOpaque where
      jointOpacity :: IsOpaque -> JointOpacity
    jointOpacity = \case
        IsOpaque
    TransparentDef -> JointOpacity
    NoOpaque
        OpaqueDef OpaqueId
    i    -> OpaqueId -> JointOpacity
    UniqueOpaque OpaqueId
    i

    instance AllAreOpaque a => AllAreOpaque [a] where
    instance AllAreOpaque a => AllAreOpaque (Maybe a) where

    ---------------------------------------------------------------------------
    -- * NameId
    ---------------------------------------------------------------------------

    -- | The unique identifier of a name. Second argument is the top-level module
    --   identifier.
    data NameId = NameId {-# UNPACK #-} !Word64 {-# UNPACK #-} !ModuleNameHash
        deriving (NameId -> NameId -> Bool
    (NameId -> NameId -> Bool)
    -> (NameId -> NameId -> Bool) -> Eq NameId
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NameId -> NameId -> Bool
    == :: NameId -> NameId -> Bool
    $c/= :: NameId -> NameId -> Bool
    /= :: NameId -> NameId -> Bool
    Eq, Eq NameId
    Eq NameId =>
    (NameId -> NameId -> Ordering)
    -> (NameId -> NameId -> Bool)
    -> (NameId -> NameId -> Bool)
    -> (NameId -> NameId -> Bool)
    -> (NameId -> NameId -> Bool)
    -> (NameId -> NameId -> NameId)
    -> (NameId -> NameId -> NameId)
    -> Ord NameId
    NameId -> NameId -> Bool
    NameId -> NameId -> Ordering
    NameId -> NameId -> NameId
    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
    $ccompare :: NameId -> NameId -> Ordering
    compare :: NameId -> NameId -> Ordering
    $c< :: NameId -> NameId -> Bool
    < :: NameId -> NameId -> Bool
    $c<= :: NameId -> NameId -> Bool
    <= :: NameId -> NameId -> Bool
    $c> :: NameId -> NameId -> Bool
    > :: NameId -> NameId -> Bool
    $c>= :: NameId -> NameId -> Bool
    >= :: NameId -> NameId -> Bool
    $cmax :: NameId -> NameId -> NameId
    max :: NameId -> NameId -> NameId
    $cmin :: NameId -> NameId -> NameId
    min :: NameId -> NameId -> NameId
    Ord, (forall x. NameId -> Rep NameId x)
    -> (forall x. Rep NameId x -> NameId) -> Generic NameId
    forall x. Rep NameId x -> NameId
    forall x. NameId -> Rep NameId x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. NameId -> Rep NameId x
    from :: forall x. NameId -> Rep NameId x
    $cto :: forall x. Rep NameId x -> NameId
    to :: forall x. Rep NameId x -> NameId
    Generic, Int -> NameId -> ShowS
    [NameId] -> ShowS
    NameId -> ArgName
    (Int -> NameId -> ShowS)
    -> (NameId -> ArgName) -> ([NameId] -> ShowS) -> Show NameId
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> NameId -> ShowS
    showsPrec :: Int -> NameId -> ShowS
    $cshow :: NameId -> ArgName
    show :: NameId -> ArgName
    $cshowList :: [NameId] -> ShowS
    showList :: [NameId] -> ShowS
    Show)

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

    instance Pretty NameId where
      pretty :: NameId -> Doc
    pretty (NameId Word64
    n ModuleNameHash
    m) = ArgName -> Doc
    forall a. ArgName -> Doc a
    text (ArgName -> Doc) -> ArgName -> Doc
    forall a b. (a -> b) -> a -> b
    $ Word64 -> ArgName
    forall a. Show a => a -> ArgName
    show Word64
    n ArgName -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ArgName
    "@" ArgName -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ModuleNameHash -> ArgName
    forall a. Show a => a -> ArgName
    show ModuleNameHash
    m

    instance Enum NameId where
      succ :: NameId -> NameId
    succ (NameId Word64
    n ModuleNameHash
    m)     = Word64 -> ModuleNameHash -> NameId
    NameId (Word64
    n Word64 -> Word64 -> Word64
    forall a. Num a => a -> a -> a
    + Word64
    1) ModuleNameHash
    m
      pred :: NameId -> NameId
    pred (NameId Word64
    n ModuleNameHash
    m)     = Word64 -> ModuleNameHash -> NameId
    NameId (Word64
    n Word64 -> Word64 -> Word64
    forall a. Num a => a -> a -> a
    - Word64
    1) ModuleNameHash
    m
      toEnum :: Int -> NameId
    toEnum Int
    n              = NameId
    forall a. HasCallStack => a
    __IMPOSSIBLE__  -- should not be used
      fromEnum :: NameId -> Int
    fromEnum (NameId Word64
    n ModuleNameHash
    _) = Word64 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word64
    n

    instance NFData NameId where
      rnf :: NameId -> ()
    rnf (NameId Word64
    _ ModuleNameHash
    _) = ()

    instance Hashable NameId where
      {-# INLINE hashWithSalt #-}
      hashWithSalt :: Int -> NameId -> Int
    hashWithSalt Int
    salt (NameId Word64
    n (ModuleNameHash Word64
    m)) = Int -> (Word64, Word64) -> Int
    forall a. Hashable a => Int -> a -> Int
    hashWithSalt Int
    salt (Word64
    n, Word64
    m)

    ---------------------------------------------------------------------------
    -- * Meta variables
    ---------------------------------------------------------------------------

    -- | Meta-variable identifiers use the same structure as 'NameId's.

    data MetaId = MetaId
      { MetaId -> Word64
    metaId     :: {-# UNPACK #-} !Word64
      , MetaId -> ModuleNameHash
    metaModule :: {-# UNPACK #-} !ModuleNameHash
      }
      deriving (MetaId -> MetaId -> Bool
    (MetaId -> MetaId -> Bool)
    -> (MetaId -> MetaId -> Bool) -> Eq MetaId
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MetaId -> MetaId -> Bool
    == :: MetaId -> MetaId -> Bool
    $c/= :: MetaId -> MetaId -> Bool
    /= :: MetaId -> MetaId -> Bool
    Eq, Eq MetaId
    Eq MetaId =>
    (MetaId -> MetaId -> Ordering)
    -> (MetaId -> MetaId -> Bool)
    -> (MetaId -> MetaId -> Bool)
    -> (MetaId -> MetaId -> Bool)
    -> (MetaId -> MetaId -> Bool)
    -> (MetaId -> MetaId -> MetaId)
    -> (MetaId -> MetaId -> MetaId)
    -> Ord MetaId
    MetaId -> MetaId -> Bool
    MetaId -> MetaId -> Ordering
    MetaId -> MetaId -> MetaId
    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
    $ccompare :: MetaId -> MetaId -> Ordering
    compare :: MetaId -> MetaId -> Ordering
    $c< :: MetaId -> MetaId -> Bool
    < :: MetaId -> MetaId -> Bool
    $c<= :: MetaId -> MetaId -> Bool
    <= :: MetaId -> MetaId -> Bool
    $c> :: MetaId -> MetaId -> Bool
    > :: MetaId -> MetaId -> Bool
    $c>= :: MetaId -> MetaId -> Bool
    >= :: MetaId -> MetaId -> Bool
    $cmax :: MetaId -> MetaId -> MetaId
    max :: MetaId -> MetaId -> MetaId
    $cmin :: MetaId -> MetaId -> MetaId
    min :: MetaId -> MetaId -> MetaId
    Ord, (forall x. MetaId -> Rep MetaId x)
    -> (forall x. Rep MetaId x -> MetaId) -> Generic MetaId
    forall x. Rep MetaId x -> MetaId
    forall x. MetaId -> Rep MetaId x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. MetaId -> Rep MetaId x
    from :: forall x. MetaId -> Rep MetaId x
    $cto :: forall x. Rep MetaId x -> MetaId
    to :: forall x. Rep MetaId x -> MetaId
    Generic)

    instance Pretty MetaId where
      pretty :: MetaId -> Doc
    pretty (MetaId Word64
    n ModuleNameHash
    m) =
        ArgName -> Doc
    forall a. ArgName -> Doc a
    text (ArgName -> Doc) -> ArgName -> Doc
    forall a b. (a -> b) -> a -> b
    $ ArgName
    "_" ArgName -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Word64 -> ArgName
    forall a. Show a => a -> ArgName
    show Word64
    n ArgName -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ArgName
    "@" ArgName -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Word64 -> ArgName
    forall a. Show a => a -> ArgName
    show (ModuleNameHash -> Word64
    moduleNameHash ModuleNameHash
    m)

    instance Enum MetaId where
      succ :: MetaId -> MetaId
    succ MetaId{Word64
    ModuleNameHash
    metaId :: MetaId -> Word64
    metaModule :: MetaId -> ModuleNameHash
    metaId :: Word64
    metaModule :: ModuleNameHash
    ..} = MetaId { metaId :: Word64
    metaId = Word64 -> Word64
    forall a. Enum a => a -> a
    succ Word64
    metaId, ModuleNameHash
    metaModule :: ModuleNameHash
    metaModule :: ModuleNameHash
    .. }
      pred :: MetaId -> MetaId
    pred MetaId{Word64
    ModuleNameHash
    metaId :: MetaId -> Word64
    metaModule :: MetaId -> ModuleNameHash
    metaId :: Word64
    metaModule :: ModuleNameHash
    ..} = MetaId { metaId :: Word64
    metaId = Word64 -> Word64
    forall a. Enum a => a -> a
    pred Word64
    metaId, ModuleNameHash
    metaModule :: ModuleNameHash
    metaModule :: ModuleNameHash
    .. }

      -- The following functions should not be used.
      toEnum :: Int -> MetaId
    toEnum   = Int -> MetaId
    forall a. HasCallStack => a
    __IMPOSSIBLE__
      fromEnum :: MetaId -> Int
    fromEnum = MetaId -> Int
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    -- | The record selectors are not included in the resulting strings.

    instance Show MetaId where
      showsPrec :: Int -> MetaId -> ShowS
    showsPrec Int
    p (MetaId Word64
    n ModuleNameHash
    m) = Bool -> ShowS -> ShowS
    showParen (Int
    p Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    0) (ShowS -> ShowS) -> ShowS -> ShowS
    forall a b. (a -> b) -> a -> b
    $
        ArgName -> ShowS
    showString ArgName
    "MetaId " ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .
        Int -> Word64 -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec Int
    11 Word64
    n ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .
        ArgName -> ShowS
    showString ArgName
    " " ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .
        Int -> ModuleNameHash -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec Int
    11 ModuleNameHash
    m

    instance NFData MetaId where
      rnf :: MetaId -> ()
    rnf (MetaId Word64
    x ModuleNameHash
    y) = Word64 -> ()
    forall a. NFData a => a -> ()
    rnf Word64
    x () -> () -> ()
    forall a b. a -> b -> b
    `seq` ModuleNameHash -> ()
    forall a. NFData a => a -> ()
    rnf ModuleNameHash
    y

    instance Hashable MetaId where
      {-# INLINE hashWithSalt #-}
      hashWithSalt :: Int -> MetaId -> Int
    hashWithSalt Int
    salt (MetaId Word64
    n ModuleNameHash
    m) = Int -> (Word64, ModuleNameHash) -> Int
    forall a. Hashable a => Int -> a -> Int
    hashWithSalt Int
    salt (Word64
    n, ModuleNameHash
    m)

    newtype Constr a = Constr a

    -----------------------------------------------------------------------------
    -- * Problems
    -----------------------------------------------------------------------------

    -- | A "problem" consists of a set of constraints and the same constraint can be part of multiple
    --   problems.
    newtype ProblemId = ProblemId Nat
      deriving (ProblemId -> ProblemId -> Bool
    (ProblemId -> ProblemId -> Bool)
    -> (ProblemId -> ProblemId -> Bool) -> Eq ProblemId
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ProblemId -> ProblemId -> Bool
    == :: ProblemId -> ProblemId -> Bool
    $c/= :: ProblemId -> ProblemId -> Bool
    /= :: ProblemId -> ProblemId -> Bool
    Eq, Eq ProblemId
    Eq ProblemId =>
    (ProblemId -> ProblemId -> Ordering)
    -> (ProblemId -> ProblemId -> Bool)
    -> (ProblemId -> ProblemId -> Bool)
    -> (ProblemId -> ProblemId -> Bool)
    -> (ProblemId -> ProblemId -> Bool)
    -> (ProblemId -> ProblemId -> ProblemId)
    -> (ProblemId -> ProblemId -> ProblemId)
    -> Ord ProblemId
    ProblemId -> ProblemId -> Bool
    ProblemId -> ProblemId -> Ordering
    ProblemId -> ProblemId -> ProblemId
    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
    $ccompare :: ProblemId -> ProblemId -> Ordering
    compare :: ProblemId -> ProblemId -> Ordering
    $c< :: ProblemId -> ProblemId -> Bool
    < :: ProblemId -> ProblemId -> Bool
    $c<= :: ProblemId -> ProblemId -> Bool
    <= :: ProblemId -> ProblemId -> Bool
    $c> :: ProblemId -> ProblemId -> Bool
    > :: ProblemId -> ProblemId -> Bool
    $c>= :: ProblemId -> ProblemId -> Bool
    >= :: ProblemId -> ProblemId -> Bool
    $cmax :: ProblemId -> ProblemId -> ProblemId
    max :: ProblemId -> ProblemId -> ProblemId
    $cmin :: ProblemId -> ProblemId -> ProblemId
    min :: ProblemId -> ProblemId -> ProblemId
    Ord, Int -> ProblemId
    ProblemId -> Int
    ProblemId -> [ProblemId]
    ProblemId -> ProblemId
    ProblemId -> ProblemId -> [ProblemId]
    ProblemId -> ProblemId -> ProblemId -> [ProblemId]
    (ProblemId -> ProblemId)
    -> (ProblemId -> ProblemId)
    -> (Int -> ProblemId)
    -> (ProblemId -> Int)
    -> (ProblemId -> [ProblemId])
    -> (ProblemId -> ProblemId -> [ProblemId])
    -> (ProblemId -> ProblemId -> [ProblemId])
    -> (ProblemId -> ProblemId -> ProblemId -> [ProblemId])
    -> Enum ProblemId
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: ProblemId -> ProblemId
    succ :: ProblemId -> ProblemId
    $cpred :: ProblemId -> ProblemId
    pred :: ProblemId -> ProblemId
    $ctoEnum :: Int -> ProblemId
    toEnum :: Int -> ProblemId
    $cfromEnum :: ProblemId -> Int
    fromEnum :: ProblemId -> Int
    $cenumFrom :: ProblemId -> [ProblemId]
    enumFrom :: ProblemId -> [ProblemId]
    $cenumFromThen :: ProblemId -> ProblemId -> [ProblemId]
    enumFromThen :: ProblemId -> ProblemId -> [ProblemId]
    $cenumFromTo :: ProblemId -> ProblemId -> [ProblemId]
    enumFromTo :: ProblemId -> ProblemId -> [ProblemId]
    $cenumFromThenTo :: ProblemId -> ProblemId -> ProblemId -> [ProblemId]
    enumFromThenTo :: ProblemId -> ProblemId -> ProblemId -> [ProblemId]
    Enum, Num ProblemId
    Ord ProblemId
    (Num ProblemId, Ord ProblemId) =>
    (ProblemId -> Rational) -> Real ProblemId
    ProblemId -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: ProblemId -> Rational
    toRational :: ProblemId -> Rational
    Real, Enum ProblemId
    Real ProblemId
    (Real ProblemId, Enum ProblemId) =>
    (ProblemId -> ProblemId -> ProblemId)
    -> (ProblemId -> ProblemId -> ProblemId)
    -> (ProblemId -> ProblemId -> ProblemId)
    -> (ProblemId -> ProblemId -> ProblemId)
    -> (ProblemId -> ProblemId -> (ProblemId, ProblemId))
    -> (ProblemId -> ProblemId -> (ProblemId, ProblemId))
    -> (ProblemId -> Integer)
    -> Integral ProblemId
    ProblemId -> Integer
    ProblemId -> ProblemId -> (ProblemId, ProblemId)
    ProblemId -> ProblemId -> ProblemId
    forall a.
    (Real a, Enum a) =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: ProblemId -> ProblemId -> ProblemId
    quot :: ProblemId -> ProblemId -> ProblemId
    $crem :: ProblemId -> ProblemId -> ProblemId
    rem :: ProblemId -> ProblemId -> ProblemId
    $cdiv :: ProblemId -> ProblemId -> ProblemId
    div :: ProblemId -> ProblemId -> ProblemId
    $cmod :: ProblemId -> ProblemId -> ProblemId
    mod :: ProblemId -> ProblemId -> ProblemId
    $cquotRem :: ProblemId -> ProblemId -> (ProblemId, ProblemId)
    quotRem :: ProblemId -> ProblemId -> (ProblemId, ProblemId)
    $cdivMod :: ProblemId -> ProblemId -> (ProblemId, ProblemId)
    divMod :: ProblemId -> ProblemId -> (ProblemId, ProblemId)
    $ctoInteger :: ProblemId -> Integer
    toInteger :: ProblemId -> Integer
    Integral, Integer -> ProblemId
    ProblemId -> ProblemId
    ProblemId -> ProblemId -> ProblemId
    (ProblemId -> ProblemId -> ProblemId)
    -> (ProblemId -> ProblemId -> ProblemId)
    -> (ProblemId -> ProblemId -> ProblemId)
    -> (ProblemId -> ProblemId)
    -> (ProblemId -> ProblemId)
    -> (ProblemId -> ProblemId)
    -> (Integer -> ProblemId)
    -> Num ProblemId
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: ProblemId -> ProblemId -> ProblemId
    + :: ProblemId -> ProblemId -> ProblemId
    $c- :: ProblemId -> ProblemId -> ProblemId
    - :: ProblemId -> ProblemId -> ProblemId
    $c* :: ProblemId -> ProblemId -> ProblemId
    * :: ProblemId -> ProblemId -> ProblemId
    $cnegate :: ProblemId -> ProblemId
    negate :: ProblemId -> ProblemId
    $cabs :: ProblemId -> ProblemId
    abs :: ProblemId -> ProblemId
    $csignum :: ProblemId -> ProblemId
    signum :: ProblemId -> ProblemId
    $cfromInteger :: Integer -> ProblemId
    fromInteger :: Integer -> ProblemId
    Num, ProblemId -> ()
    (ProblemId -> ()) -> NFData ProblemId
    forall a. (a -> ()) -> NFData a
    $crnf :: ProblemId -> ()
    rnf :: ProblemId -> ()
    NFData)

    -- This particular Show instance is ok because of the Num instance.
    instance Show   ProblemId where show :: ProblemId -> ArgName
    show   (ProblemId Int
    n) = Int -> ArgName
    forall a. Show a => a -> ArgName
    show Int
    n
    instance Pretty ProblemId where pretty :: ProblemId -> Doc
    pretty (ProblemId Int
    n) = Int -> Doc
    forall a. Pretty a => a -> Doc
    pretty Int
    n

    -- | The unique identifier of an opaque block. Second argument is the
    -- top-level module identifier.
    data OpaqueId = OpaqueId {-# UNPACK #-} !Word64 {-# UNPACK #-} !ModuleNameHash
        deriving (OpaqueId -> OpaqueId -> Bool
    (OpaqueId -> OpaqueId -> Bool)
    -> (OpaqueId -> OpaqueId -> Bool) -> Eq OpaqueId
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OpaqueId -> OpaqueId -> Bool
    == :: OpaqueId -> OpaqueId -> Bool
    $c/= :: OpaqueId -> OpaqueId -> Bool
    /= :: OpaqueId -> OpaqueId -> Bool
    Eq, Eq OpaqueId
    Eq OpaqueId =>
    (OpaqueId -> OpaqueId -> Ordering)
    -> (OpaqueId -> OpaqueId -> Bool)
    -> (OpaqueId -> OpaqueId -> Bool)
    -> (OpaqueId -> OpaqueId -> Bool)
    -> (OpaqueId -> OpaqueId -> Bool)
    -> (OpaqueId -> OpaqueId -> OpaqueId)
    -> (OpaqueId -> OpaqueId -> OpaqueId)
    -> Ord OpaqueId
    OpaqueId -> OpaqueId -> Bool
    OpaqueId -> OpaqueId -> Ordering
    OpaqueId -> OpaqueId -> OpaqueId
    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
    $ccompare :: OpaqueId -> OpaqueId -> Ordering
    compare :: OpaqueId -> OpaqueId -> Ordering
    $c< :: OpaqueId -> OpaqueId -> Bool
    < :: OpaqueId -> OpaqueId -> Bool
    $c<= :: OpaqueId -> OpaqueId -> Bool
    <= :: OpaqueId -> OpaqueId -> Bool
    $c> :: OpaqueId -> OpaqueId -> Bool
    > :: OpaqueId -> OpaqueId -> Bool
    $c>= :: OpaqueId -> OpaqueId -> Bool
    >= :: OpaqueId -> OpaqueId -> Bool
    $cmax :: OpaqueId -> OpaqueId -> OpaqueId
    max :: OpaqueId -> OpaqueId -> OpaqueId
    $cmin :: OpaqueId -> OpaqueId -> OpaqueId
    min :: OpaqueId -> OpaqueId -> OpaqueId
    Ord, (forall x. OpaqueId -> Rep OpaqueId x)
    -> (forall x. Rep OpaqueId x -> OpaqueId) -> Generic OpaqueId
    forall x. Rep OpaqueId x -> OpaqueId
    forall x. OpaqueId -> Rep OpaqueId x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. OpaqueId -> Rep OpaqueId x
    from :: forall x. OpaqueId -> Rep OpaqueId x
    $cto :: forall x. Rep OpaqueId x -> OpaqueId
    to :: forall x. Rep OpaqueId x -> OpaqueId
    Generic, Int -> OpaqueId -> ShowS
    [OpaqueId] -> ShowS
    OpaqueId -> ArgName
    (Int -> OpaqueId -> ShowS)
    -> (OpaqueId -> ArgName) -> ([OpaqueId] -> ShowS) -> Show OpaqueId
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OpaqueId -> ShowS
    showsPrec :: Int -> OpaqueId -> ShowS
    $cshow :: OpaqueId -> ArgName
    show :: OpaqueId -> ArgName
    $cshowList :: [OpaqueId] -> ShowS
    showList :: [OpaqueId] -> ShowS
    Show)

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

    instance Pretty OpaqueId where
      pretty :: OpaqueId -> Doc
    pretty (OpaqueId Word64
    n ModuleNameHash
    m) = ArgName -> Doc
    forall a. ArgName -> Doc a
    text (ArgName -> Doc) -> ArgName -> Doc
    forall a b. (a -> b) -> a -> b
    $ Word64 -> ArgName
    forall a. Show a => a -> ArgName
    show Word64
    n ArgName -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ArgName
    "@" ArgName -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ModuleNameHash -> ArgName
    forall a. Show a => a -> ArgName
    show ModuleNameHash
    m

    instance Enum OpaqueId where
      succ :: OpaqueId -> OpaqueId
    succ (OpaqueId Word64
    n ModuleNameHash
    m)     = Word64 -> ModuleNameHash -> OpaqueId
    OpaqueId (Word64
    n Word64 -> Word64 -> Word64
    forall a. Num a => a -> a -> a
    + Word64
    1) ModuleNameHash
    m
      pred :: OpaqueId -> OpaqueId
    pred (OpaqueId Word64
    n ModuleNameHash
    m)     = Word64 -> ModuleNameHash -> OpaqueId
    OpaqueId (Word64
    n Word64 -> Word64 -> Word64
    forall a. Num a => a -> a -> a
    - Word64
    1) ModuleNameHash
    m
      toEnum :: Int -> OpaqueId
    toEnum Int
    n                = OpaqueId
    forall a. HasCallStack => a
    __IMPOSSIBLE__  -- should not be used
      fromEnum :: OpaqueId -> Int
    fromEnum (OpaqueId Word64
    n ModuleNameHash
    _) = Word64 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word64
    n

    instance NFData OpaqueId where
      rnf :: OpaqueId -> ()
    rnf (OpaqueId Word64
    _ ModuleNameHash
    _) = ()

    instance Hashable OpaqueId where
      {-# INLINE hashWithSalt #-}
      hashWithSalt :: Int -> OpaqueId -> Int
    hashWithSalt Int
    salt (OpaqueId Word64
    n (ModuleNameHash Word64
    m)) = Int -> (Word64, Word64) -> Int
    forall a. Hashable a => Int -> a -> Int
    hashWithSalt Int
    salt (Word64
    n, Word64
    m)

    ------------------------------------------------------------------------
    -- * Placeholders (used to parse sections)
    ------------------------------------------------------------------------

    -- | The position of a name part or underscore in a name.

    data PositionInName
      = Beginning
        -- ^ The following underscore is at the beginning of the name:
        -- @_foo@.
      | Middle
        -- ^ The following underscore is in the middle of the name:
        -- @foo_bar@.
      | End
        -- ^ The following underscore is at the end of the name: @foo_@.
      deriving (Int -> PositionInName -> ShowS
    [PositionInName] -> ShowS
    PositionInName -> ArgName
    (Int -> PositionInName -> ShowS)
    -> (PositionInName -> ArgName)
    -> ([PositionInName] -> ShowS)
    -> Show PositionInName
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PositionInName -> ShowS
    showsPrec :: Int -> PositionInName -> ShowS
    $cshow :: PositionInName -> ArgName
    show :: PositionInName -> ArgName
    $cshowList :: [PositionInName] -> ShowS
    showList :: [PositionInName] -> ShowS
    Show, PositionInName -> PositionInName -> Bool
    (PositionInName -> PositionInName -> Bool)
    -> (PositionInName -> PositionInName -> Bool) -> Eq PositionInName
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PositionInName -> PositionInName -> Bool
    == :: PositionInName -> PositionInName -> Bool
    $c/= :: PositionInName -> PositionInName -> Bool
    /= :: PositionInName -> PositionInName -> Bool
    Eq, Eq PositionInName
    Eq PositionInName =>
    (PositionInName -> PositionInName -> Ordering)
    -> (PositionInName -> PositionInName -> Bool)
    -> (PositionInName -> PositionInName -> Bool)
    -> (PositionInName -> PositionInName -> Bool)
    -> (PositionInName -> PositionInName -> Bool)
    -> (PositionInName -> PositionInName -> PositionInName)
    -> (PositionInName -> PositionInName -> PositionInName)
    -> Ord PositionInName
    PositionInName -> PositionInName -> Bool
    PositionInName -> PositionInName -> Ordering
    PositionInName -> PositionInName -> PositionInName
    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
    $ccompare :: PositionInName -> PositionInName -> Ordering
    compare :: PositionInName -> PositionInName -> Ordering
    $c< :: PositionInName -> PositionInName -> Bool
    < :: PositionInName -> PositionInName -> Bool
    $c<= :: PositionInName -> PositionInName -> Bool
    <= :: PositionInName -> PositionInName -> Bool
    $c> :: PositionInName -> PositionInName -> Bool
    > :: PositionInName -> PositionInName -> Bool
    $c>= :: PositionInName -> PositionInName -> Bool
    >= :: PositionInName -> PositionInName -> Bool
    $cmax :: PositionInName -> PositionInName -> PositionInName
    max :: PositionInName -> PositionInName -> PositionInName
    $cmin :: PositionInName -> PositionInName -> PositionInName
    min :: PositionInName -> PositionInName -> PositionInName
    Ord)

    -- | Placeholders are used to represent the underscores in a section.

    data MaybePlaceholder e
      = Placeholder !PositionInName
      | NoPlaceholder !(Strict.Maybe PositionInName) e
        -- ^ The second argument is used only (but not always) for name
        -- parts other than underscores.
      deriving (MaybePlaceholder e -> MaybePlaceholder e -> Bool
    (MaybePlaceholder e -> MaybePlaceholder e -> Bool)
    -> (MaybePlaceholder e -> MaybePlaceholder e -> Bool)
    -> Eq (MaybePlaceholder e)
    forall e. Eq e => MaybePlaceholder e -> MaybePlaceholder e -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall e. Eq e => MaybePlaceholder e -> MaybePlaceholder e -> Bool
    == :: MaybePlaceholder e -> MaybePlaceholder e -> Bool
    $c/= :: forall e. Eq e => MaybePlaceholder e -> MaybePlaceholder e -> Bool
    /= :: MaybePlaceholder e -> MaybePlaceholder e -> Bool
    Eq, Eq (MaybePlaceholder e)
    Eq (MaybePlaceholder e) =>
    (MaybePlaceholder e -> MaybePlaceholder e -> Ordering)
    -> (MaybePlaceholder e -> MaybePlaceholder e -> Bool)
    -> (MaybePlaceholder e -> MaybePlaceholder e -> Bool)
    -> (MaybePlaceholder e -> MaybePlaceholder e -> Bool)
    -> (MaybePlaceholder e -> MaybePlaceholder e -> Bool)
    -> (MaybePlaceholder e -> MaybePlaceholder e -> MaybePlaceholder e)
    -> (MaybePlaceholder e -> MaybePlaceholder e -> MaybePlaceholder e)
    -> Ord (MaybePlaceholder e)
    MaybePlaceholder e -> MaybePlaceholder e -> Bool
    MaybePlaceholder e -> MaybePlaceholder e -> Ordering
    MaybePlaceholder e -> MaybePlaceholder e -> MaybePlaceholder e
    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 e. Ord e => Eq (MaybePlaceholder e)
    forall e. Ord e => MaybePlaceholder e -> MaybePlaceholder e -> Bool
    forall e.
    Ord e =>
    MaybePlaceholder e -> MaybePlaceholder e -> Ordering
    forall e.
    Ord e =>
    MaybePlaceholder e -> MaybePlaceholder e -> MaybePlaceholder e
    $ccompare :: forall e.
    Ord e =>
    MaybePlaceholder e -> MaybePlaceholder e -> Ordering
    compare :: MaybePlaceholder e -> MaybePlaceholder e -> Ordering
    $c< :: forall e. Ord e => MaybePlaceholder e -> MaybePlaceholder e -> Bool
    < :: MaybePlaceholder e -> MaybePlaceholder e -> Bool
    $c<= :: forall e. Ord e => MaybePlaceholder e -> MaybePlaceholder e -> Bool
    <= :: MaybePlaceholder e -> MaybePlaceholder e -> Bool
    $c> :: forall e. Ord e => MaybePlaceholder e -> MaybePlaceholder e -> Bool
    > :: MaybePlaceholder e -> MaybePlaceholder e -> Bool
    $c>= :: forall e. Ord e => MaybePlaceholder e -> MaybePlaceholder e -> Bool
    >= :: MaybePlaceholder e -> MaybePlaceholder e -> Bool
    $cmax :: forall e.
    Ord e =>
    MaybePlaceholder e -> MaybePlaceholder e -> MaybePlaceholder e
    max :: MaybePlaceholder e -> MaybePlaceholder e -> MaybePlaceholder e
    $cmin :: forall e.
    Ord e =>
    MaybePlaceholder e -> MaybePlaceholder e -> MaybePlaceholder e
    min :: MaybePlaceholder e -> MaybePlaceholder e -> MaybePlaceholder e
    Ord, (forall a b. (a -> b) -> MaybePlaceholder a -> MaybePlaceholder b)
    -> (forall a b. a -> MaybePlaceholder b -> MaybePlaceholder a)
    -> Functor MaybePlaceholder
    forall a b. a -> MaybePlaceholder b -> MaybePlaceholder a
    forall a b. (a -> b) -> MaybePlaceholder a -> MaybePlaceholder b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> MaybePlaceholder a -> MaybePlaceholder b
    fmap :: forall a b. (a -> b) -> MaybePlaceholder a -> MaybePlaceholder b
    $c<$ :: forall a b. a -> MaybePlaceholder b -> MaybePlaceholder a
    <$ :: forall a b. a -> MaybePlaceholder b -> MaybePlaceholder a
    Functor, (forall m. Monoid m => MaybePlaceholder m -> m)
    -> (forall m a. Monoid m => (a -> m) -> MaybePlaceholder a -> m)
    -> (forall m a. Monoid m => (a -> m) -> MaybePlaceholder a -> m)
    -> (forall a b. (a -> b -> b) -> b -> MaybePlaceholder a -> b)
    -> (forall a b. (a -> b -> b) -> b -> MaybePlaceholder a -> b)
    -> (forall b a. (b -> a -> b) -> b -> MaybePlaceholder a -> b)
    -> (forall b a. (b -> a -> b) -> b -> MaybePlaceholder a -> b)
    -> (forall a. (a -> a -> a) -> MaybePlaceholder a -> a)
    -> (forall a. (a -> a -> a) -> MaybePlaceholder a -> a)
    -> (forall a. MaybePlaceholder a -> [a])
    -> (forall a. MaybePlaceholder a -> Bool)
    -> (forall a. MaybePlaceholder a -> Int)
    -> (forall a. Eq a => a -> MaybePlaceholder a -> Bool)
    -> (forall a. Ord a => MaybePlaceholder a -> a)
    -> (forall a. Ord a => MaybePlaceholder a -> a)
    -> (forall a. Num a => MaybePlaceholder a -> a)
    -> (forall a. Num a => MaybePlaceholder a -> a)
    -> Foldable MaybePlaceholder
    forall a. Eq a => a -> MaybePlaceholder a -> Bool
    forall a. Num a => MaybePlaceholder a -> a
    forall a. Ord a => MaybePlaceholder a -> a
    forall m. Monoid m => MaybePlaceholder m -> m
    forall a. MaybePlaceholder a -> Bool
    forall a. MaybePlaceholder a -> Int
    forall a. MaybePlaceholder a -> [a]
    forall a. (a -> a -> a) -> MaybePlaceholder a -> a
    forall m a. Monoid m => (a -> m) -> MaybePlaceholder a -> m
    forall b a. (b -> a -> b) -> b -> MaybePlaceholder a -> b
    forall a b. (a -> b -> b) -> b -> MaybePlaceholder 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
    $cfold :: forall m. Monoid m => MaybePlaceholder m -> m
    fold :: forall m. Monoid m => MaybePlaceholder m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> MaybePlaceholder a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> MaybePlaceholder a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> MaybePlaceholder a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> MaybePlaceholder a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> MaybePlaceholder a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> MaybePlaceholder a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> MaybePlaceholder a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> MaybePlaceholder a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> MaybePlaceholder a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> MaybePlaceholder a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> MaybePlaceholder a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> MaybePlaceholder a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> MaybePlaceholder a -> a
    foldr1 :: forall a. (a -> a -> a) -> MaybePlaceholder a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> MaybePlaceholder a -> a
    foldl1 :: forall a. (a -> a -> a) -> MaybePlaceholder a -> a
    $ctoList :: forall a. MaybePlaceholder a -> [a]
    toList :: forall a. MaybePlaceholder a -> [a]
    $cnull :: forall a. MaybePlaceholder a -> Bool
    null :: forall a. MaybePlaceholder a -> Bool
    $clength :: forall a. MaybePlaceholder a -> Int
    length :: forall a. MaybePlaceholder a -> Int
    $celem :: forall a. Eq a => a -> MaybePlaceholder a -> Bool
    elem :: forall a. Eq a => a -> MaybePlaceholder a -> Bool
    $cmaximum :: forall a. Ord a => MaybePlaceholder a -> a
    maximum :: forall a. Ord a => MaybePlaceholder a -> a
    $cminimum :: forall a. Ord a => MaybePlaceholder a -> a
    minimum :: forall a. Ord a => MaybePlaceholder a -> a
    $csum :: forall a. Num a => MaybePlaceholder a -> a
    sum :: forall a. Num a => MaybePlaceholder a -> a
    $cproduct :: forall a. Num a => MaybePlaceholder a -> a
    product :: forall a. Num a => MaybePlaceholder a -> a
    Foldable, Functor MaybePlaceholder
    Foldable MaybePlaceholder
    (Functor MaybePlaceholder, Foldable MaybePlaceholder) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> MaybePlaceholder a -> f (MaybePlaceholder b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        MaybePlaceholder (f a) -> f (MaybePlaceholder a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> MaybePlaceholder a -> m (MaybePlaceholder b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        MaybePlaceholder (m a) -> m (MaybePlaceholder a))
    -> Traversable MaybePlaceholder
    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 =>
    MaybePlaceholder (m a) -> m (MaybePlaceholder a)
    forall (f :: * -> *) a.
    Applicative f =>
    MaybePlaceholder (f a) -> f (MaybePlaceholder a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MaybePlaceholder a -> m (MaybePlaceholder b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> MaybePlaceholder a -> f (MaybePlaceholder b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> MaybePlaceholder a -> f (MaybePlaceholder b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> MaybePlaceholder a -> f (MaybePlaceholder b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    MaybePlaceholder (f a) -> f (MaybePlaceholder a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    MaybePlaceholder (f a) -> f (MaybePlaceholder a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MaybePlaceholder a -> m (MaybePlaceholder b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MaybePlaceholder a -> m (MaybePlaceholder b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    MaybePlaceholder (m a) -> m (MaybePlaceholder a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    MaybePlaceholder (m a) -> m (MaybePlaceholder a)
    Traversable, Int -> MaybePlaceholder e -> ShowS
    [MaybePlaceholder e] -> ShowS
    MaybePlaceholder e -> ArgName
    (Int -> MaybePlaceholder e -> ShowS)
    -> (MaybePlaceholder e -> ArgName)
    -> ([MaybePlaceholder e] -> ShowS)
    -> Show (MaybePlaceholder e)
    forall e. Show e => Int -> MaybePlaceholder e -> ShowS
    forall e. Show e => [MaybePlaceholder e] -> ShowS
    forall e. Show e => MaybePlaceholder e -> ArgName
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall e. Show e => Int -> MaybePlaceholder e -> ShowS
    showsPrec :: Int -> MaybePlaceholder e -> ShowS
    $cshow :: forall e. Show e => MaybePlaceholder e -> ArgName
    show :: MaybePlaceholder e -> ArgName
    $cshowList :: forall e. Show e => [MaybePlaceholder e] -> ShowS
    showList :: [MaybePlaceholder e] -> ShowS
    Show)

    -- | An abbreviation: @noPlaceholder = 'NoPlaceholder'
    -- 'Strict.Nothing'@.

    noPlaceholder :: e -> MaybePlaceholder e
    noPlaceholder :: forall e. e -> MaybePlaceholder e
    noPlaceholder = Maybe PositionInName -> e -> MaybePlaceholder e
    forall e. Maybe PositionInName -> e -> MaybePlaceholder e
    NoPlaceholder Maybe PositionInName
    forall a. Maybe a
    Strict.Nothing

    instance HasRange a => HasRange (MaybePlaceholder a) where
      getRange :: MaybePlaceholder a -> Range
    getRange Placeholder{}       = Range
    forall a. Range' a
    noRange
      getRange (NoPlaceholder Maybe PositionInName
    _ a
    e) = a -> Range
    forall a. HasRange a => a -> Range
    getRange a
    e

    instance KillRange a => KillRange (MaybePlaceholder a) where
      killRange :: KillRangeT (MaybePlaceholder a)
    killRange p :: MaybePlaceholder a
    p@Placeholder{}     = MaybePlaceholder a
    p
      killRange (NoPlaceholder Maybe PositionInName
    p a
    e) = (a -> MaybePlaceholder a) -> a -> MaybePlaceholder a
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN (Maybe PositionInName -> a -> MaybePlaceholder a
    forall e. Maybe PositionInName -> e -> MaybePlaceholder e
    NoPlaceholder Maybe PositionInName
    p) a
    e

    instance NFData a => NFData (MaybePlaceholder a) where
      rnf :: MaybePlaceholder a -> ()
    rnf (Placeholder PositionInName
    _)     = ()
      rnf (NoPlaceholder Maybe PositionInName
    _ a
    a) = a -> ()
    forall a. NFData a => a -> ()
    rnf a
    a

    ---------------------------------------------------------------------------
    -- * Interaction meta variables
    ---------------------------------------------------------------------------

    newtype InteractionId = InteractionId { InteractionId -> Int
    interactionId :: Nat }
        deriving ( InteractionId -> InteractionId -> Bool
    (InteractionId -> InteractionId -> Bool)
    -> (InteractionId -> InteractionId -> Bool) -> Eq InteractionId
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: InteractionId -> InteractionId -> Bool
    == :: InteractionId -> InteractionId -> Bool
    $c/= :: InteractionId -> InteractionId -> Bool
    /= :: InteractionId -> InteractionId -> Bool
    Eq
                 , Eq InteractionId
    Eq InteractionId =>
    (InteractionId -> InteractionId -> Ordering)
    -> (InteractionId -> InteractionId -> Bool)
    -> (InteractionId -> InteractionId -> Bool)
    -> (InteractionId -> InteractionId -> Bool)
    -> (InteractionId -> InteractionId -> Bool)
    -> (InteractionId -> InteractionId -> InteractionId)
    -> (InteractionId -> InteractionId -> InteractionId)
    -> Ord InteractionId
    InteractionId -> InteractionId -> Bool
    InteractionId -> InteractionId -> Ordering
    InteractionId -> InteractionId -> InteractionId
    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
    $ccompare :: InteractionId -> InteractionId -> Ordering
    compare :: InteractionId -> InteractionId -> Ordering
    $c< :: InteractionId -> InteractionId -> Bool
    < :: InteractionId -> InteractionId -> Bool
    $c<= :: InteractionId -> InteractionId -> Bool
    <= :: InteractionId -> InteractionId -> Bool
    $c> :: InteractionId -> InteractionId -> Bool
    > :: InteractionId -> InteractionId -> Bool
    $c>= :: InteractionId -> InteractionId -> Bool
    >= :: InteractionId -> InteractionId -> Bool
    $cmax :: InteractionId -> InteractionId -> InteractionId
    max :: InteractionId -> InteractionId -> InteractionId
    $cmin :: InteractionId -> InteractionId -> InteractionId
    min :: InteractionId -> InteractionId -> InteractionId
    Ord
                 , Int -> InteractionId -> ShowS
    [InteractionId] -> ShowS
    InteractionId -> ArgName
    (Int -> InteractionId -> ShowS)
    -> (InteractionId -> ArgName)
    -> ([InteractionId] -> ShowS)
    -> Show InteractionId
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> InteractionId -> ShowS
    showsPrec :: Int -> InteractionId -> ShowS
    $cshow :: InteractionId -> ArgName
    show :: InteractionId -> ArgName
    $cshowList :: [InteractionId] -> ShowS
    showList :: [InteractionId] -> ShowS
    Show
                 , Integer -> InteractionId
    InteractionId -> InteractionId
    InteractionId -> InteractionId -> InteractionId
    (InteractionId -> InteractionId -> InteractionId)
    -> (InteractionId -> InteractionId -> InteractionId)
    -> (InteractionId -> InteractionId -> InteractionId)
    -> (InteractionId -> InteractionId)
    -> (InteractionId -> InteractionId)
    -> (InteractionId -> InteractionId)
    -> (Integer -> InteractionId)
    -> Num InteractionId
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: InteractionId -> InteractionId -> InteractionId
    + :: InteractionId -> InteractionId -> InteractionId
    $c- :: InteractionId -> InteractionId -> InteractionId
    - :: InteractionId -> InteractionId -> InteractionId
    $c* :: InteractionId -> InteractionId -> InteractionId
    * :: InteractionId -> InteractionId -> InteractionId
    $cnegate :: InteractionId -> InteractionId
    negate :: InteractionId -> InteractionId
    $cabs :: InteractionId -> InteractionId
    abs :: InteractionId -> InteractionId
    $csignum :: InteractionId -> InteractionId
    signum :: InteractionId -> InteractionId
    $cfromInteger :: Integer -> InteractionId
    fromInteger :: Integer -> InteractionId
    Num
                 , Enum InteractionId
    Real InteractionId
    (Real InteractionId, Enum InteractionId) =>
    (InteractionId -> InteractionId -> InteractionId)
    -> (InteractionId -> InteractionId -> InteractionId)
    -> (InteractionId -> InteractionId -> InteractionId)
    -> (InteractionId -> InteractionId -> InteractionId)
    -> (InteractionId
        -> InteractionId -> (InteractionId, InteractionId))
    -> (InteractionId
        -> InteractionId -> (InteractionId, InteractionId))
    -> (InteractionId -> Integer)
    -> Integral InteractionId
    InteractionId -> Integer
    InteractionId -> InteractionId -> (InteractionId, InteractionId)
    InteractionId -> InteractionId -> InteractionId
    forall a.
    (Real a, Enum a) =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: InteractionId -> InteractionId -> InteractionId
    quot :: InteractionId -> InteractionId -> InteractionId
    $crem :: InteractionId -> InteractionId -> InteractionId
    rem :: InteractionId -> InteractionId -> InteractionId
    $cdiv :: InteractionId -> InteractionId -> InteractionId
    div :: InteractionId -> InteractionId -> InteractionId
    $cmod :: InteractionId -> InteractionId -> InteractionId
    mod :: InteractionId -> InteractionId -> InteractionId
    $cquotRem :: InteractionId -> InteractionId -> (InteractionId, InteractionId)
    quotRem :: InteractionId -> InteractionId -> (InteractionId, InteractionId)
    $cdivMod :: InteractionId -> InteractionId -> (InteractionId, InteractionId)
    divMod :: InteractionId -> InteractionId -> (InteractionId, InteractionId)
    $ctoInteger :: InteractionId -> Integer
    toInteger :: InteractionId -> Integer
    Integral
                 , Num InteractionId
    Ord InteractionId
    (Num InteractionId, Ord InteractionId) =>
    (InteractionId -> Rational) -> Real InteractionId
    InteractionId -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: InteractionId -> Rational
    toRational :: InteractionId -> Rational
    Real
                 , Int -> InteractionId
    InteractionId -> Int
    InteractionId -> [InteractionId]
    InteractionId -> InteractionId
    InteractionId -> InteractionId -> [InteractionId]
    InteractionId -> InteractionId -> InteractionId -> [InteractionId]
    (InteractionId -> InteractionId)
    -> (InteractionId -> InteractionId)
    -> (Int -> InteractionId)
    -> (InteractionId -> Int)
    -> (InteractionId -> [InteractionId])
    -> (InteractionId -> InteractionId -> [InteractionId])
    -> (InteractionId -> InteractionId -> [InteractionId])
    -> (InteractionId
        -> InteractionId -> InteractionId -> [InteractionId])
    -> Enum InteractionId
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: InteractionId -> InteractionId
    succ :: InteractionId -> InteractionId
    $cpred :: InteractionId -> InteractionId
    pred :: InteractionId -> InteractionId
    $ctoEnum :: Int -> InteractionId
    toEnum :: Int -> InteractionId
    $cfromEnum :: InteractionId -> Int
    fromEnum :: InteractionId -> Int
    $cenumFrom :: InteractionId -> [InteractionId]
    enumFrom :: InteractionId -> [InteractionId]
    $cenumFromThen :: InteractionId -> InteractionId -> [InteractionId]
    enumFromThen :: InteractionId -> InteractionId -> [InteractionId]
    $cenumFromTo :: InteractionId -> InteractionId -> [InteractionId]
    enumFromTo :: InteractionId -> InteractionId -> [InteractionId]
    $cenumFromThenTo :: InteractionId -> InteractionId -> InteractionId -> [InteractionId]
    enumFromThenTo :: InteractionId -> InteractionId -> InteractionId -> [InteractionId]
    Enum
                 , InteractionId -> ()
    (InteractionId -> ()) -> NFData InteractionId
    forall a. (a -> ()) -> NFData a
    $crnf :: InteractionId -> ()
    rnf :: InteractionId -> ()
    NFData
                 )

    instance Pretty InteractionId where
        pretty :: InteractionId -> Doc
    pretty (InteractionId Int
    i) = ArgName -> Doc
    forall a. ArgName -> Doc a
    text (ArgName -> Doc) -> ArgName -> Doc
    forall a b. (a -> b) -> a -> b
    $ ArgName
    "?" ArgName -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> ArgName
    forall a. Show a => a -> ArgName
    show Int
    i

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

    ---------------------------------------------------------------------------
    -- * Fixity
    ---------------------------------------------------------------------------

    -- | Precedence levels for operators.

    type PrecedenceLevel = Double

    data FixityLevel
      = Unrelated
        -- ^ No fixity declared.
      | Related !PrecedenceLevel
        -- ^ Fixity level declared as the number.
      deriving (FixityLevel -> FixityLevel -> Bool
    (FixityLevel -> FixityLevel -> Bool)
    -> (FixityLevel -> FixityLevel -> Bool) -> Eq FixityLevel
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FixityLevel -> FixityLevel -> Bool
    == :: FixityLevel -> FixityLevel -> Bool
    $c/= :: FixityLevel -> FixityLevel -> Bool
    /= :: FixityLevel -> FixityLevel -> Bool
    Eq, Eq FixityLevel
    Eq FixityLevel =>
    (FixityLevel -> FixityLevel -> Ordering)
    -> (FixityLevel -> FixityLevel -> Bool)
    -> (FixityLevel -> FixityLevel -> Bool)
    -> (FixityLevel -> FixityLevel -> Bool)
    -> (FixityLevel -> FixityLevel -> Bool)
    -> (FixityLevel -> FixityLevel -> FixityLevel)
    -> (FixityLevel -> FixityLevel -> FixityLevel)
    -> Ord FixityLevel
    FixityLevel -> FixityLevel -> Bool
    FixityLevel -> FixityLevel -> Ordering
    FixityLevel -> FixityLevel -> FixityLevel
    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
    $ccompare :: FixityLevel -> FixityLevel -> Ordering
    compare :: FixityLevel -> FixityLevel -> Ordering
    $c< :: FixityLevel -> FixityLevel -> Bool
    < :: FixityLevel -> FixityLevel -> Bool
    $c<= :: FixityLevel -> FixityLevel -> Bool
    <= :: FixityLevel -> FixityLevel -> Bool
    $c> :: FixityLevel -> FixityLevel -> Bool
    > :: FixityLevel -> FixityLevel -> Bool
    $c>= :: FixityLevel -> FixityLevel -> Bool
    >= :: FixityLevel -> FixityLevel -> Bool
    $cmax :: FixityLevel -> FixityLevel -> FixityLevel
    max :: FixityLevel -> FixityLevel -> FixityLevel
    $cmin :: FixityLevel -> FixityLevel -> FixityLevel
    min :: FixityLevel -> FixityLevel -> FixityLevel
    Ord, Int -> FixityLevel -> ShowS
    [FixityLevel] -> ShowS
    FixityLevel -> ArgName
    (Int -> FixityLevel -> ShowS)
    -> (FixityLevel -> ArgName)
    -> ([FixityLevel] -> ShowS)
    -> Show FixityLevel
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FixityLevel -> ShowS
    showsPrec :: Int -> FixityLevel -> ShowS
    $cshow :: FixityLevel -> ArgName
    show :: FixityLevel -> ArgName
    $cshowList :: [FixityLevel] -> ShowS
    showList :: [FixityLevel] -> ShowS
    Show)

    instance Null FixityLevel where
      null :: FixityLevel -> Bool
    null FixityLevel
    Unrelated = Bool
    True
      null Related{} = Bool
    False
      empty :: FixityLevel
    empty = FixityLevel
    Unrelated

    instance NFData FixityLevel where
      rnf :: FixityLevel -> ()
    rnf FixityLevel
    Unrelated   = ()
      rnf (Related PrecedenceLevel
    _) = ()

    instance Pretty FixityLevel where
      pretty :: FixityLevel -> Doc
    pretty = \case
        FixityLevel
    Unrelated  -> Doc
    forall a. Null a => a
    empty
        Related PrecedenceLevel
    d  -> ArgName -> Doc
    forall a. ArgName -> Doc a
    text (ArgName -> Doc) -> ArgName -> Doc
    forall a b. (a -> b) -> a -> b
    $ PrecedenceLevel -> ArgName
    toStringWithoutDotZero PrecedenceLevel
    d

    -- | Associativity.

    data Associativity = NonAssoc | LeftAssoc | RightAssoc
       deriving (Associativity -> Associativity -> Bool
    (Associativity -> Associativity -> Bool)
    -> (Associativity -> Associativity -> Bool) -> Eq Associativity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Associativity -> Associativity -> Bool
    == :: Associativity -> Associativity -> Bool
    $c/= :: Associativity -> Associativity -> Bool
    /= :: Associativity -> Associativity -> Bool
    Eq, Eq Associativity
    Eq Associativity =>
    (Associativity -> Associativity -> Ordering)
    -> (Associativity -> Associativity -> Bool)
    -> (Associativity -> Associativity -> Bool)
    -> (Associativity -> Associativity -> Bool)
    -> (Associativity -> Associativity -> Bool)
    -> (Associativity -> Associativity -> Associativity)
    -> (Associativity -> Associativity -> Associativity)
    -> Ord Associativity
    Associativity -> Associativity -> Bool
    Associativity -> Associativity -> Ordering
    Associativity -> Associativity -> Associativity
    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
    $ccompare :: Associativity -> Associativity -> Ordering
    compare :: Associativity -> Associativity -> Ordering
    $c< :: Associativity -> Associativity -> Bool
    < :: Associativity -> Associativity -> Bool
    $c<= :: Associativity -> Associativity -> Bool
    <= :: Associativity -> Associativity -> Bool
    $c> :: Associativity -> Associativity -> Bool
    > :: Associativity -> Associativity -> Bool
    $c>= :: Associativity -> Associativity -> Bool
    >= :: Associativity -> Associativity -> Bool
    $cmax :: Associativity -> Associativity -> Associativity
    max :: Associativity -> Associativity -> Associativity
    $cmin :: Associativity -> Associativity -> Associativity
    min :: Associativity -> Associativity -> Associativity
    Ord, Int -> Associativity -> ShowS
    [Associativity] -> ShowS
    Associativity -> ArgName
    (Int -> Associativity -> ShowS)
    -> (Associativity -> ArgName)
    -> ([Associativity] -> ShowS)
    -> Show Associativity
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Associativity -> ShowS
    showsPrec :: Int -> Associativity -> ShowS
    $cshow :: Associativity -> ArgName
    show :: Associativity -> ArgName
    $cshowList :: [Associativity] -> ShowS
    showList :: [Associativity] -> ShowS
    Show)

    instance Pretty Associativity where
      pretty :: Associativity -> Doc
    pretty = \case
        Associativity
    LeftAssoc  -> Doc
    "infixl"
        Associativity
    RightAssoc -> Doc
    "infixr"
        Associativity
    NonAssoc   -> Doc
    "infix"

    -- | Fixity of operators.

    data Fixity = Fixity
      { Fixity -> Range
    fixityRange :: Range
        -- ^ Range of the whole fixity declaration.
      , Fixity -> FixityLevel
    fixityLevel :: !FixityLevel
      , Fixity -> Associativity
    fixityAssoc :: !Associativity
      }
      deriving Int -> Fixity -> ShowS
    [Fixity] -> ShowS
    Fixity -> ArgName
    (Int -> Fixity -> ShowS)
    -> (Fixity -> ArgName) -> ([Fixity] -> ShowS) -> Show Fixity
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Fixity -> ShowS
    showsPrec :: Int -> Fixity -> ShowS
    $cshow :: Fixity -> ArgName
    show :: Fixity -> ArgName
    $cshowList :: [Fixity] -> ShowS
    showList :: [Fixity] -> ShowS
    Show

    noFixity :: Fixity
    noFixity :: Fixity
    noFixity = Range -> FixityLevel -> Associativity -> Fixity
    Fixity Range
    forall a. Range' a
    noRange FixityLevel
    Unrelated Associativity
    NonAssoc

    defaultFixity :: Fixity
    defaultFixity :: Fixity
    defaultFixity = Range -> FixityLevel -> Associativity -> Fixity
    Fixity Range
    forall a. Range' a
    noRange (PrecedenceLevel -> FixityLevel
    Related PrecedenceLevel
    20) Associativity
    NonAssoc

    -- For @instance Pretty Fixity@, see Agda.Syntax.Concrete.Pretty

    instance Eq Fixity where
      Fixity
    f1 == :: Fixity -> Fixity -> Bool
    == Fixity
    f2 = Fixity -> Fixity -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare Fixity
    f1 Fixity
    f2 Ordering -> Ordering -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ordering
    EQ

    instance Ord Fixity where
      compare :: Fixity -> Fixity -> Ordering
    compare = (FixityLevel, Associativity)
    -> (FixityLevel, Associativity) -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare ((FixityLevel, Associativity)
     -> (FixityLevel, Associativity) -> Ordering)
    -> (Fixity -> (FixityLevel, Associativity))
    -> Fixity
    -> Fixity
    -> Ordering
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` (Fixity -> FixityLevel
    fixityLevel (Fixity -> FixityLevel)
    -> (Fixity -> Associativity)
    -> Fixity
    -> (FixityLevel, Associativity)
    forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
    forall (a :: * -> * -> *) b c c'.
    Arrow a =>
    a b c -> a b c' -> a b (c, c')
    &&& Fixity -> Associativity
    fixityAssoc)

    instance Null Fixity where
      null :: Fixity -> Bool
    null  = FixityLevel -> Bool
    forall a. Null a => a -> Bool
    null (FixityLevel -> Bool) -> (Fixity -> FixityLevel) -> Fixity -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Fixity -> FixityLevel
    fixityLevel
      empty :: Fixity
    empty = Fixity
    noFixity

    instance HasRange Fixity where
      getRange :: Fixity -> Range
    getRange = Fixity -> Range
    fixityRange

    instance KillRange Fixity where
      killRange :: Fixity -> Fixity
    killRange Fixity
    f = Fixity
    f { fixityRange = noRange }

    instance NFData Fixity where
      rnf :: Fixity -> ()
    rnf (Fixity Range
    _ FixityLevel
    _ Associativity
    _) = ()     -- Ranges are not forced, the other fields are strict.

    instance Pretty Fixity where
      pretty :: Fixity -> Doc
    pretty (Fixity Range
    _ FixityLevel
    level Associativity
    ass) = case FixityLevel
    level of
        FixityLevel
    Unrelated  -> Doc
    forall a. Null a => a
    empty
        Related{}  -> Associativity -> Doc
    forall a. Pretty a => a -> Doc
    pretty Associativity
    ass Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+> FixityLevel -> Doc
    forall a. Pretty a => a -> Doc
    pretty FixityLevel
    level

    -- ** Notation coupled with 'Fixity'

    -- | The notation is handled as the fixity in the renamer.
    --   Hence, they are grouped together in this type.
    data Fixity' = Fixity'
        { Fixity' -> Fixity
    theFixity   :: !Fixity
        , Fixity' -> Notation
    theNotation :: Notation
        , Fixity' -> Range
    theNameRange :: Range
          -- ^ Range of the name in the fixity declaration
          --   (used for correct highlighting, see issue #2140).
        }
      deriving Int -> Fixity' -> ShowS
    [Fixity'] -> ShowS
    Fixity' -> ArgName
    (Int -> Fixity' -> ShowS)
    -> (Fixity' -> ArgName) -> ([Fixity'] -> ShowS) -> Show Fixity'
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Fixity' -> ShowS
    showsPrec :: Int -> Fixity' -> ShowS
    $cshow :: Fixity' -> ArgName
    show :: Fixity' -> ArgName
    $cshowList :: [Fixity'] -> ShowS
    showList :: [Fixity'] -> ShowS
    Show

    noFixity' :: Fixity'
    noFixity' :: Fixity'
    noFixity' = Fixity -> Notation -> Range -> Fixity'
    Fixity' Fixity
    noFixity Notation
    noNotation Range
    forall a. Range' a
    noRange

    instance Eq Fixity' where
      Fixity' Fixity
    f Notation
    n Range
    _ == :: Fixity' -> Fixity' -> Bool
    == Fixity' Fixity
    f' Notation
    n' Range
    _ = Fixity
    f Fixity -> Fixity -> Bool
    forall a. Eq a => a -> a -> Bool
    == Fixity
    f' Bool -> Bool -> Bool
    && Notation
    n Notation -> Notation -> Bool
    forall a. Eq a => a -> a -> Bool
    == Notation
    n'

    instance Null Fixity' where
      null :: Fixity' -> Bool
    null (Fixity' Fixity
    f Notation
    n Range
    _) = Fixity -> Bool
    forall a. Null a => a -> Bool
    null Fixity
    f Bool -> Bool -> Bool
    && Notation -> Bool
    forall a. Null a => a -> Bool
    null Notation
    n
      empty :: Fixity'
    empty = Fixity'
    noFixity'

    instance NFData Fixity' where
      rnf :: Fixity' -> ()
    rnf (Fixity' Fixity
    _ Notation
    a Range
    _) = Notation -> ()
    forall a. NFData a => a -> ()
    rnf Notation
    a

    instance KillRange Fixity' where
      killRange :: KillRangeT Fixity'
    killRange (Fixity' Fixity
    f Notation
    n Range
    r) = (Fixity -> Notation -> Range -> Fixity')
    -> Fixity -> Notation -> Range -> Fixity'
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN Fixity -> Notation -> Range -> Fixity'
    Fixity' Fixity
    f Notation
    n Range
    r

    -- lenses

    _fixityAssoc :: Lens' Fixity Associativity
    _fixityAssoc :: Lens' Fixity Associativity
    _fixityAssoc Associativity -> f Associativity
    f Fixity
    r = Associativity -> f Associativity
    f (Fixity -> Associativity
    fixityAssoc Fixity
    r) f Associativity -> (Associativity -> Fixity) -> f Fixity
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \Associativity
    x -> Fixity
    r { fixityAssoc = x }

    _fixityLevel :: Lens' Fixity FixityLevel
    _fixityLevel :: Lens' Fixity FixityLevel
    _fixityLevel FixityLevel -> f FixityLevel
    f Fixity
    r = FixityLevel -> f FixityLevel
    f (Fixity -> FixityLevel
    fixityLevel Fixity
    r) f FixityLevel -> (FixityLevel -> Fixity) -> f Fixity
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \FixityLevel
    x -> Fixity
    r { fixityLevel = x }

    -- Lens focusing on Fixity

    class LensFixity a where
      lensFixity :: Lens' a Fixity

    instance LensFixity Fixity where
      lensFixity :: Lens' Fixity Fixity
    lensFixity = (Fixity -> f Fixity) -> Fixity -> f Fixity
    forall a. a -> a
    id

    instance LensFixity Fixity' where
      lensFixity :: Lens' Fixity' Fixity
    lensFixity Fixity -> f Fixity
    f Fixity'
    fix' = Fixity -> f Fixity
    f (Fixity' -> Fixity
    theFixity Fixity'
    fix') f Fixity -> (Fixity -> Fixity') -> f Fixity'
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \ Fixity
    fx -> Fixity'
    fix' { theFixity = fx }

    -- Lens focusing on Fixity'

    class LensFixity' a where
      lensFixity' :: Lens' a Fixity'

    instance LensFixity' Fixity' where
      lensFixity' :: Lens' Fixity' Fixity'
    lensFixity' = (Fixity' -> f Fixity') -> Fixity' -> f Fixity'
    forall a. a -> a
    id

    ---------------------------------------------------------------------------
    -- * Import directive
    ---------------------------------------------------------------------------

    -- | The things you are allowed to say when you shuffle names between name
    --   spaces (i.e. in @import@, @namespace@, or @open@ declarations).
    data ImportDirective' n m = ImportDirective
      { forall n m. ImportDirective' n m -> Range
    importDirRange :: Range
      , forall n m. ImportDirective' n m -> Using' n m
    using          :: Using' n m
      , forall n m. ImportDirective' n m -> HidingDirective' n m
    hiding         :: HidingDirective' n m
      , forall n m. ImportDirective' n m -> RenamingDirective' n m
    impRenaming    :: RenamingDirective' n m
      , forall n m. ImportDirective' n m -> Maybe KwRange
    publicOpen     :: Maybe KwRange
          -- ^ Only for @open@. Exports the opened names from the current module.
          --   Range of the @public@ keyword.
      }
      deriving (ImportDirective' n m -> ImportDirective' n m -> Bool
    (ImportDirective' n m -> ImportDirective' n m -> Bool)
    -> (ImportDirective' n m -> ImportDirective' n m -> Bool)
    -> Eq (ImportDirective' n m)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall n m.
    (Eq m, Eq n) =>
    ImportDirective' n m -> ImportDirective' n m -> Bool
    $c== :: forall n m.
    (Eq m, Eq n) =>
    ImportDirective' n m -> ImportDirective' n m -> Bool
    == :: ImportDirective' n m -> ImportDirective' n m -> Bool
    $c/= :: forall n m.
    (Eq m, Eq n) =>
    ImportDirective' n m -> ImportDirective' n m -> Bool
    /= :: ImportDirective' n m -> ImportDirective' n m -> Bool
    Eq, Int -> ImportDirective' n m -> ShowS
    [ImportDirective' n m] -> ShowS
    ImportDirective' n m -> ArgName
    (Int -> ImportDirective' n m -> ShowS)
    -> (ImportDirective' n m -> ArgName)
    -> ([ImportDirective' n m] -> ShowS)
    -> Show (ImportDirective' n m)
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    forall n m.
    (Show m, Show n) =>
    Int -> ImportDirective' n m -> ShowS
    forall n m. (Show m, Show n) => [ImportDirective' n m] -> ShowS
    forall n m. (Show m, Show n) => ImportDirective' n m -> ArgName
    $cshowsPrec :: forall n m.
    (Show m, Show n) =>
    Int -> ImportDirective' n m -> ShowS
    showsPrec :: Int -> ImportDirective' n m -> ShowS
    $cshow :: forall n m. (Show m, Show n) => ImportDirective' n m -> ArgName
    show :: ImportDirective' n m -> ArgName
    $cshowList :: forall n m. (Show m, Show n) => [ImportDirective' n m] -> ShowS
    showList :: [ImportDirective' n m] -> ShowS
    Show)

    type HidingDirective'   n m = [ImportedName' n m]
    type RenamingDirective' n m = [Renaming' n m]

    -- | @null@ for import directives holds when everything is imported unchanged
    --   (no names are hidden or renamed).
    instance Null (ImportDirective' n m) where
      null :: ImportDirective' n m -> Bool
    null = \case
        ImportDirective Range
    _ Using' n m
    UseEverything [] [] Maybe KwRange
    _ -> Bool
    True
        ImportDirective' n m
    _ -> Bool
    False
      empty :: ImportDirective' n m
    empty = ImportDirective' n m
    forall n m. ImportDirective' n m
    defaultImportDir

    instance (HasRange n, HasRange m) => Semigroup (ImportDirective' n m) where
      ImportDirective' n m
    i1 <> :: ImportDirective' n m
    -> ImportDirective' n m -> ImportDirective' n m
    <> ImportDirective' n m
    i2 = ImportDirective
        { importDirRange :: Range
    importDirRange = ImportDirective' n m -> ImportDirective' n m -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange ImportDirective' n m
    i1 ImportDirective' n m
    i2
        , using :: Using' n m
    using          = ImportDirective' n m -> Using' n m
    forall n m. ImportDirective' n m -> Using' n m
    using ImportDirective' n m
    i1 Using' n m -> Using' n m -> Using' n m
    forall a. Semigroup a => a -> a -> a
    <> ImportDirective' n m -> Using' n m
    forall n m. ImportDirective' n m -> Using' n m
    using ImportDirective' n m
    i2
        , hiding :: HidingDirective' n m
    hiding         = ImportDirective' n m -> HidingDirective' n m
    forall n m. ImportDirective' n m -> HidingDirective' n m
    hiding ImportDirective' n m
    i1 HidingDirective' n m
    -> HidingDirective' n m -> HidingDirective' n m
    forall a. [a] -> [a] -> [a]
    ++ ImportDirective' n m -> HidingDirective' n m
    forall n m. ImportDirective' n m -> HidingDirective' n m
    hiding ImportDirective' n m
    i2
        , impRenaming :: RenamingDirective' n m
    impRenaming    = ImportDirective' n m -> RenamingDirective' n m
    forall n m. ImportDirective' n m -> RenamingDirective' n m
    impRenaming ImportDirective' n m
    i1 RenamingDirective' n m
    -> RenamingDirective' n m -> RenamingDirective' n m
    forall a. [a] -> [a] -> [a]
    ++ ImportDirective' n m -> RenamingDirective' n m
    forall n m. ImportDirective' n m -> RenamingDirective' n m
    impRenaming ImportDirective' n m
    i2
        , publicOpen :: Maybe KwRange
    publicOpen     = ImportDirective' n m -> Maybe KwRange
    forall n m. ImportDirective' n m -> Maybe KwRange
    publicOpen ImportDirective' n m
    i1 Maybe KwRange -> Maybe KwRange -> Maybe KwRange
    forall a. Maybe a -> Maybe a -> Maybe a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ImportDirective' n m -> Maybe KwRange
    forall n m. ImportDirective' n m -> Maybe KwRange
    publicOpen ImportDirective' n m
    i2
        }

    instance (HasRange n, HasRange m) => Monoid (ImportDirective' n m) where
      mempty :: ImportDirective' n m
    mempty  = ImportDirective' n m
    forall a. Null a => a
    empty
      mappend :: ImportDirective' n m
    -> ImportDirective' n m -> ImportDirective' n m
    mappend = ImportDirective' n m
    -> ImportDirective' n m -> ImportDirective' n m
    forall a. Semigroup a => a -> a -> a
    (<>)

    -- | Default is directive is @private@ (use everything, but do not export).
    defaultImportDir :: ImportDirective' n m
    defaultImportDir :: forall n m. ImportDirective' n m
    defaultImportDir = Range
    -> Using' n m
    -> HidingDirective' n m
    -> RenamingDirective' n m
    -> Maybe KwRange
    -> ImportDirective' n m
    forall n m.
    Range
    -> Using' n m
    -> HidingDirective' n m
    -> RenamingDirective' n m
    -> Maybe KwRange
    -> ImportDirective' n m
    ImportDirective Range
    forall a. Range' a
    noRange Using' n m
    forall n m. Using' n m
    UseEverything [] [] Maybe KwRange
    forall a. Maybe a
    Nothing

    -- | @isDefaultImportDir@ implies @null@, but not the other way round.
    isDefaultImportDir :: ImportDirective' n m -> Bool
    isDefaultImportDir :: forall n m. ImportDirective' n m -> Bool
    isDefaultImportDir ImportDirective' n m
    dir = ImportDirective' n m -> Bool
    forall a. Null a => a -> Bool
    null ImportDirective' n m
    dir Bool -> Bool -> Bool
    && Maybe KwRange -> Bool
    forall a. Null a => a -> Bool
    null (ImportDirective' n m -> Maybe KwRange
    forall n m. ImportDirective' n m -> Maybe KwRange
    publicOpen ImportDirective' n m
    dir)

    -- | The @using@ clause of import directive.
    data Using' n m
      = UseEverything              -- ^ No @using@ clause given.
      | Using [ImportedName' n m]  -- ^ @using@ the specified names.
      deriving (Using' n m -> Using' n m -> Bool
    (Using' n m -> Using' n m -> Bool)
    -> (Using' n m -> Using' n m -> Bool) -> Eq (Using' n m)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall n m. (Eq m, Eq n) => Using' n m -> Using' n m -> Bool
    $c== :: forall n m. (Eq m, Eq n) => Using' n m -> Using' n m -> Bool
    == :: Using' n m -> Using' n m -> Bool
    $c/= :: forall n m. (Eq m, Eq n) => Using' n m -> Using' n m -> Bool
    /= :: Using' n m -> Using' n m -> Bool
    Eq, Int -> Using' n m -> ShowS
    [Using' n m] -> ShowS
    Using' n m -> ArgName
    (Int -> Using' n m -> ShowS)
    -> (Using' n m -> ArgName)
    -> ([Using' n m] -> ShowS)
    -> Show (Using' n m)
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    forall n m. (Show m, Show n) => Int -> Using' n m -> ShowS
    forall n m. (Show m, Show n) => [Using' n m] -> ShowS
    forall n m. (Show m, Show n) => Using' n m -> ArgName
    $cshowsPrec :: forall n m. (Show m, Show n) => Int -> Using' n m -> ShowS
    showsPrec :: Int -> Using' n m -> ShowS
    $cshow :: forall n m. (Show m, Show n) => Using' n m -> ArgName
    show :: Using' n m -> ArgName
    $cshowList :: forall n m. (Show m, Show n) => [Using' n m] -> ShowS
    showList :: [Using' n m] -> ShowS
    Show)

    instance Semigroup (Using' n m) where
      Using' n m
    UseEverything <> :: Using' n m -> Using' n m -> Using' n m
    <> Using' n m
    u             = Using' n m
    u
      Using' n m
    u             <> Using' n m
    UseEverything = Using' n m
    u
      Using [ImportedName' n m]
    xs      <> Using [ImportedName' n m]
    ys      = [ImportedName' n m] -> Using' n m
    forall n m. [ImportedName' n m] -> Using' n m
    Using ([ImportedName' n m]
    xs [ImportedName' n m] -> [ImportedName' n m] -> [ImportedName' n m]
    forall a. [a] -> [a] -> [a]
    ++ [ImportedName' n m]
    ys)

    instance Monoid (Using' n m) where
      mempty :: Using' n m
    mempty  = Using' n m
    forall n m. Using' n m
    UseEverything
      mappend :: Using' n m -> Using' n m -> Using' n m
    mappend = Using' n m -> Using' n m -> Using' n m
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance Null (Using' n m) where
      null :: Using' n m -> Bool
    null Using' n m
    UseEverything = Bool
    True
      null Using{}       = Bool
    False
      empty :: Using' n m
    empty = Using' n m
    forall a. Monoid a => a
    mempty

    mapUsing :: ([ImportedName' n1 m1] -> [ImportedName' n2 m2]) -> Using' n1 m1 -> Using' n2 m2
    mapUsing :: forall n1 m1 n2 m2.
    ([ImportedName' n1 m1] -> [ImportedName' n2 m2])
    -> Using' n1 m1 -> Using' n2 m2
    mapUsing [ImportedName' n1 m1] -> [ImportedName' n2 m2]
    f = \case
      Using' n1 m1
    UseEverything -> Using' n2 m2
    forall n m. Using' n m
    UseEverything
      Using [ImportedName' n1 m1]
    xs      -> [ImportedName' n2 m2] -> Using' n2 m2
    forall n m. [ImportedName' n m] -> Using' n m
    Using ([ImportedName' n2 m2] -> Using' n2 m2)
    -> [ImportedName' n2 m2] -> Using' n2 m2
    forall a b. (a -> b) -> a -> b
    $ [ImportedName' n1 m1] -> [ImportedName' n2 m2]
    f [ImportedName' n1 m1]
    xs

    -- | An imported name can be a module or a defined name.
    data ImportedName' n m
      = ImportedModule  m  -- ^ Imported module name of type @m@.
      | ImportedName    n  -- ^ Imported name of type @n@.
      deriving (ImportedName' n m -> ImportedName' n m -> Bool
    (ImportedName' n m -> ImportedName' n m -> Bool)
    -> (ImportedName' n m -> ImportedName' n m -> Bool)
    -> Eq (ImportedName' n m)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall n m.
    (Eq m, Eq n) =>
    ImportedName' n m -> ImportedName' n m -> Bool
    $c== :: forall n m.
    (Eq m, Eq n) =>
    ImportedName' n m -> ImportedName' n m -> Bool
    == :: ImportedName' n m -> ImportedName' n m -> Bool
    $c/= :: forall n m.
    (Eq m, Eq n) =>
    ImportedName' n m -> ImportedName' n m -> Bool
    /= :: ImportedName' n m -> ImportedName' n m -> Bool
    Eq, Eq (ImportedName' n m)
    Eq (ImportedName' n m) =>
    (ImportedName' n m -> ImportedName' n m -> Ordering)
    -> (ImportedName' n m -> ImportedName' n m -> Bool)
    -> (ImportedName' n m -> ImportedName' n m -> Bool)
    -> (ImportedName' n m -> ImportedName' n m -> Bool)
    -> (ImportedName' n m -> ImportedName' n m -> Bool)
    -> (ImportedName' n m -> ImportedName' n m -> ImportedName' n m)
    -> (ImportedName' n m -> ImportedName' n m -> ImportedName' n m)
    -> Ord (ImportedName' n m)
    ImportedName' n m -> ImportedName' n m -> Bool
    ImportedName' n m -> ImportedName' n m -> Ordering
    ImportedName' n m -> ImportedName' n m -> ImportedName' n m
    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 n m. (Ord m, Ord n) => Eq (ImportedName' n m)
    forall n m.
    (Ord m, Ord n) =>
    ImportedName' n m -> ImportedName' n m -> Bool
    forall n m.
    (Ord m, Ord n) =>
    ImportedName' n m -> ImportedName' n m -> Ordering
    forall n m.
    (Ord m, Ord n) =>
    ImportedName' n m -> ImportedName' n m -> ImportedName' n m
    $ccompare :: forall n m.
    (Ord m, Ord n) =>
    ImportedName' n m -> ImportedName' n m -> Ordering
    compare :: ImportedName' n m -> ImportedName' n m -> Ordering
    $c< :: forall n m.
    (Ord m, Ord n) =>
    ImportedName' n m -> ImportedName' n m -> Bool
    < :: ImportedName' n m -> ImportedName' n m -> Bool
    $c<= :: forall n m.
    (Ord m, Ord n) =>
    ImportedName' n m -> ImportedName' n m -> Bool
    <= :: ImportedName' n m -> ImportedName' n m -> Bool
    $c> :: forall n m.
    (Ord m, Ord n) =>
    ImportedName' n m -> ImportedName' n m -> Bool
    > :: ImportedName' n m -> ImportedName' n m -> Bool
    $c>= :: forall n m.
    (Ord m, Ord n) =>
    ImportedName' n m -> ImportedName' n m -> Bool
    >= :: ImportedName' n m -> ImportedName' n m -> Bool
    $cmax :: forall n m.
    (Ord m, Ord n) =>
    ImportedName' n m -> ImportedName' n m -> ImportedName' n m
    max :: ImportedName' n m -> ImportedName' n m -> ImportedName' n m
    $cmin :: forall n m.
    (Ord m, Ord n) =>
    ImportedName' n m -> ImportedName' n m -> ImportedName' n m
    min :: ImportedName' n m -> ImportedName' n m -> ImportedName' n m
    Ord, Int -> ImportedName' n m -> ShowS
    [ImportedName' n m] -> ShowS
    ImportedName' n m -> ArgName
    (Int -> ImportedName' n m -> ShowS)
    -> (ImportedName' n m -> ArgName)
    -> ([ImportedName' n m] -> ShowS)
    -> Show (ImportedName' n m)
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    forall n m. (Show m, Show n) => Int -> ImportedName' n m -> ShowS
    forall n m. (Show m, Show n) => [ImportedName' n m] -> ShowS
    forall n m. (Show m, Show n) => ImportedName' n m -> ArgName
    $cshowsPrec :: forall n m. (Show m, Show n) => Int -> ImportedName' n m -> ShowS
    showsPrec :: Int -> ImportedName' n m -> ShowS
    $cshow :: forall n m. (Show m, Show n) => ImportedName' n m -> ArgName
    show :: ImportedName' n m -> ArgName
    $cshowList :: forall n m. (Show m, Show n) => [ImportedName' n m] -> ShowS
    showList :: [ImportedName' n m] -> ShowS
    Show)

    fromImportedName :: ImportedName' a a -> a
    fromImportedName :: forall a. ImportedName' a a -> a
    fromImportedName = \case
      ImportedModule a
    x -> a
    x
      ImportedName   a
    x -> a
    x

    setImportedName :: ImportedName' a a -> a -> ImportedName' a a
    setImportedName :: forall a. ImportedName' a a -> a -> ImportedName' a a
    setImportedName (ImportedName   a
    x) a
    y = a -> ImportedName' a a
    forall n m. n -> ImportedName' n m
    ImportedName   a
    y
    setImportedName (ImportedModule a
    x) a
    y = a -> ImportedName' a a
    forall n m. m -> ImportedName' n m
    ImportedModule a
    y

    -- | Like 'partitionEithers'.
    partitionImportedNames :: [ImportedName' n m] -> ([n], [m])
    partitionImportedNames :: forall n m. [ImportedName' n m] -> ([n], [m])
    partitionImportedNames = ((ImportedName' n m -> ([n], [m]) -> ([n], [m]))
     -> ([n], [m]) -> [ImportedName' n m] -> ([n], [m]))
    -> ([n], [m])
    -> (ImportedName' n m -> ([n], [m]) -> ([n], [m]))
    -> [ImportedName' n m]
    -> ([n], [m])
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (ImportedName' n m -> ([n], [m]) -> ([n], [m]))
    -> ([n], [m]) -> [ImportedName' n m] -> ([n], [m])
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr ([], []) ((ImportedName' n m -> ([n], [m]) -> ([n], [m]))
     -> [ImportedName' n m] -> ([n], [m]))
    -> (ImportedName' n m -> ([n], [m]) -> ([n], [m]))
    -> [ImportedName' n m]
    -> ([n], [m])
    forall a b. (a -> b) -> a -> b
    $ \case
      ImportedName   n
    n -> ([n] -> [n]) -> ([n], [m]) -> ([n], [m])
    forall a b c. (a -> b) -> (a, c) -> (b, c)
    forall (p :: * -> * -> *) a b c.
    Bifunctor p =>
    (a -> b) -> p a c -> p b c
    first  (n
    nn -> [n] -> [n]
    forall a. a -> [a] -> [a]
    :)
      ImportedModule m
    m -> ([m] -> [m]) -> ([n], [m]) -> ([n], [m])
    forall b c a. (b -> c) -> (a, b) -> (a, c)
    forall (p :: * -> * -> *) b c a.
    Bifunctor p =>
    (b -> c) -> p a b -> p a c
    second (m
    mm -> [m] -> [m]
    forall a. a -> [a] -> [a]
    :)

    -- -- Defined in Concrete.Pretty
    -- instance (Pretty n, Pretty m) => Pretty (ImportedName' n m) where
    --   pretty (ImportedModule x) = "module" <+> pretty x
    --   pretty (ImportedName   x) = pretty x

    -- instance (Show n, Show m) => Show (ImportedName' n m) where
    --   show (ImportedModule x) = "module " ++ show x
    --   show (ImportedName   x) = show x

    data Renaming' n m = Renaming
      { forall n m. Renaming' n m -> ImportedName' n m
    renFrom    :: ImportedName' n m
        -- ^ Rename from this name.
      , forall n m. Renaming' n m -> ImportedName' n m
    renTo      :: ImportedName' n m
        -- ^ To this one.  Must be same kind as 'renFrom'.
      , forall n m. Renaming' n m -> Maybe Fixity
    renFixity  :: Maybe Fixity
        -- ^ New fixity of 'renTo' (optional).
      , forall n m. Renaming' n m -> Range
    renToRange :: Range
        -- ^ The range of the \"to\" keyword.  Retained for highlighting purposes.
      }
      deriving (Renaming' n m -> Renaming' n m -> Bool
    (Renaming' n m -> Renaming' n m -> Bool)
    -> (Renaming' n m -> Renaming' n m -> Bool) -> Eq (Renaming' n m)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall n m. (Eq m, Eq n) => Renaming' n m -> Renaming' n m -> Bool
    $c== :: forall n m. (Eq m, Eq n) => Renaming' n m -> Renaming' n m -> Bool
    == :: Renaming' n m -> Renaming' n m -> Bool
    $c/= :: forall n m. (Eq m, Eq n) => Renaming' n m -> Renaming' n m -> Bool
    /= :: Renaming' n m -> Renaming' n m -> Bool
    Eq, Int -> Renaming' n m -> ShowS
    [Renaming' n m] -> ShowS
    Renaming' n m -> ArgName
    (Int -> Renaming' n m -> ShowS)
    -> (Renaming' n m -> ArgName)
    -> ([Renaming' n m] -> ShowS)
    -> Show (Renaming' n m)
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    forall n m. (Show m, Show n) => Int -> Renaming' n m -> ShowS
    forall n m. (Show m, Show n) => [Renaming' n m] -> ShowS
    forall n m. (Show m, Show n) => Renaming' n m -> ArgName
    $cshowsPrec :: forall n m. (Show m, Show n) => Int -> Renaming' n m -> ShowS
    showsPrec :: Int -> Renaming' n m -> ShowS
    $cshow :: forall n m. (Show m, Show n) => Renaming' n m -> ArgName
    show :: Renaming' n m -> ArgName
    $cshowList :: forall n m. (Show m, Show n) => [Renaming' n m] -> ShowS
    showList :: [Renaming' n m] -> ShowS
    Show)

    -- ** HasRange instances

    instance (HasRange a, HasRange b) => HasRange (ImportDirective' a b) where
      getRange :: ImportDirective' a b -> Range
    getRange = ImportDirective' a b -> Range
    forall n m. ImportDirective' n m -> Range
    importDirRange

    instance (HasRange a, HasRange b) => HasRange (Using' a b) where
      getRange :: Using' a b -> Range
    getRange (Using  [ImportedName' a b]
    xs) = [ImportedName' a b] -> Range
    forall a. HasRange a => a -> Range
    getRange [ImportedName' a b]
    xs
      getRange Using' a b
    UseEverything = Range
    forall a. Range' a
    noRange

    instance (HasRange a, HasRange b) => HasRange (Renaming' a b) where
      getRange :: Renaming' a b -> Range
    getRange Renaming' a b
    r = (ImportedName' a b, ImportedName' a b) -> Range
    forall a. HasRange a => a -> Range
    getRange (Renaming' a b -> ImportedName' a b
    forall n m. Renaming' n m -> ImportedName' n m
    renFrom Renaming' a b
    r, Renaming' a b -> ImportedName' a b
    forall n m. Renaming' n m -> ImportedName' n m
    renTo Renaming' a b
    r)

    instance (HasRange a, HasRange b) => HasRange (ImportedName' a b) where
      getRange :: ImportedName' a b -> Range
    getRange (ImportedName   a
    x) = a -> Range
    forall a. HasRange a => a -> Range
    getRange a
    x
      getRange (ImportedModule b
    x) = b -> Range
    forall a. HasRange a => a -> Range
    getRange b
    x

    -- ** KillRange instances

    instance (KillRange a, KillRange b) => KillRange (ImportDirective' a b) where
      killRange :: KillRangeT (ImportDirective' a b)
    killRange (ImportDirective Range
    _ Using' a b
    u HidingDirective' a b
    h RenamingDirective' a b
    r Maybe KwRange
    p) =
        (Using' a b
     -> HidingDirective' a b
     -> RenamingDirective' a b
     -> ImportDirective' a b)
    -> Using' a b
    -> HidingDirective' a b
    -> RenamingDirective' a b
    -> ImportDirective' a b
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN (\Using' a b
    u HidingDirective' a b
    h RenamingDirective' a b
    r -> Range
    -> Using' a b
    -> HidingDirective' a b
    -> RenamingDirective' a b
    -> Maybe KwRange
    -> ImportDirective' a b
    forall n m.
    Range
    -> Using' n m
    -> HidingDirective' n m
    -> RenamingDirective' n m
    -> Maybe KwRange
    -> ImportDirective' n m
    ImportDirective Range
    forall a. Range' a
    noRange Using' a b
    u HidingDirective' a b
    h RenamingDirective' a b
    r (Maybe KwRange
    p Maybe KwRange -> KwRange -> Maybe KwRange
    forall (f :: * -> *) a b. Functor f => f a -> b -> f b
    $> KwRange
    forall a. Null a => a
    empty)) Using' a b
    u HidingDirective' a b
    h RenamingDirective' a b
    r

    instance (KillRange a, KillRange b) => KillRange (Using' a b) where
      killRange :: KillRangeT (Using' a b)
    killRange (Using  [ImportedName' a b]
    i) = ([ImportedName' a b] -> Using' a b)
    -> [ImportedName' a b] -> Using' a b
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN [ImportedName' a b] -> Using' a b
    forall n m. [ImportedName' n m] -> Using' n m
    Using  [ImportedName' a b]
    i
      killRange Using' a b
    UseEverything = Using' a b
    forall n m. Using' n m
    UseEverything

    instance (KillRange a, KillRange b) => KillRange (Renaming' a b) where
      killRange :: KillRangeT (Renaming' a b)
    killRange (Renaming ImportedName' a b
    i ImportedName' a b
    n Maybe Fixity
    mf Range
    _to) = (ImportedName' a b
     -> ImportedName' a b -> Maybe Fixity -> Renaming' a b)
    -> ImportedName' a b
    -> ImportedName' a b
    -> Maybe Fixity
    -> Renaming' a b
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN (\ ImportedName' a b
    i ImportedName' a b
    n Maybe Fixity
    mf -> ImportedName' a b
    -> ImportedName' a b -> Maybe Fixity -> Range -> Renaming' a b
    forall n m.
    ImportedName' n m
    -> ImportedName' n m -> Maybe Fixity -> Range -> Renaming' n m
    Renaming ImportedName' a b
    i ImportedName' a b
    n Maybe Fixity
    mf Range
    forall a. Range' a
    noRange) ImportedName' a b
    i ImportedName' a b
    n Maybe Fixity
    mf

    instance (KillRange a, KillRange b) => KillRange (ImportedName' a b) where
      killRange :: KillRangeT (ImportedName' a b)
    killRange (ImportedModule b
    n) = (b -> ImportedName' a b) -> b -> ImportedName' a b
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN b -> ImportedName' a b
    forall n m. m -> ImportedName' n m
    ImportedModule b
    n
      killRange (ImportedName   a
    n) = (a -> ImportedName' a b) -> a -> ImportedName' a b
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN a -> ImportedName' a b
    forall n m. n -> ImportedName' n m
    ImportedName   a
    n

    -- ** Pretty instances

    instance (Pretty a, Pretty b) => Pretty (ImportDirective' a b) where
        pretty :: ImportDirective' a b -> Doc
    pretty ImportDirective' a b
    i =
            [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    sep [ Maybe KwRange -> Doc
    forall {a} {a}. (IsString a, Null a) => Maybe a -> a
    public (ImportDirective' a b -> Maybe KwRange
    forall n m. ImportDirective' n m -> Maybe KwRange
    publicOpen ImportDirective' a b
    i)
                , Using' a b -> Doc
    forall a. Pretty a => a -> Doc
    pretty (Using' a b -> Doc) -> Using' a b -> Doc
    forall a b. (a -> b) -> a -> b
    $ ImportDirective' a b -> Using' a b
    forall n m. ImportDirective' n m -> Using' n m
    using ImportDirective' a b
    i
                , [ImportedName' a b] -> Doc
    forall {a}. Pretty a => [a] -> Doc
    prettyHiding ([ImportedName' a b] -> Doc) -> [ImportedName' a b] -> Doc
    forall a b. (a -> b) -> a -> b
    $ ImportDirective' a b -> [ImportedName' a b]
    forall n m. ImportDirective' n m -> HidingDirective' n m
    hiding ImportDirective' a b
    i
                , [Renaming' a b] -> Doc
    forall {a}. Pretty a => [a] -> Doc
    rename ([Renaming' a b] -> Doc) -> [Renaming' a b] -> Doc
    forall a b. (a -> b) -> a -> b
    $ ImportDirective' a b -> [Renaming' a b]
    forall n m. ImportDirective' n m -> RenamingDirective' n m
    impRenaming ImportDirective' a b
    i
                ]
            where
                public :: Maybe a -> a
    public Just{}  = a
    "public"
                public Maybe a
    Nothing = a
    forall a. Null a => a
    empty

                prettyHiding :: [a] -> Doc
    prettyHiding [] = Doc
    forall a. Null a => a
    empty
                prettyHiding [a]
    xs = Doc
    "hiding" Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+> Doc -> Doc
    parens ([Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    fsep ([Doc] -> Doc) -> [Doc] -> Doc
    forall a b. (a -> b) -> a -> b
    $ Doc -> [Doc] -> [Doc]
    forall (t :: * -> *). Foldable t => Doc -> t Doc -> [Doc]
    punctuate Doc
    ";" ([Doc] -> [Doc]) -> [Doc] -> [Doc]
    forall a b. (a -> b) -> a -> b
    $ (a -> Doc) -> [a] -> [Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map a -> Doc
    forall a. Pretty a => a -> Doc
    pretty [a]
    xs)

                rename :: [a] -> Doc
    rename [] = Doc
    forall a. Null a => a
    empty
                rename [a]
    xs = [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    hsep [ Doc
    "renaming"
                                 , Doc -> Doc
    parens (Doc -> Doc) -> Doc -> Doc
    forall a b. (a -> b) -> a -> b
    $ [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    fsep ([Doc] -> Doc) -> [Doc] -> Doc
    forall a b. (a -> b) -> a -> b
    $ Doc -> [Doc] -> [Doc]
    forall (t :: * -> *). Foldable t => Doc -> t Doc -> [Doc]
    punctuate Doc
    ";" ([Doc] -> [Doc]) -> [Doc] -> [Doc]
    forall a b. (a -> b) -> a -> b
    $ (a -> Doc) -> [a] -> [Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map a -> Doc
    forall a. Pretty a => a -> Doc
    pretty [a]
    xs
                                 ]

    instance (Pretty a, Pretty b) => Pretty (Using' a b) where
        pretty :: Using' a b -> Doc
    pretty Using' a b
    UseEverything = Doc
    forall a. Null a => a
    empty
        pretty (Using [ImportedName' a b]
    xs)    =
            Doc
    "using" Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+> Doc -> Doc
    parens ([Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    fsep ([Doc] -> Doc) -> [Doc] -> Doc
    forall a b. (a -> b) -> a -> b
    $ Doc -> [Doc] -> [Doc]
    forall (t :: * -> *). Foldable t => Doc -> t Doc -> [Doc]
    punctuate Doc
    ";" ([Doc] -> [Doc]) -> [Doc] -> [Doc]
    forall a b. (a -> b) -> a -> b
    $ (ImportedName' a b -> Doc) -> [ImportedName' a b] -> [Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map ImportedName' a b -> Doc
    forall a. Pretty a => a -> Doc
    pretty [ImportedName' a b]
    xs)

    instance (Pretty a, Pretty b) => Pretty (ImportedName' a b) where
        pretty :: ImportedName' a b -> Doc
    pretty (ImportedName   a
    a) = a -> Doc
    forall a. Pretty a => a -> Doc
    pretty a
    a
        pretty (ImportedModule b
    b) = Doc
    "module" Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+> b -> Doc
    forall a. Pretty a => a -> Doc
    pretty b
    b

    instance (Pretty a, Pretty b) => Pretty (Renaming' a b) where
        pretty :: Renaming' a b -> Doc
    pretty (Renaming ImportedName' a b
    from ImportedName' a b
    to Maybe Fixity
    mfx Range
    _r) = [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    hsep
          [ ImportedName' a b -> Doc
    forall a. Pretty a => a -> Doc
    pretty ImportedName' a b
    from
          , Doc
    "to"
          , Doc -> (Fixity -> Doc) -> Maybe Fixity -> Doc
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Doc
    forall a. Null a => a
    empty Fixity -> Doc
    forall a. Pretty a => a -> Doc
    pretty Maybe Fixity
    mfx
          , case ImportedName' a b
    to of
              ImportedName a
    a   -> a -> Doc
    forall a. Pretty a => a -> Doc
    pretty a
    a
              ImportedModule b
    b -> b -> Doc
    forall a. Pretty a => a -> Doc
    pretty b
    b   -- don't print "module" here
          ]

    -- ** NFData instances

    -- | Ranges are not forced.

    instance (NFData a, NFData b) => NFData (ImportDirective' a b) where
      rnf :: ImportDirective' a b -> ()
    rnf (ImportDirective Range
    _ Using' a b
    a HidingDirective' a b
    b RenamingDirective' a b
    c Maybe KwRange
    _) = Using' a b -> ()
    forall a. NFData a => a -> ()
    rnf Using' a b
    a () -> () -> ()
    forall a b. a -> b -> b
    `seq` HidingDirective' a b -> ()
    forall a. NFData a => a -> ()
    rnf HidingDirective' a b
    b () -> () -> ()
    forall a b. a -> b -> b
    `seq` RenamingDirective' a b -> ()
    forall a. NFData a => a -> ()
    rnf RenamingDirective' a b
    c

    instance (NFData a, NFData b) => NFData (Using' a b) where
      rnf :: Using' a b -> ()
    rnf Using' a b
    UseEverything = ()
      rnf (Using [ImportedName' a b]
    a)     = [ImportedName' a b] -> ()
    forall a. NFData a => a -> ()
    rnf [ImportedName' a b]
    a

    -- | Ranges are not forced.

    instance (NFData a, NFData b) => NFData (Renaming' a b) where
      rnf :: Renaming' a b -> ()
    rnf (Renaming ImportedName' a b
    a ImportedName' a b
    b Maybe Fixity
    c Range
    _) = ImportedName' a b -> ()
    forall a. NFData a => a -> ()
    rnf ImportedName' a b
    a () -> () -> ()
    forall a b. a -> b -> b
    `seq` ImportedName' a b -> ()
    forall a. NFData a => a -> ()
    rnf ImportedName' a b
    b () -> () -> ()
    forall a b. a -> b -> b
    `seq` Maybe Fixity -> ()
    forall a. NFData a => a -> ()
    rnf Maybe Fixity
    c

    instance (NFData a, NFData b) => NFData (ImportedName' a b) where
      rnf :: ImportedName' a b -> ()
    rnf (ImportedModule b
    a) = b -> ()
    forall a. NFData a => a -> ()
    rnf b
    a
      rnf (ImportedName a
    a)   = a -> ()
    forall a. NFData a => a -> ()
    rnf a
    a

    -----------------------------------------------------------------------------
    -- * Termination
    -----------------------------------------------------------------------------

    -- | Termination check? (Default = TerminationCheck).
    data TerminationCheck m
      = TerminationCheck
        -- ^ Run the termination checker.
      | NoTerminationCheck
        -- ^ Skip termination checking (unsafe).
      | NonTerminating
        -- ^ Treat as non-terminating.
      | Terminating
        -- ^ Treat as terminating (unsafe).  Same effect as 'NoTerminationCheck'.
      | TerminationMeasure Range m
        -- ^ Skip termination checking but use measure instead.
        deriving (Int -> TerminationCheck m -> ShowS
    [TerminationCheck m] -> ShowS
    TerminationCheck m -> ArgName
    (Int -> TerminationCheck m -> ShowS)
    -> (TerminationCheck m -> ArgName)
    -> ([TerminationCheck m] -> ShowS)
    -> Show (TerminationCheck m)
    forall m. Show m => Int -> TerminationCheck m -> ShowS
    forall m. Show m => [TerminationCheck m] -> ShowS
    forall m. Show m => TerminationCheck m -> ArgName
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall m. Show m => Int -> TerminationCheck m -> ShowS
    showsPrec :: Int -> TerminationCheck m -> ShowS
    $cshow :: forall m. Show m => TerminationCheck m -> ArgName
    show :: TerminationCheck m -> ArgName
    $cshowList :: forall m. Show m => [TerminationCheck m] -> ShowS
    showList :: [TerminationCheck m] -> ShowS
    Show, TerminationCheck m -> TerminationCheck m -> Bool
    (TerminationCheck m -> TerminationCheck m -> Bool)
    -> (TerminationCheck m -> TerminationCheck m -> Bool)
    -> Eq (TerminationCheck m)
    forall m. Eq m => TerminationCheck m -> TerminationCheck m -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall m. Eq m => TerminationCheck m -> TerminationCheck m -> Bool
    == :: TerminationCheck m -> TerminationCheck m -> Bool
    $c/= :: forall m. Eq m => TerminationCheck m -> TerminationCheck m -> Bool
    /= :: TerminationCheck m -> TerminationCheck m -> Bool
    Eq, (forall a b. (a -> b) -> TerminationCheck a -> TerminationCheck b)
    -> (forall a b. a -> TerminationCheck b -> TerminationCheck a)
    -> Functor TerminationCheck
    forall a b. a -> TerminationCheck b -> TerminationCheck a
    forall a b. (a -> b) -> TerminationCheck a -> TerminationCheck b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> TerminationCheck a -> TerminationCheck b
    fmap :: forall a b. (a -> b) -> TerminationCheck a -> TerminationCheck b
    $c<$ :: forall a b. a -> TerminationCheck b -> TerminationCheck a
    <$ :: forall a b. a -> TerminationCheck b -> TerminationCheck a
    Functor)

    instance KillRange m => KillRange (TerminationCheck m) where
      killRange :: KillRangeT (TerminationCheck m)
    killRange (TerminationMeasure Range
    _ m
    m) = Range -> m -> TerminationCheck m
    forall m. Range -> m -> TerminationCheck m
    TerminationMeasure Range
    forall a. Range' a
    noRange (KillRangeT m
    forall a. KillRange a => KillRangeT a
    killRange m
    m)
      killRange TerminationCheck m
    t                        = TerminationCheck m
    t

    instance NFData a => NFData (TerminationCheck a) where
      rnf :: TerminationCheck a -> ()
    rnf TerminationCheck a
    TerminationCheck         = ()
      rnf TerminationCheck a
    NoTerminationCheck       = ()
      rnf TerminationCheck a
    NonTerminating           = ()
      rnf TerminationCheck a
    Terminating              = ()
      rnf (TerminationMeasure Range
    _ a
    a) = a -> ()
    forall a. NFData a => a -> ()
    rnf a
    a

    -----------------------------------------------------------------------------
    -- * Positivity
    -----------------------------------------------------------------------------

    -- | Positivity check? (Default = True).
    data PositivityCheck = YesPositivityCheck | NoPositivityCheck
      deriving (PositivityCheck -> PositivityCheck -> Bool
    (PositivityCheck -> PositivityCheck -> Bool)
    -> (PositivityCheck -> PositivityCheck -> Bool)
    -> Eq PositivityCheck
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PositivityCheck -> PositivityCheck -> Bool
    == :: PositivityCheck -> PositivityCheck -> Bool
    $c/= :: PositivityCheck -> PositivityCheck -> Bool
    /= :: PositivityCheck -> PositivityCheck -> Bool
    Eq, Eq PositivityCheck
    Eq PositivityCheck =>
    (PositivityCheck -> PositivityCheck -> Ordering)
    -> (PositivityCheck -> PositivityCheck -> Bool)
    -> (PositivityCheck -> PositivityCheck -> Bool)
    -> (PositivityCheck -> PositivityCheck -> Bool)
    -> (PositivityCheck -> PositivityCheck -> Bool)
    -> (PositivityCheck -> PositivityCheck -> PositivityCheck)
    -> (PositivityCheck -> PositivityCheck -> PositivityCheck)
    -> Ord PositivityCheck
    PositivityCheck -> PositivityCheck -> Bool
    PositivityCheck -> PositivityCheck -> Ordering
    PositivityCheck -> PositivityCheck -> PositivityCheck
    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
    $ccompare :: PositivityCheck -> PositivityCheck -> Ordering
    compare :: PositivityCheck -> PositivityCheck -> Ordering
    $c< :: PositivityCheck -> PositivityCheck -> Bool
    < :: PositivityCheck -> PositivityCheck -> Bool
    $c<= :: PositivityCheck -> PositivityCheck -> Bool
    <= :: PositivityCheck -> PositivityCheck -> Bool
    $c> :: PositivityCheck -> PositivityCheck -> Bool
    > :: PositivityCheck -> PositivityCheck -> Bool
    $c>= :: PositivityCheck -> PositivityCheck -> Bool
    >= :: PositivityCheck -> PositivityCheck -> Bool
    $cmax :: PositivityCheck -> PositivityCheck -> PositivityCheck
    max :: PositivityCheck -> PositivityCheck -> PositivityCheck
    $cmin :: PositivityCheck -> PositivityCheck -> PositivityCheck
    min :: PositivityCheck -> PositivityCheck -> PositivityCheck
    Ord, Int -> PositivityCheck -> ShowS
    [PositivityCheck] -> ShowS
    PositivityCheck -> ArgName
    (Int -> PositivityCheck -> ShowS)
    -> (PositivityCheck -> ArgName)
    -> ([PositivityCheck] -> ShowS)
    -> Show PositivityCheck
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PositivityCheck -> ShowS
    showsPrec :: Int -> PositivityCheck -> ShowS
    $cshow :: PositivityCheck -> ArgName
    show :: PositivityCheck -> ArgName
    $cshowList :: [PositivityCheck] -> ShowS
    showList :: [PositivityCheck] -> ShowS
    Show, PositivityCheck
    PositivityCheck -> PositivityCheck -> Bounded PositivityCheck
    forall a. a -> a -> Bounded a
    $cminBound :: PositivityCheck
    minBound :: PositivityCheck
    $cmaxBound :: PositivityCheck
    maxBound :: PositivityCheck
    Bounded, Int -> PositivityCheck
    PositivityCheck -> Int
    PositivityCheck -> [PositivityCheck]
    PositivityCheck -> PositivityCheck
    PositivityCheck -> PositivityCheck -> [PositivityCheck]
    PositivityCheck
    -> PositivityCheck -> PositivityCheck -> [PositivityCheck]
    (PositivityCheck -> PositivityCheck)
    -> (PositivityCheck -> PositivityCheck)
    -> (Int -> PositivityCheck)
    -> (PositivityCheck -> Int)
    -> (PositivityCheck -> [PositivityCheck])
    -> (PositivityCheck -> PositivityCheck -> [PositivityCheck])
    -> (PositivityCheck -> PositivityCheck -> [PositivityCheck])
    -> (PositivityCheck
        -> PositivityCheck -> PositivityCheck -> [PositivityCheck])
    -> Enum PositivityCheck
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: PositivityCheck -> PositivityCheck
    succ :: PositivityCheck -> PositivityCheck
    $cpred :: PositivityCheck -> PositivityCheck
    pred :: PositivityCheck -> PositivityCheck
    $ctoEnum :: Int -> PositivityCheck
    toEnum :: Int -> PositivityCheck
    $cfromEnum :: PositivityCheck -> Int
    fromEnum :: PositivityCheck -> Int
    $cenumFrom :: PositivityCheck -> [PositivityCheck]
    enumFrom :: PositivityCheck -> [PositivityCheck]
    $cenumFromThen :: PositivityCheck -> PositivityCheck -> [PositivityCheck]
    enumFromThen :: PositivityCheck -> PositivityCheck -> [PositivityCheck]
    $cenumFromTo :: PositivityCheck -> PositivityCheck -> [PositivityCheck]
    enumFromTo :: PositivityCheck -> PositivityCheck -> [PositivityCheck]
    $cenumFromThenTo :: PositivityCheck
    -> PositivityCheck -> PositivityCheck -> [PositivityCheck]
    enumFromThenTo :: PositivityCheck
    -> PositivityCheck -> PositivityCheck -> [PositivityCheck]
    Enum, (forall x. PositivityCheck -> Rep PositivityCheck x)
    -> (forall x. Rep PositivityCheck x -> PositivityCheck)
    -> Generic PositivityCheck
    forall x. Rep PositivityCheck x -> PositivityCheck
    forall x. PositivityCheck -> Rep PositivityCheck x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. PositivityCheck -> Rep PositivityCheck x
    from :: forall x. PositivityCheck -> Rep PositivityCheck x
    $cto :: forall x. Rep PositivityCheck x -> PositivityCheck
    to :: forall x. Rep PositivityCheck x -> PositivityCheck
    Generic)

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

    -- Semigroup and Monoid via conjunction
    instance Semigroup PositivityCheck where
      PositivityCheck
    NoPositivityCheck <> :: PositivityCheck -> PositivityCheck -> PositivityCheck
    <> PositivityCheck
    _ = PositivityCheck
    NoPositivityCheck
      PositivityCheck
    _ <> PositivityCheck
    NoPositivityCheck = PositivityCheck
    NoPositivityCheck
      PositivityCheck
    _ <> PositivityCheck
    _ = PositivityCheck
    YesPositivityCheck

    instance Monoid PositivityCheck where
      mempty :: PositivityCheck
    mempty  = PositivityCheck
    YesPositivityCheck
      mappend :: PositivityCheck -> PositivityCheck -> PositivityCheck
    mappend = PositivityCheck -> PositivityCheck -> PositivityCheck
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance NFData PositivityCheck

    -----------------------------------------------------------------------------
    -- * Universe checking
    -----------------------------------------------------------------------------

    -- | Universe check? (Default is yes).
    data UniverseCheck = YesUniverseCheck | NoUniverseCheck
      deriving (UniverseCheck -> UniverseCheck -> Bool
    (UniverseCheck -> UniverseCheck -> Bool)
    -> (UniverseCheck -> UniverseCheck -> Bool) -> Eq UniverseCheck
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: UniverseCheck -> UniverseCheck -> Bool
    == :: UniverseCheck -> UniverseCheck -> Bool
    $c/= :: UniverseCheck -> UniverseCheck -> Bool
    /= :: UniverseCheck -> UniverseCheck -> Bool
    Eq, Eq UniverseCheck
    Eq UniverseCheck =>
    (UniverseCheck -> UniverseCheck -> Ordering)
    -> (UniverseCheck -> UniverseCheck -> Bool)
    -> (UniverseCheck -> UniverseCheck -> Bool)
    -> (UniverseCheck -> UniverseCheck -> Bool)
    -> (UniverseCheck -> UniverseCheck -> Bool)
    -> (UniverseCheck -> UniverseCheck -> UniverseCheck)
    -> (UniverseCheck -> UniverseCheck -> UniverseCheck)
    -> Ord UniverseCheck
    UniverseCheck -> UniverseCheck -> Bool
    UniverseCheck -> UniverseCheck -> Ordering
    UniverseCheck -> UniverseCheck -> UniverseCheck
    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
    $ccompare :: UniverseCheck -> UniverseCheck -> Ordering
    compare :: UniverseCheck -> UniverseCheck -> Ordering
    $c< :: UniverseCheck -> UniverseCheck -> Bool
    < :: UniverseCheck -> UniverseCheck -> Bool
    $c<= :: UniverseCheck -> UniverseCheck -> Bool
    <= :: UniverseCheck -> UniverseCheck -> Bool
    $c> :: UniverseCheck -> UniverseCheck -> Bool
    > :: UniverseCheck -> UniverseCheck -> Bool
    $c>= :: UniverseCheck -> UniverseCheck -> Bool
    >= :: UniverseCheck -> UniverseCheck -> Bool
    $cmax :: UniverseCheck -> UniverseCheck -> UniverseCheck
    max :: UniverseCheck -> UniverseCheck -> UniverseCheck
    $cmin :: UniverseCheck -> UniverseCheck -> UniverseCheck
    min :: UniverseCheck -> UniverseCheck -> UniverseCheck
    Ord, Int -> UniverseCheck -> ShowS
    [UniverseCheck] -> ShowS
    UniverseCheck -> ArgName
    (Int -> UniverseCheck -> ShowS)
    -> (UniverseCheck -> ArgName)
    -> ([UniverseCheck] -> ShowS)
    -> Show UniverseCheck
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> UniverseCheck -> ShowS
    showsPrec :: Int -> UniverseCheck -> ShowS
    $cshow :: UniverseCheck -> ArgName
    show :: UniverseCheck -> ArgName
    $cshowList :: [UniverseCheck] -> ShowS
    showList :: [UniverseCheck] -> ShowS
    Show, UniverseCheck
    UniverseCheck -> UniverseCheck -> Bounded UniverseCheck
    forall a. a -> a -> Bounded a
    $cminBound :: UniverseCheck
    minBound :: UniverseCheck
    $cmaxBound :: UniverseCheck
    maxBound :: UniverseCheck
    Bounded, Int -> UniverseCheck
    UniverseCheck -> Int
    UniverseCheck -> [UniverseCheck]
    UniverseCheck -> UniverseCheck
    UniverseCheck -> UniverseCheck -> [UniverseCheck]
    UniverseCheck -> UniverseCheck -> UniverseCheck -> [UniverseCheck]
    (UniverseCheck -> UniverseCheck)
    -> (UniverseCheck -> UniverseCheck)
    -> (Int -> UniverseCheck)
    -> (UniverseCheck -> Int)
    -> (UniverseCheck -> [UniverseCheck])
    -> (UniverseCheck -> UniverseCheck -> [UniverseCheck])
    -> (UniverseCheck -> UniverseCheck -> [UniverseCheck])
    -> (UniverseCheck
        -> UniverseCheck -> UniverseCheck -> [UniverseCheck])
    -> Enum UniverseCheck
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: UniverseCheck -> UniverseCheck
    succ :: UniverseCheck -> UniverseCheck
    $cpred :: UniverseCheck -> UniverseCheck
    pred :: UniverseCheck -> UniverseCheck
    $ctoEnum :: Int -> UniverseCheck
    toEnum :: Int -> UniverseCheck
    $cfromEnum :: UniverseCheck -> Int
    fromEnum :: UniverseCheck -> Int
    $cenumFrom :: UniverseCheck -> [UniverseCheck]
    enumFrom :: UniverseCheck -> [UniverseCheck]
    $cenumFromThen :: UniverseCheck -> UniverseCheck -> [UniverseCheck]
    enumFromThen :: UniverseCheck -> UniverseCheck -> [UniverseCheck]
    $cenumFromTo :: UniverseCheck -> UniverseCheck -> [UniverseCheck]
    enumFromTo :: UniverseCheck -> UniverseCheck -> [UniverseCheck]
    $cenumFromThenTo :: UniverseCheck -> UniverseCheck -> UniverseCheck -> [UniverseCheck]
    enumFromThenTo :: UniverseCheck -> UniverseCheck -> UniverseCheck -> [UniverseCheck]
    Enum, (forall x. UniverseCheck -> Rep UniverseCheck x)
    -> (forall x. Rep UniverseCheck x -> UniverseCheck)
    -> Generic UniverseCheck
    forall x. Rep UniverseCheck x -> UniverseCheck
    forall x. UniverseCheck -> Rep UniverseCheck x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. UniverseCheck -> Rep UniverseCheck x
    from :: forall x. UniverseCheck -> Rep UniverseCheck x
    $cto :: forall x. Rep UniverseCheck x -> UniverseCheck
    to :: forall x. Rep UniverseCheck x -> UniverseCheck
    Generic)

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

    instance NFData UniverseCheck

    -----------------------------------------------------------------------------
    -- * Coverage
    -----------------------------------------------------------------------------

    -- | 'Range' of the CATCHALL pragma for a clause, if any.
    --   'Nothing' means no such pragma.
    data Catchall = YesCatchall Range | NoCatchall
      deriving (Catchall -> Catchall -> Bool
    (Catchall -> Catchall -> Bool)
    -> (Catchall -> Catchall -> Bool) -> Eq Catchall
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Catchall -> Catchall -> Bool
    == :: Catchall -> Catchall -> Bool
    $c/= :: Catchall -> Catchall -> Bool
    /= :: Catchall -> Catchall -> Bool
    Eq, Int -> Catchall -> ShowS
    [Catchall] -> ShowS
    Catchall -> ArgName
    (Int -> Catchall -> ShowS)
    -> (Catchall -> ArgName) -> ([Catchall] -> ShowS) -> Show Catchall
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Catchall -> ShowS
    showsPrec :: Int -> Catchall -> ShowS
    $cshow :: Catchall -> ArgName
    show :: Catchall -> ArgName
    $cshowList :: [Catchall] -> ShowS
    showList :: [Catchall] -> ShowS
    Show, (forall x. Catchall -> Rep Catchall x)
    -> (forall x. Rep Catchall x -> Catchall) -> Generic Catchall
    forall x. Rep Catchall x -> Catchall
    forall x. Catchall -> Rep Catchall x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Catchall -> Rep Catchall x
    from :: forall x. Catchall -> Rep Catchall x
    $cto :: forall x. Rep Catchall x -> Catchall
    to :: forall x. Rep Catchall x -> Catchall
    Generic)

    -- | Composition is left-biased, taking the left 'Range' if both have one.
    instance Semigroup Catchall where
      Catchall
    NoCatchall         <> :: Catchall -> Catchall -> Catchall
    <> Catchall
    c                   = Catchall
    c
      Catchall
    c                  <> Catchall
    NoCatchall          = Catchall
    c
      c1 :: Catchall
    c1@(YesCatchall Range
    r) <> c2 :: Catchall
    c2@(YesCatchall Range
    r') = if Range -> Bool
    forall a. Null a => a -> Bool
    null Range
    r then Catchall
    c2 else Catchall
    c1

    instance Monoid Catchall where
      mempty :: Catchall
    mempty = Catchall
    forall a. Null a => a
    empty

    instance Null Catchall where
      empty :: Catchall
    empty = Catchall
    NoCatchall

    instance KillRange Catchall where
      killRange :: Catchall -> Catchall
    killRange = \case
        YesCatchall Range
    _ -> Range -> Catchall
    YesCatchall Range
    forall a. Range' a
    noRange
        Catchall
    NoCatchall    -> Catchall
    NoCatchall

    instance NFData Catchall where
      rnf :: Catchall -> ()
    rnf = \case
        YesCatchall Range
    _ -> ()
        Catchall
    NoCatchall    -> ()

    -- | Coverage check? (Default is yes).
    data CoverageCheck = YesCoverageCheck | NoCoverageCheck
      deriving (CoverageCheck -> CoverageCheck -> Bool
    (CoverageCheck -> CoverageCheck -> Bool)
    -> (CoverageCheck -> CoverageCheck -> Bool) -> Eq CoverageCheck
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CoverageCheck -> CoverageCheck -> Bool
    == :: CoverageCheck -> CoverageCheck -> Bool
    $c/= :: CoverageCheck -> CoverageCheck -> Bool
    /= :: CoverageCheck -> CoverageCheck -> Bool
    Eq, Eq CoverageCheck
    Eq CoverageCheck =>
    (CoverageCheck -> CoverageCheck -> Ordering)
    -> (CoverageCheck -> CoverageCheck -> Bool)
    -> (CoverageCheck -> CoverageCheck -> Bool)
    -> (CoverageCheck -> CoverageCheck -> Bool)
    -> (CoverageCheck -> CoverageCheck -> Bool)
    -> (CoverageCheck -> CoverageCheck -> CoverageCheck)
    -> (CoverageCheck -> CoverageCheck -> CoverageCheck)
    -> Ord CoverageCheck
    CoverageCheck -> CoverageCheck -> Bool
    CoverageCheck -> CoverageCheck -> Ordering
    CoverageCheck -> CoverageCheck -> CoverageCheck
    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
    $ccompare :: CoverageCheck -> CoverageCheck -> Ordering
    compare :: CoverageCheck -> CoverageCheck -> Ordering
    $c< :: CoverageCheck -> CoverageCheck -> Bool
    < :: CoverageCheck -> CoverageCheck -> Bool
    $c<= :: CoverageCheck -> CoverageCheck -> Bool
    <= :: CoverageCheck -> CoverageCheck -> Bool
    $c> :: CoverageCheck -> CoverageCheck -> Bool
    > :: CoverageCheck -> CoverageCheck -> Bool
    $c>= :: CoverageCheck -> CoverageCheck -> Bool
    >= :: CoverageCheck -> CoverageCheck -> Bool
    $cmax :: CoverageCheck -> CoverageCheck -> CoverageCheck
    max :: CoverageCheck -> CoverageCheck -> CoverageCheck
    $cmin :: CoverageCheck -> CoverageCheck -> CoverageCheck
    min :: CoverageCheck -> CoverageCheck -> CoverageCheck
    Ord, Int -> CoverageCheck -> ShowS
    [CoverageCheck] -> ShowS
    CoverageCheck -> ArgName
    (Int -> CoverageCheck -> ShowS)
    -> (CoverageCheck -> ArgName)
    -> ([CoverageCheck] -> ShowS)
    -> Show CoverageCheck
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CoverageCheck -> ShowS
    showsPrec :: Int -> CoverageCheck -> ShowS
    $cshow :: CoverageCheck -> ArgName
    show :: CoverageCheck -> ArgName
    $cshowList :: [CoverageCheck] -> ShowS
    showList :: [CoverageCheck] -> ShowS
    Show, CoverageCheck
    CoverageCheck -> CoverageCheck -> Bounded CoverageCheck
    forall a. a -> a -> Bounded a
    $cminBound :: CoverageCheck
    minBound :: CoverageCheck
    $cmaxBound :: CoverageCheck
    maxBound :: CoverageCheck
    Bounded, Int -> CoverageCheck
    CoverageCheck -> Int
    CoverageCheck -> [CoverageCheck]
    CoverageCheck -> CoverageCheck
    CoverageCheck -> CoverageCheck -> [CoverageCheck]
    CoverageCheck -> CoverageCheck -> CoverageCheck -> [CoverageCheck]
    (CoverageCheck -> CoverageCheck)
    -> (CoverageCheck -> CoverageCheck)
    -> (Int -> CoverageCheck)
    -> (CoverageCheck -> Int)
    -> (CoverageCheck -> [CoverageCheck])
    -> (CoverageCheck -> CoverageCheck -> [CoverageCheck])
    -> (CoverageCheck -> CoverageCheck -> [CoverageCheck])
    -> (CoverageCheck
        -> CoverageCheck -> CoverageCheck -> [CoverageCheck])
    -> Enum CoverageCheck
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: CoverageCheck -> CoverageCheck
    succ :: CoverageCheck -> CoverageCheck
    $cpred :: CoverageCheck -> CoverageCheck
    pred :: CoverageCheck -> CoverageCheck
    $ctoEnum :: Int -> CoverageCheck
    toEnum :: Int -> CoverageCheck
    $cfromEnum :: CoverageCheck -> Int
    fromEnum :: CoverageCheck -> Int
    $cenumFrom :: CoverageCheck -> [CoverageCheck]
    enumFrom :: CoverageCheck -> [CoverageCheck]
    $cenumFromThen :: CoverageCheck -> CoverageCheck -> [CoverageCheck]
    enumFromThen :: CoverageCheck -> CoverageCheck -> [CoverageCheck]
    $cenumFromTo :: CoverageCheck -> CoverageCheck -> [CoverageCheck]
    enumFromTo :: CoverageCheck -> CoverageCheck -> [CoverageCheck]
    $cenumFromThenTo :: CoverageCheck -> CoverageCheck -> CoverageCheck -> [CoverageCheck]
    enumFromThenTo :: CoverageCheck -> CoverageCheck -> CoverageCheck -> [CoverageCheck]
    Enum, (forall x. CoverageCheck -> Rep CoverageCheck x)
    -> (forall x. Rep CoverageCheck x -> CoverageCheck)
    -> Generic CoverageCheck
    forall x. Rep CoverageCheck x -> CoverageCheck
    forall x. CoverageCheck -> Rep CoverageCheck x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. CoverageCheck -> Rep CoverageCheck x
    from :: forall x. CoverageCheck -> Rep CoverageCheck x
    $cto :: forall x. Rep CoverageCheck x -> CoverageCheck
    to :: forall x. Rep CoverageCheck x -> CoverageCheck
    Generic)

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

    -- Semigroup and Monoid via conjunction
    instance Semigroup CoverageCheck where
      CoverageCheck
    NoCoverageCheck <> :: CoverageCheck -> CoverageCheck -> CoverageCheck
    <> CoverageCheck
    _ = CoverageCheck
    NoCoverageCheck
      CoverageCheck
    _ <> CoverageCheck
    NoCoverageCheck = CoverageCheck
    NoCoverageCheck
      CoverageCheck
    _ <> CoverageCheck
    _ = CoverageCheck
    YesCoverageCheck

    instance Monoid CoverageCheck where
      mempty :: CoverageCheck
    mempty  = CoverageCheck
    YesCoverageCheck
      mappend :: CoverageCheck -> CoverageCheck -> CoverageCheck
    mappend = CoverageCheck -> CoverageCheck -> CoverageCheck
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance NFData CoverageCheck

    -----------------------------------------------------------------------------
    -- * Rewrite Directives on the LHS
    -----------------------------------------------------------------------------

    -- | @RewriteEqn' qn p e@ represents the @rewrite@ and irrefutable @with@
    --   clauses of the LHS.
    --   @qn@ stands for the QName of the auxiliary function generated to implement the feature
    --   @nm@ is the type of names for pattern variables
    --   @p@  is the type of patterns
    --   @e@  is the type of expressions

    data RewriteEqn' qn nm p e
      = Rewrite (List1 (qn, e))             -- ^ @rewrite e@
      | Invert qn (List1 (Named nm (p, e))) -- ^ @with p <- e in eq@
      | LeftLet (List1 (p, e))              -- ^ @using p <- e@
      deriving (RewriteEqn' qn nm p e -> RewriteEqn' qn nm p e -> Bool
    (RewriteEqn' qn nm p e -> RewriteEqn' qn nm p e -> Bool)
    -> (RewriteEqn' qn nm p e -> RewriteEqn' qn nm p e -> Bool)
    -> Eq (RewriteEqn' qn nm p e)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall qn nm p e.
    (Eq e, Eq qn, Eq nm, Eq p) =>
    RewriteEqn' qn nm p e -> RewriteEqn' qn nm p e -> Bool
    $c== :: forall qn nm p e.
    (Eq e, Eq qn, Eq nm, Eq p) =>
    RewriteEqn' qn nm p e -> RewriteEqn' qn nm p e -> Bool
    == :: RewriteEqn' qn nm p e -> RewriteEqn' qn nm p e -> Bool
    $c/= :: forall qn nm p e.
    (Eq e, Eq qn, Eq nm, Eq p) =>
    RewriteEqn' qn nm p e -> RewriteEqn' qn nm p e -> Bool
    /= :: RewriteEqn' qn nm p e -> RewriteEqn' qn nm p e -> Bool
    Eq, Int -> RewriteEqn' qn nm p e -> ShowS
    [RewriteEqn' qn nm p e] -> ShowS
    RewriteEqn' qn nm p e -> ArgName
    (Int -> RewriteEqn' qn nm p e -> ShowS)
    -> (RewriteEqn' qn nm p e -> ArgName)
    -> ([RewriteEqn' qn nm p e] -> ShowS)
    -> Show (RewriteEqn' qn nm p e)
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    forall qn nm p e.
    (Show e, Show qn, Show nm, Show p) =>
    Int -> RewriteEqn' qn nm p e -> ShowS
    forall qn nm p e.
    (Show e, Show qn, Show nm, Show p) =>
    [RewriteEqn' qn nm p e] -> ShowS
    forall qn nm p e.
    (Show e, Show qn, Show nm, Show p) =>
    RewriteEqn' qn nm p e -> ArgName
    $cshowsPrec :: forall qn nm p e.
    (Show e, Show qn, Show nm, Show p) =>
    Int -> RewriteEqn' qn nm p e -> ShowS
    showsPrec :: Int -> RewriteEqn' qn nm p e -> ShowS
    $cshow :: forall qn nm p e.
    (Show e, Show qn, Show nm, Show p) =>
    RewriteEqn' qn nm p e -> ArgName
    show :: RewriteEqn' qn nm p e -> ArgName
    $cshowList :: forall qn nm p e.
    (Show e, Show qn, Show nm, Show p) =>
    [RewriteEqn' qn nm p e] -> ShowS
    showList :: [RewriteEqn' qn nm p e] -> ShowS
    Show, (forall a b.
     (a -> b) -> RewriteEqn' qn nm p a -> RewriteEqn' qn nm p b)
    -> (forall a b.
        a -> RewriteEqn' qn nm p b -> RewriteEqn' qn nm p a)
    -> Functor (RewriteEqn' qn nm p)
    forall a b. a -> RewriteEqn' qn nm p b -> RewriteEqn' qn nm p a
    forall a b.
    (a -> b) -> RewriteEqn' qn nm p a -> RewriteEqn' qn nm p b
    forall qn nm p a b.
    a -> RewriteEqn' qn nm p b -> RewriteEqn' qn nm p a
    forall qn nm p a b.
    (a -> b) -> RewriteEqn' qn nm p a -> RewriteEqn' qn nm p b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall qn nm p a b.
    (a -> b) -> RewriteEqn' qn nm p a -> RewriteEqn' qn nm p b
    fmap :: forall a b.
    (a -> b) -> RewriteEqn' qn nm p a -> RewriteEqn' qn nm p b
    $c<$ :: forall qn nm p a b.
    a -> RewriteEqn' qn nm p b -> RewriteEqn' qn nm p a
    <$ :: forall a b. a -> RewriteEqn' qn nm p b -> RewriteEqn' qn nm p a
    Functor, (forall m. Monoid m => RewriteEqn' qn nm p m -> m)
    -> (forall m a. Monoid m => (a -> m) -> RewriteEqn' qn nm p a -> m)
    -> (forall m a. Monoid m => (a -> m) -> RewriteEqn' qn nm p a -> m)
    -> (forall a b. (a -> b -> b) -> b -> RewriteEqn' qn nm p a -> b)
    -> (forall a b. (a -> b -> b) -> b -> RewriteEqn' qn nm p a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RewriteEqn' qn nm p a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RewriteEqn' qn nm p a -> b)
    -> (forall a. (a -> a -> a) -> RewriteEqn' qn nm p a -> a)
    -> (forall a. (a -> a -> a) -> RewriteEqn' qn nm p a -> a)
    -> (forall a. RewriteEqn' qn nm p a -> [a])
    -> (forall a. RewriteEqn' qn nm p a -> Bool)
    -> (forall a. RewriteEqn' qn nm p a -> Int)
    -> (forall a. Eq a => a -> RewriteEqn' qn nm p a -> Bool)
    -> (forall a. Ord a => RewriteEqn' qn nm p a -> a)
    -> (forall a. Ord a => RewriteEqn' qn nm p a -> a)
    -> (forall a. Num a => RewriteEqn' qn nm p a -> a)
    -> (forall a. Num a => RewriteEqn' qn nm p a -> a)
    -> Foldable (RewriteEqn' qn nm p)
    forall a. Eq a => a -> RewriteEqn' qn nm p a -> Bool
    forall a. Num a => RewriteEqn' qn nm p a -> a
    forall a. Ord a => RewriteEqn' qn nm p a -> a
    forall m. Monoid m => RewriteEqn' qn nm p m -> m
    forall a. RewriteEqn' qn nm p a -> Bool
    forall a. RewriteEqn' qn nm p a -> Int
    forall a. RewriteEqn' qn nm p a -> [a]
    forall a. (a -> a -> a) -> RewriteEqn' qn nm p a -> a
    forall m a. Monoid m => (a -> m) -> RewriteEqn' qn nm p a -> m
    forall b a. (b -> a -> b) -> b -> RewriteEqn' qn nm p a -> b
    forall a b. (a -> b -> b) -> b -> RewriteEqn' qn nm p a -> b
    forall qn nm p a. Eq a => a -> RewriteEqn' qn nm p a -> Bool
    forall qn nm p a. Num a => RewriteEqn' qn nm p a -> a
    forall qn nm p a. Ord a => RewriteEqn' qn nm p a -> a
    forall qn nm p m. Monoid m => RewriteEqn' qn nm p m -> m
    forall qn nm p a. RewriteEqn' qn nm p a -> Bool
    forall qn nm p a. RewriteEqn' qn nm p a -> Int
    forall qn nm p a. RewriteEqn' qn nm p a -> [a]
    forall qn nm p a. (a -> a -> a) -> RewriteEqn' qn nm p a -> a
    forall qn nm p m a.
    Monoid m =>
    (a -> m) -> RewriteEqn' qn nm p a -> m
    forall qn nm p b a.
    (b -> a -> b) -> b -> RewriteEqn' qn nm p a -> b
    forall qn nm p a b.
    (a -> b -> b) -> b -> RewriteEqn' qn nm p 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
    $cfold :: forall qn nm p m. Monoid m => RewriteEqn' qn nm p m -> m
    fold :: forall m. Monoid m => RewriteEqn' qn nm p m -> m
    $cfoldMap :: forall qn nm p m a.
    Monoid m =>
    (a -> m) -> RewriteEqn' qn nm p a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> RewriteEqn' qn nm p a -> m
    $cfoldMap' :: forall qn nm p m a.
    Monoid m =>
    (a -> m) -> RewriteEqn' qn nm p a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> RewriteEqn' qn nm p a -> m
    $cfoldr :: forall qn nm p a b.
    (a -> b -> b) -> b -> RewriteEqn' qn nm p a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> RewriteEqn' qn nm p a -> b
    $cfoldr' :: forall qn nm p a b.
    (a -> b -> b) -> b -> RewriteEqn' qn nm p a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> RewriteEqn' qn nm p a -> b
    $cfoldl :: forall qn nm p b a.
    (b -> a -> b) -> b -> RewriteEqn' qn nm p a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> RewriteEqn' qn nm p a -> b
    $cfoldl' :: forall qn nm p b a.
    (b -> a -> b) -> b -> RewriteEqn' qn nm p a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> RewriteEqn' qn nm p a -> b
    $cfoldr1 :: forall qn nm p a. (a -> a -> a) -> RewriteEqn' qn nm p a -> a
    foldr1 :: forall a. (a -> a -> a) -> RewriteEqn' qn nm p a -> a
    $cfoldl1 :: forall qn nm p a. (a -> a -> a) -> RewriteEqn' qn nm p a -> a
    foldl1 :: forall a. (a -> a -> a) -> RewriteEqn' qn nm p a -> a
    $ctoList :: forall qn nm p a. RewriteEqn' qn nm p a -> [a]
    toList :: forall a. RewriteEqn' qn nm p a -> [a]
    $cnull :: forall qn nm p a. RewriteEqn' qn nm p a -> Bool
    null :: forall a. RewriteEqn' qn nm p a -> Bool
    $clength :: forall qn nm p a. RewriteEqn' qn nm p a -> Int
    length :: forall a. RewriteEqn' qn nm p a -> Int
    $celem :: forall qn nm p a. Eq a => a -> RewriteEqn' qn nm p a -> Bool
    elem :: forall a. Eq a => a -> RewriteEqn' qn nm p a -> Bool
    $cmaximum :: forall qn nm p a. Ord a => RewriteEqn' qn nm p a -> a
    maximum :: forall a. Ord a => RewriteEqn' qn nm p a -> a
    $cminimum :: forall qn nm p a. Ord a => RewriteEqn' qn nm p a -> a
    minimum :: forall a. Ord a => RewriteEqn' qn nm p a -> a
    $csum :: forall qn nm p a. Num a => RewriteEqn' qn nm p a -> a
    sum :: forall a. Num a => RewriteEqn' qn nm p a -> a
    $cproduct :: forall qn nm p a. Num a => RewriteEqn' qn nm p a -> a
    product :: forall a. Num a => RewriteEqn' qn nm p a -> a
    Foldable, Functor (RewriteEqn' qn nm p)
    Foldable (RewriteEqn' qn nm p)
    (Functor (RewriteEqn' qn nm p), Foldable (RewriteEqn' qn nm p)) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> RewriteEqn' qn nm p a -> f (RewriteEqn' qn nm p b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        RewriteEqn' qn nm p (f a) -> f (RewriteEqn' qn nm p a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> RewriteEqn' qn nm p a -> m (RewriteEqn' qn nm p b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        RewriteEqn' qn nm p (m a) -> m (RewriteEqn' qn nm p a))
    -> Traversable (RewriteEqn' qn nm p)
    forall qn nm p. Functor (RewriteEqn' qn nm p)
    forall qn nm p. Foldable (RewriteEqn' qn nm p)
    forall qn nm p (m :: * -> *) a.
    Monad m =>
    RewriteEqn' qn nm p (m a) -> m (RewriteEqn' qn nm p a)
    forall qn nm p (f :: * -> *) a.
    Applicative f =>
    RewriteEqn' qn nm p (f a) -> f (RewriteEqn' qn nm p a)
    forall qn nm p (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RewriteEqn' qn nm p a -> m (RewriteEqn' qn nm p b)
    forall qn nm p (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RewriteEqn' qn nm p a -> f (RewriteEqn' qn nm p b)
    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 =>
    RewriteEqn' qn nm p (m a) -> m (RewriteEqn' qn nm p a)
    forall (f :: * -> *) a.
    Applicative f =>
    RewriteEqn' qn nm p (f a) -> f (RewriteEqn' qn nm p a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RewriteEqn' qn nm p a -> m (RewriteEqn' qn nm p b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RewriteEqn' qn nm p a -> f (RewriteEqn' qn nm p b)
    $ctraverse :: forall qn nm p (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RewriteEqn' qn nm p a -> f (RewriteEqn' qn nm p b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RewriteEqn' qn nm p a -> f (RewriteEqn' qn nm p b)
    $csequenceA :: forall qn nm p (f :: * -> *) a.
    Applicative f =>
    RewriteEqn' qn nm p (f a) -> f (RewriteEqn' qn nm p a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    RewriteEqn' qn nm p (f a) -> f (RewriteEqn' qn nm p a)
    $cmapM :: forall qn nm p (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RewriteEqn' qn nm p a -> m (RewriteEqn' qn nm p b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RewriteEqn' qn nm p a -> m (RewriteEqn' qn nm p b)
    $csequence :: forall qn nm p (m :: * -> *) a.
    Monad m =>
    RewriteEqn' qn nm p (m a) -> m (RewriteEqn' qn nm p a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    RewriteEqn' qn nm p (m a) -> m (RewriteEqn' qn nm p a)
    Traversable)

    instance (NFData qn, NFData nm, NFData p, NFData e) => NFData (RewriteEqn' qn nm p e) where
      rnf :: RewriteEqn' qn nm p e -> ()
    rnf = \case
        Rewrite List1 (qn, e)
    es    -> List1 (qn, e) -> ()
    forall a. NFData a => a -> ()
    rnf List1 (qn, e)
    es
        Invert qn
    qn List1 (Named nm (p, e))
    pes -> (qn, List1 (Named nm (p, e))) -> ()
    forall a. NFData a => a -> ()
    rnf (qn
    qn, List1 (Named nm (p, e))
    pes)
        LeftLet List1 (p, e)
    pes   -> List1 (p, e) -> ()
    forall a. NFData a => a -> ()
    rnf List1 (p, e)
    pes

    instance (Pretty nm, Pretty p, Pretty e) => Pretty (RewriteEqn' qn nm p e) where
      pretty :: RewriteEqn' qn nm p e -> Doc
    pretty = \case
        Rewrite List1 (qn, e)
    es   -> Doc -> [Doc] -> Doc
    prefixedThings (ArgName -> Doc
    forall a. ArgName -> Doc a
    text ArgName
    "rewrite") ([Doc] -> Doc) -> [Doc] -> Doc
    forall a b. (a -> b) -> a -> b
    $ NonEmpty Doc -> [Item (NonEmpty Doc)]
    forall l. IsList l => l -> [Item l]
    List1.toList (e -> Doc
    forall a. Pretty a => a -> Doc
    pretty (e -> Doc) -> ((qn, e) -> e) -> (qn, e) -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (qn, e) -> e
    forall a b. (a, b) -> b
    snd ((qn, e) -> Doc) -> List1 (qn, e) -> NonEmpty Doc
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> List1 (qn, e)
    es)
        LeftLet List1 (p, e)
    pes  -> Doc -> [Doc] -> Doc
    prefixedThings (ArgName -> Doc
    forall a. ArgName -> Doc a
    text ArgName
    "using") [p -> Doc
    forall a. Pretty a => a -> Doc
    pretty p
    p Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+> Doc
    "<-" Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+> e -> Doc
    forall a. Pretty a => a -> Doc
    pretty e
    e | (p
    p, e
    e) <- List1 (p, e) -> [Item (List1 (p, e))]
    forall l. IsList l => l -> [Item l]
    List1.toList List1 (p, e)
    pes]
        Invert qn
    _ List1 (Named nm (p, e))
    pes -> Doc -> [Doc] -> Doc
    prefixedThings (ArgName -> Doc
    forall a. ArgName -> Doc a
    text ArgName
    "invert") ([Doc] -> Doc) -> [Doc] -> Doc
    forall a b. (a -> b) -> a -> b
    $ NonEmpty Doc -> [Item (NonEmpty Doc)]
    forall l. IsList l => l -> [Item l]
    List1.toList (Named nm (p, e) -> Doc
    forall {a} {a} {a}.
    (Pretty a, Pretty a, Pretty a) =>
    Named a (a, a) -> Doc
    namedWith (Named nm (p, e) -> Doc) -> List1 (Named nm (p, e)) -> NonEmpty Doc
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> List1 (Named nm (p, e))
    pes) where

          namedWith :: Named a (a, a) -> Doc
    namedWith (Named Maybe a
    nm (a
    p, a
    e)) =
            let patexp :: Doc
    patexp = a -> Doc
    forall a. Pretty a => a -> Doc
    pretty a
    p Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+> Doc
    "<-" Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+> a -> Doc
    forall a. Pretty a => a -> Doc
    pretty a
    e in
            case Maybe a
    nm of
              Maybe a
    Nothing -> Doc
    patexp
              Just a
    nm -> a -> Doc
    forall a. Pretty a => a -> Doc
    pretty a
    nm Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+> Doc
    ":" Doc -> Doc -> Doc
    forall a. Doc a -> Doc a -> Doc a
    <+> Doc
    patexp

    instance (HasRange qn, HasRange nm, HasRange p, HasRange e) => HasRange (RewriteEqn' qn nm p e) where
      getRange :: RewriteEqn' qn nm p e -> Range
    getRange = \case
        Rewrite List1 (qn, e)
    es    -> List1 (qn, e) -> Range
    forall a. HasRange a => a -> Range
    getRange List1 (qn, e)
    es
        Invert qn
    qn List1 (Named nm (p, e))
    pes -> (qn, List1 (Named nm (p, e))) -> Range
    forall a. HasRange a => a -> Range
    getRange (qn
    qn, List1 (Named nm (p, e))
    pes)
        LeftLet List1 (p, e)
    pes   -> List1 (p, e) -> Range
    forall a. HasRange a => a -> Range
    getRange List1 (p, e)
    pes

    instance (KillRange qn, KillRange nm, KillRange e, KillRange p) => KillRange (RewriteEqn' qn nm p e) where
      killRange :: KillRangeT (RewriteEqn' qn nm p e)
    killRange = \case
        Rewrite List1 (qn, e)
    es    -> (List1 (qn, e) -> RewriteEqn' qn nm p e)
    -> List1 (qn, e) -> RewriteEqn' qn nm p e
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN List1 (qn, e) -> RewriteEqn' qn nm p e
    forall qn nm p e. List1 (qn, e) -> RewriteEqn' qn nm p e
    Rewrite List1 (qn, e)
    es
        Invert qn
    qn List1 (Named nm (p, e))
    pes -> (qn -> List1 (Named nm (p, e)) -> RewriteEqn' qn nm p e)
    -> qn -> List1 (Named nm (p, e)) -> RewriteEqn' qn nm p e
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN qn -> List1 (Named nm (p, e)) -> RewriteEqn' qn nm p e
    forall qn nm p e.
    qn -> List1 (Named nm (p, e)) -> RewriteEqn' qn nm p e
    Invert qn
    qn List1 (Named nm (p, e))
    pes
        LeftLet List1 (p, e)
    pes   -> (List1 (p, e) -> RewriteEqn' qn nm p e)
    -> List1 (p, e) -> RewriteEqn' qn nm p e
    forall t (b :: Bool).
    (KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
    t -> t
    killRangeN List1 (p, e) -> RewriteEqn' qn nm p e
    forall qn nm p e. List1 (p, e) -> RewriteEqn' qn nm p e
    LeftLet List1 (p, e)
    pes

    -----------------------------------------------------------------------------
    -- * Information on expanded ellipsis (@...@)
    -----------------------------------------------------------------------------

    -- ^ When the ellipsis in a clause is expanded, we remember that we
    --   did so. We also store the number of with-arguments that are
    --   included in the expanded ellipsis.
    data ExpandedEllipsis
      = ExpandedEllipsis
      { ExpandedEllipsis -> Range
    ellipsisRange :: Range
      , ExpandedEllipsis -> Int
    ellipsisWithArgs :: Int
      }
      | NoEllipsis
      deriving (Int -> ExpandedEllipsis -> ShowS
    [ExpandedEllipsis] -> ShowS
    ExpandedEllipsis -> ArgName
    (Int -> ExpandedEllipsis -> ShowS)
    -> (ExpandedEllipsis -> ArgName)
    -> ([ExpandedEllipsis] -> ShowS)
    -> Show ExpandedEllipsis
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ExpandedEllipsis -> ShowS
    showsPrec :: Int -> ExpandedEllipsis -> ShowS
    $cshow :: ExpandedEllipsis -> ArgName
    show :: ExpandedEllipsis -> ArgName
    $cshowList :: [ExpandedEllipsis] -> ShowS
    showList :: [ExpandedEllipsis] -> ShowS
    Show, ExpandedEllipsis -> ExpandedEllipsis -> Bool
    (ExpandedEllipsis -> ExpandedEllipsis -> Bool)
    -> (ExpandedEllipsis -> ExpandedEllipsis -> Bool)
    -> Eq ExpandedEllipsis
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ExpandedEllipsis -> ExpandedEllipsis -> Bool
    == :: ExpandedEllipsis -> ExpandedEllipsis -> Bool
    $c/= :: ExpandedEllipsis -> ExpandedEllipsis -> Bool
    /= :: ExpandedEllipsis -> ExpandedEllipsis -> Bool
    Eq)

    instance Null ExpandedEllipsis where
      empty :: ExpandedEllipsis
    empty = ExpandedEllipsis
    NoEllipsis

    instance Semigroup ExpandedEllipsis where
      ExpandedEllipsis
    NoEllipsis <> :: ExpandedEllipsis -> ExpandedEllipsis -> ExpandedEllipsis
    <> ExpandedEllipsis
    e          = ExpandedEllipsis
    e
      ExpandedEllipsis
    e          <> ExpandedEllipsis
    NoEllipsis = ExpandedEllipsis
    e
      (ExpandedEllipsis Range
    r1 Int
    k1) <> (ExpandedEllipsis Range
    r2 Int
    k2) = Range -> Int -> ExpandedEllipsis
    ExpandedEllipsis (Range
    r1 Range -> Range -> Range
    forall a. Semigroup a => a -> a -> a
    <> Range
    r2) (Int
    k1 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    k2)

    instance Monoid ExpandedEllipsis where
      mempty :: ExpandedEllipsis
    mempty  = ExpandedEllipsis
    NoEllipsis
      mappend :: ExpandedEllipsis -> ExpandedEllipsis -> ExpandedEllipsis
    mappend = ExpandedEllipsis -> ExpandedEllipsis -> ExpandedEllipsis
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance KillRange ExpandedEllipsis where
      killRange :: ExpandedEllipsis -> ExpandedEllipsis
    killRange (ExpandedEllipsis Range
    _ Int
    k) = Range -> Int -> ExpandedEllipsis
    ExpandedEllipsis Range
    forall a. Range' a
    noRange Int
    k
      killRange ExpandedEllipsis
    NoEllipsis             = ExpandedEllipsis
    NoEllipsis

    instance NFData ExpandedEllipsis where
      rnf :: ExpandedEllipsis -> ()
    rnf (ExpandedEllipsis Range
    _ Int
    a) = Int -> ()
    forall a. NFData a => a -> ()
    rnf Int
    a
      rnf ExpandedEllipsis
    NoEllipsis             = ()

    -- | Notation as provided by the @syntax@ declaration.
    type Notation = [NotationPart]

    noNotation :: Notation
    noNotation :: Notation
    noNotation = []

    -- | Positions of variables in syntax declarations.

    data BoundVariablePosition = BoundVariablePosition
      { BoundVariablePosition -> Int
    holeNumber :: !Int
        -- ^ The position (in the left-hand side of the syntax
        -- declaration) of the hole in which the variable is bound,
        -- counting from zero (and excluding parts that are not holes).
        -- For instance, for @syntax Σ A (λ x → B) = B , A , x@ the number
        -- for @x@ is @1@, corresponding to @B@ (@0@ would correspond to
        -- @A@).
      , BoundVariablePosition -> Int
    varNumber :: !Int
        -- ^ The position in the list of variables for this particular
        -- variable, counting from zero, and including wildcards. For
        -- instance, for @syntax F (λ x _ y → A) = y ! A ! x@ the number
        -- for @x@ is @0@, the number for @_@ is @1@, and the number for
        -- @y@ is @2@.
      }
      deriving (BoundVariablePosition -> BoundVariablePosition -> Bool
    (BoundVariablePosition -> BoundVariablePosition -> Bool)
    -> (BoundVariablePosition -> BoundVariablePosition -> Bool)
    -> Eq BoundVariablePosition
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BoundVariablePosition -> BoundVariablePosition -> Bool
    == :: BoundVariablePosition -> BoundVariablePosition -> Bool
    $c/= :: BoundVariablePosition -> BoundVariablePosition -> Bool
    /= :: BoundVariablePosition -> BoundVariablePosition -> Bool
    Eq, Eq BoundVariablePosition
    Eq BoundVariablePosition =>
    (BoundVariablePosition -> BoundVariablePosition -> Ordering)
    -> (BoundVariablePosition -> BoundVariablePosition -> Bool)
    -> (BoundVariablePosition -> BoundVariablePosition -> Bool)
    -> (BoundVariablePosition -> BoundVariablePosition -> Bool)
    -> (BoundVariablePosition -> BoundVariablePosition -> Bool)
    -> (BoundVariablePosition
        -> BoundVariablePosition -> BoundVariablePosition)
    -> (BoundVariablePosition
        -> BoundVariablePosition -> BoundVariablePosition)
    -> Ord BoundVariablePosition
    BoundVariablePosition -> BoundVariablePosition -> Bool
    BoundVariablePosition -> BoundVariablePosition -> Ordering
    BoundVariablePosition
    -> BoundVariablePosition -> BoundVariablePosition
    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
    $ccompare :: BoundVariablePosition -> BoundVariablePosition -> Ordering
    compare :: BoundVariablePosition -> BoundVariablePosition -> Ordering
    $c< :: BoundVariablePosition -> BoundVariablePosition -> Bool
    < :: BoundVariablePosition -> BoundVariablePosition -> Bool
    $c<= :: BoundVariablePosition -> BoundVariablePosition -> Bool
    <= :: BoundVariablePosition -> BoundVariablePosition -> Bool
    $c> :: BoundVariablePosition -> BoundVariablePosition -> Bool
    > :: BoundVariablePosition -> BoundVariablePosition -> Bool
    $c>= :: BoundVariablePosition -> BoundVariablePosition -> Bool
    >= :: BoundVariablePosition -> BoundVariablePosition -> Bool
    $cmax :: BoundVariablePosition
    -> BoundVariablePosition -> BoundVariablePosition
    max :: BoundVariablePosition
    -> BoundVariablePosition -> BoundVariablePosition
    $cmin :: BoundVariablePosition
    -> BoundVariablePosition -> BoundVariablePosition
    min :: BoundVariablePosition
    -> BoundVariablePosition -> BoundVariablePosition
    Ord, Int -> BoundVariablePosition -> ShowS
    [BoundVariablePosition] -> ShowS
    BoundVariablePosition -> ArgName
    (Int -> BoundVariablePosition -> ShowS)
    -> (BoundVariablePosition -> ArgName)
    -> ([BoundVariablePosition] -> ShowS)
    -> Show BoundVariablePosition
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BoundVariablePosition -> ShowS
    showsPrec :: Int -> BoundVariablePosition -> ShowS
    $cshow :: BoundVariablePosition -> ArgName
    show :: BoundVariablePosition -> ArgName
    $cshowList :: [BoundVariablePosition] -> ShowS
    showList :: [BoundVariablePosition] -> ShowS
    Show)

    -- | Notation parts.

    data NotationPart
      = IdPart RString
        -- ^ An identifier part. For instance, for @_+_@ the only
        -- identifier part is @+@.
      | HolePart Range (NamedArg (Ranged Int))
        -- ^ A hole: a place where argument expressions can be written.
        -- For instance, for @_+_@ the two underscores are holes, and for
        -- @syntax Σ A (λ x → B) = B , A , x@ the variables @A@ and @B@
        -- are holes. The number is the position of the hole, counting
        -- from zero. For instance, the number for @A@ is @0@, and the
        -- number for @B@ is @1@.
      | VarPart Range (Ranged BoundVariablePosition)
        -- ^ A bound variable.
        --
        -- The first range is the range of the variable in the right-hand
        -- side of the syntax declaration, and the second range is the
        -- range of the variable in the left-hand side.
      | WildPart (Ranged BoundVariablePosition)
        -- ^ A wildcard (an underscore in binding position).
      deriving Int -> NotationPart -> ShowS
    Notation -> ShowS
    NotationPart -> ArgName
    (Int -> NotationPart -> ShowS)
    -> (NotationPart -> ArgName)
    -> (Notation -> ShowS)
    -> Show NotationPart
    forall a.
    (Int -> a -> ShowS) -> (a -> ArgName) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> NotationPart -> ShowS
    showsPrec :: Int -> NotationPart -> ShowS
    $cshow :: NotationPart -> ArgName
    show :: NotationPart -> ArgName
    $cshowList :: Notation -> ShowS
    showList :: Notation -> ShowS
    Show

    instance Eq NotationPart where
      VarPart Range
    _ Ranged BoundVariablePosition
    i  == :: NotationPart -> NotationPart -> Bool
    == VarPart Range
    _ Ranged BoundVariablePosition
    j  = Ranged BoundVariablePosition
    i Ranged BoundVariablePosition
    -> Ranged BoundVariablePosition -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ranged BoundVariablePosition
    j
      HolePart Range
    _ NamedArg (Ranged Int)
    x == HolePart Range
    _ NamedArg (Ranged Int)
    y = NamedArg (Ranged Int)
    x NamedArg (Ranged Int) -> NamedArg (Ranged Int) -> Bool
    forall a. Eq a => a -> a -> Bool
    == NamedArg (Ranged Int)
    y
      WildPart Ranged BoundVariablePosition
    i   == WildPart Ranged BoundVariablePosition
    j   = Ranged BoundVariablePosition
    i Ranged BoundVariablePosition
    -> Ranged BoundVariablePosition -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ranged BoundVariablePosition
    j
      IdPart Ranged ArgName
    x     == IdPart Ranged ArgName
    y     = Ranged ArgName
    x Ranged ArgName -> Ranged ArgName -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ranged ArgName
    y
      NotationPart
    _            == NotationPart
    _            = Bool
    False

    instance Ord NotationPart where
      VarPart Range
    _ Ranged BoundVariablePosition
    i  compare :: NotationPart -> NotationPart -> Ordering
    `compare` VarPart Range
    _ Ranged BoundVariablePosition
    j  = Ranged BoundVariablePosition
    i Ranged BoundVariablePosition
    -> Ranged BoundVariablePosition -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` Ranged BoundVariablePosition
    j
      HolePart Range
    _ NamedArg (Ranged Int)
    x `compare` HolePart Range
    _ NamedArg (Ranged Int)
    y = NamedArg (Ranged Int)
    x NamedArg (Ranged Int) -> NamedArg (Ranged Int) -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` NamedArg (Ranged Int)
    y
      WildPart Ranged BoundVariablePosition
    i   `compare` WildPart Ranged BoundVariablePosition
    j   = Ranged BoundVariablePosition
    i Ranged BoundVariablePosition
    -> Ranged BoundVariablePosition -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` Ranged BoundVariablePosition
    j
      IdPart Ranged ArgName
    x     `compare` IdPart Ranged ArgName
    y     = Ranged ArgName
    x Ranged ArgName -> Ranged ArgName -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` Ranged ArgName
    y
      VarPart{}    `compare` NotationPart
    _            = Ordering
    LT
      NotationPart
    _            `compare` VarPart{}    = Ordering
    GT
      HolePart{}   `compare` NotationPart
    _            = Ordering
    LT
      NotationPart
    _            `compare` HolePart{}   = Ordering
    GT
      WildPart{}   `compare` NotationPart
    _            = Ordering
    LT
      NotationPart
    _            `compare` WildPart{}   = Ordering
    GT

    instance HasRange NotationPart where
      getRange :: NotationPart -> Range
    getRange = \case
        IdPart Ranged ArgName
    x     -> Ranged ArgName -> Range
    forall a. HasRange a => a -> Range
    getRange Ranged ArgName
    x
        VarPart Range
    r Ranged BoundVariablePosition
    _  -> Range
    r
        WildPart Ranged BoundVariablePosition
    i   -> Ranged BoundVariablePosition -> Range
    forall a. HasRange a => a -> Range
    getRange Ranged BoundVariablePosition
    i
        HolePart Range
    r NamedArg (Ranged Int)
    _ -> Range
    r

    instance SetRange NotationPart where
      setRange :: Range -> NotationPart -> NotationPart
    setRange Range
    r = \case
        IdPart Ranged ArgName
    x     -> Ranged ArgName -> NotationPart
    IdPart Ranged ArgName
    x
        VarPart Range
    _ Ranged BoundVariablePosition
    i  -> Range -> Ranged BoundVariablePosition -> NotationPart
    VarPart Range
    r Ranged BoundVariablePosition
    i
        WildPart Ranged BoundVariablePosition
    i   -> Ranged BoundVariablePosition -> NotationPart
    WildPart Ranged BoundVariablePosition
    i
        HolePart Range
    _ NamedArg (Ranged Int)
    i -> Range -> NamedArg (Ranged Int) -> NotationPart
    HolePart Range
    r NamedArg (Ranged Int)
    i

    instance KillRange NotationPart where
      killRange :: NotationPart -> NotationPart
    killRange = \case
        IdPart Ranged ArgName
    x     -> Ranged ArgName -> NotationPart
    IdPart (Ranged ArgName -> NotationPart) -> Ranged ArgName -> NotationPart
    forall a b. (a -> b) -> a -> b
    $ KillRangeT (Ranged ArgName)
    forall a. KillRange a => KillRangeT a
    killRange Ranged ArgName
    x
        VarPart Range
    _ Ranged BoundVariablePosition
    i  -> Range -> Ranged BoundVariablePosition -> NotationPart
    VarPart Range
    forall a. Range' a
    noRange (Ranged BoundVariablePosition -> NotationPart)
    -> Ranged BoundVariablePosition -> NotationPart
    forall a b. (a -> b) -> a -> b
    $ KillRangeT (Ranged BoundVariablePosition)
    forall a. KillRange a => KillRangeT a
    killRange Ranged BoundVariablePosition
    i
        WildPart Ranged BoundVariablePosition
    i   -> Ranged BoundVariablePosition -> NotationPart
    WildPart (Ranged BoundVariablePosition -> NotationPart)
    -> Ranged BoundVariablePosition -> NotationPart
    forall a b. (a -> b) -> a -> b
    $ KillRangeT (Ranged BoundVariablePosition)
    forall a. KillRange a => KillRangeT a
    killRange Ranged BoundVariablePosition
    i
        HolePart Range
    _ NamedArg (Ranged Int)
    x -> Range -> NamedArg (Ranged Int) -> NotationPart
    HolePart Range
    forall a. Range' a
    noRange (NamedArg (Ranged Int) -> NotationPart)
    -> NamedArg (Ranged Int) -> NotationPart
    forall a b. (a -> b) -> a -> b
    $ KillRangeT (NamedArg (Ranged Int))
    forall a. KillRange a => KillRangeT a
    killRange NamedArg (Ranged Int)
    x

    instance NFData BoundVariablePosition where
      rnf :: BoundVariablePosition -> ()
    rnf = (BoundVariablePosition -> () -> ()
    forall a b. a -> b -> b
    `seq` ())

    instance NFData NotationPart where
      rnf :: NotationPart -> ()
    rnf (VarPart Range
    _ Ranged BoundVariablePosition
    a)  = Ranged BoundVariablePosition -> ()
    forall a. NFData a => a -> ()
    rnf Ranged BoundVariablePosition
    a
      rnf (HolePart Range
    _ NamedArg (Ranged Int)
    a) = NamedArg (Ranged Int) -> ()
    forall a. NFData a => a -> ()
    rnf NamedArg (Ranged Int)
    a
      rnf (WildPart Ranged BoundVariablePosition
    a)   = Ranged BoundVariablePosition -> ()
    forall a. NFData a => a -> ()
    rnf Ranged BoundVariablePosition
    a
      rnf (IdPart Ranged ArgName
    a)     = Ranged ArgName -> ()
    forall a. NFData a => a -> ()
    rnf Ranged ArgName
    a