{-# LANGUAGE FlexibleContexts, FlexibleInstances, MultiParamTypeClasses, OverloadedStrings,
             ScopedTypeVariables, StandaloneDeriving, TypeFamilies, TypeOperators, UndecidableInstances #-}

-- | Tracking which extensions are used by the AST
module Language.Haskell.Extensions.Verifier (Accounting(Accounting), Verification(Verification),
                                             Error(..), verify) where

import Control.Applicative (liftA2)
import Control.Monad.Trans.Accum (Accum, accum, evalAccum)
import qualified Data.Char as Char
import Data.Foldable (toList)
import Data.Functor.Const (Const(Const, getConst))
import Data.Functor.Compose (Compose(..))
import Data.Maybe (isJust)
import Data.Monoid (Any(Any, getAny), Sum(Sum), Ap(Ap, getAp))
import Data.Monoid.Textual (TextualMonoid, characterPrefix)
import qualified Data.Monoid.Textual as Textual
import Data.Semigroup.Cancellative (LeftReductive(isPrefixOf, stripPrefix))
import Data.Semigroup.Factorial (Factorial)
import Data.Semigroup.Union (UnionWith(UnionWith, getUnionWith))
import qualified Data.Semigroup.Factorial as Factorial
import Data.Map.Lazy (Map)
import Data.Set (Set)
import qualified Data.Map.Lazy as Map
import qualified Data.Set as Set
import Data.String (IsString)

import qualified Rank2
import qualified Transformation
import qualified Transformation.Deep as Deep
import qualified Transformation.Full as Full
import qualified Transformation.Shallow as Shallow
import qualified Transformation.AG.Dimorphic as AG.Di
import Text.Grampa (Ambiguous(..))

import qualified Language.Haskell.AST as AST
import qualified Language.Haskell.Binder as Binder
import Language.Haskell.Grammar (isSymbol)
import Language.Haskell.Extensions (Extension, ExtensionSwitch, partitionContradictory, withImplications)
import qualified Language.Haskell.Extensions as Extensions
import qualified Language.Haskell.Extensions.Abstract as Abstract
import qualified Language.Haskell.Extensions.AST as ExtAST
import qualified Language.Haskell.Reserializer as Reserializer
import Language.Haskell.Reserializer (Lexeme(..), ParsedLexemes(..), TokenType(..))

-- | Transformation for tracking the uses of language extensions.
data Accounting l pos s = Accounting

data MPTCAccounting l pos s = MPTCAccounting
data FlexibleInstanceHeadAccounting l pos s = FlexibleInstanceHeadAccounting
data FlexibleInstanceTypeAccounting l pos s = FlexibleInstanceTypeAccounting
data FlexibleInstanceTypeArgAccounting l pos s = FlexibleInstanceTypeArgAccounting
data UnicodeSyntaxAccounting l pos s = UnicodeSyntaxAccounting

-- | Transformation for reporting errors about language extension use
data Verification l pos s = Verification

type Accounted pos = Const (UnionWith (Map Extension) [(pos, pos)])
type Verified pos = Const (Ap (Accum (Map Extension Bool)) [Error pos])

-- | Extension misuse or disuse errors
data Error pos = ContradictoryExtensionSwitches (Set ExtensionSwitch)
               | UndeclaredExtensionUse Extension [(pos, pos)]
               | UnusedExtension Extension
               | RecordTypeDataFields [(pos, pos)]
               | StrictTypeDataFields [(pos, pos)]
                 deriving (Int -> Error pos -> ShowS
[Error pos] -> ShowS
Error pos -> String
(Int -> Error pos -> ShowS)
-> (Error pos -> String)
-> ([Error pos] -> ShowS)
-> Show (Error pos)
forall pos. Show pos => Int -> Error pos -> ShowS
forall pos. Show pos => [Error pos] -> ShowS
forall pos. Show pos => Error pos -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall pos. Show pos => Int -> Error pos -> ShowS
showsPrec :: Int -> Error pos -> ShowS
$cshow :: forall pos. Show pos => Error pos -> String
show :: Error pos -> String
$cshowList :: forall pos. Show pos => [Error pos] -> ShowS
showList :: [Error pos] -> ShowS
Show)

type Wrap l pos s = Binder.WithEnvironment l (Reserializer.Wrapped pos s)

instance Transformation.Transformation (Accounting l pos s) where
    type Domain (Accounting l pos s) = Wrap l pos s
    type Codomain (Accounting l pos s) = Accounted pos

instance Transformation.Transformation (MPTCAccounting l pos s) where
    type Domain (MPTCAccounting l pos s) = Wrap l pos s
    type Codomain (MPTCAccounting l pos s) = Const (Sum Int)

instance Transformation.Transformation (FlexibleInstanceHeadAccounting l pos s) where
    type Domain (FlexibleInstanceHeadAccounting l pos s) = Wrap l pos s
    type Codomain (FlexibleInstanceHeadAccounting l pos s) = Accounted pos

instance Transformation.Transformation (FlexibleInstanceTypeAccounting l pos s) where
    type Domain (FlexibleInstanceTypeAccounting l pos s) = Wrap l pos s
    type Codomain (FlexibleInstanceTypeAccounting l pos s) = Accounted pos

instance Transformation.Transformation (FlexibleInstanceTypeArgAccounting l pos s) where
    type Domain (FlexibleInstanceTypeArgAccounting l pos s) = Wrap l pos s
    type Codomain (FlexibleInstanceTypeArgAccounting l pos s) = Accounted pos

instance Transformation.Transformation (UnicodeSyntaxAccounting l pos s) where
    type Domain (UnicodeSyntaxAccounting l pos s) = Wrap l pos s
    type Codomain (UnicodeSyntaxAccounting l pos s) = Accounted pos

instance Transformation.Transformation (Verification l pos s) where
    type Domain (Verification l pos s) = Wrap l pos s
    type Codomain (Verification l pos s) = Verified pos

-- | Given the list of declared extensions, report errors on the use of undeclared extensions and non-use
-- of declared ones.
verify :: forall w l pos s g. (w ~ Wrap l pos s, Full.Foldable (Verification l pos s) g) =>
                Map Extension Bool
             -> w (g w w)
             -> [Error pos]
verify :: forall (w :: * -> *) l pos s (g :: (* -> *) -> (* -> *) -> *).
(w ~ Wrap l pos s, Foldable (Verification l pos s) g) =>
Map Extension Bool -> w (g w w) -> [Error pos]
verify Map Extension Bool
extensions w (g w w)
node = Accum (Map Extension Bool) [Error pos]
-> Map Extension Bool -> [Error pos]
forall w a. Monoid w => Accum w a -> w -> a
evalAccum (Ap (AccumT (Map Extension Bool) Identity) [Error pos]
-> Accum (Map Extension Bool) [Error pos]
forall {k} (f :: k -> *) (a :: k). Ap f a -> f a
getAp (Ap (AccumT (Map Extension Bool) Identity) [Error pos]
 -> Accum (Map Extension Bool) [Error pos])
-> Ap (AccumT (Map Extension Bool) Identity) [Error pos]
-> Accum (Map Extension Bool) [Error pos]
forall a b. (a -> b) -> a -> b
$ Verification l pos s
-> Domain
     (Verification l pos s)
     (g (Domain (Verification l pos s)) (Domain (Verification l pos s)))
-> Ap (AccumT (Map Extension Bool) Identity) [Error pos]
forall m.
(Codomain (Verification l pos s) ~ Const m, Monoid m) =>
Verification l pos s
-> Domain
     (Verification l pos s)
     (g (Domain (Verification l pos s)) (Domain (Verification l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMap (Verification l pos s
forall l pos s. Verification l pos s
Verification :: Verification l pos s) w (g w w)
Domain
  (Verification l pos s)
  (g (Domain (Verification l pos s)) (Domain (Verification l pos s)))
node) Map Extension Bool
extensions

verifyModuleExtensions :: forall l pos s. (TextualMonoid s, Num pos, Ord pos,
                                           Abstract.DeeplyFoldable (Accounting l pos s) l,
                                           Abstract.Haskell l, Abstract.Module l l ~ AST.Module l l,
                                           Ord (Abstract.ModuleName l), Ord (Abstract.Name l)) =>
                          Map Extension Bool
                       -> Wrap l pos s (AST.Module l l (Wrap l pos s) (Wrap l pos s))
                       -> ([Error pos], Map Extension Bool)
verifyModuleExtensions :: forall l pos s.
(TextualMonoid s, Num pos, Ord pos,
 DeeplyFoldable (Accounting l pos s) l, Haskell l,
 Module l l ~ Module l l, Ord (ModuleName l), Ord (Name l)) =>
Map Extension Bool
-> Wrap l pos s (Module l l (Wrap l pos s) (Wrap l pos s))
-> ([Error pos], Map Extension Bool)
verifyModuleExtensions Map Extension Bool
extensions (Compose (Attributes l
_, ((pos, ParsedLexemes s, pos)
_, (AST.ExtendedModule [ExtensionSwitch]
localExtensionSwitches Wrap l pos s (Module l l (Wrap l pos s) (Wrap l pos s))
m)))) =
   ((if Set ExtensionSwitch -> Bool
forall a. Set a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Set ExtensionSwitch
contradictions then [Error pos]
forall a. Monoid a => a
mempty else [Set ExtensionSwitch -> Error pos
forall pos. Set ExtensionSwitch -> Error pos
ContradictoryExtensionSwitches Set ExtensionSwitch
contradictions])
    [Error pos] -> [Error pos] -> [Error pos]
forall a. Semigroup a => a -> a -> a
<> (Extension -> Error pos
forall pos. Extension -> Error pos
UnusedExtension
        (Extension -> Error pos) -> [Extension] -> [Error pos]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Extension -> [Extension]
forall a. Set a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (Map Extension Bool -> Set Extension
forall k a. Map k a -> Set k
Map.keysSet ((Bool -> Bool) -> Map Extension Bool -> Map Extension Bool
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter Bool -> Bool
forall a. a -> a
id Map Extension Bool
localExtensions)
                    Set Extension -> Set Extension -> Set Extension
forall a. Ord a => Set a -> Set a -> Set a
Set.\\ Set Extension
usedExtensionsWithPremises Set Extension -> Set Extension -> Set Extension
forall a. Ord a => Set a -> Set a -> Set a
Set.\\ Set Extension
Extensions.languageVersions))
    [Error pos] -> [Error pos] -> [Error pos]
forall a. Semigroup a => a -> a -> a
<> ((Extension -> [(pos, pos)] -> Error pos)
-> (Extension, [(pos, pos)]) -> Error pos
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Extension -> [(pos, pos)] -> Error pos
forall pos. Extension -> [(pos, pos)] -> Error pos
UndeclaredExtensionUse ((Extension, [(pos, pos)]) -> Error pos)
-> [(Extension, [(pos, pos)])] -> [Error pos]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map Extension [(pos, pos)] -> [(Extension, [(pos, pos)])]
forall k a. Map k a -> [(k, a)]
Map.toList (Map Extension [(pos, pos)]
usedExtensions Map Extension [(pos, pos)]
-> Map Extension Bool -> Map Extension [(pos, pos)]
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.\\ Map Extension Bool
declaredExtensions)),
    Map Extension Bool
declaredExtensions)
   where usedExtensions :: Map Extension [(pos, pos)]
         usedExtensions :: Map Extension [(pos, pos)]
usedExtensions = Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall pos.
(Num pos, Ord pos) =>
Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
filterExtensions (Map Extension [(pos, pos)] -> Map Extension [(pos, pos)])
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ UnionWith (Map Extension) [(pos, pos)]
-> Map Extension [(pos, pos)]
forall (f :: * -> *) m. UnionWith f m -> f m
getUnionWith (UnionWith (Map Extension) [(pos, pos)]
 -> Map Extension [(pos, pos)])
-> UnionWith (Map Extension) [(pos, pos)]
-> Map Extension [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ Accounting l pos s
-> Domain
     (Accounting l pos s)
     (Module
        l l (Domain (Accounting l pos s)) (Domain (Accounting l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
forall m.
(Codomain (Accounting l pos s) ~ Const m, Monoid m) =>
Accounting l pos s
-> Domain
     (Accounting l pos s)
     (Module
        l l (Domain (Accounting l pos s)) (Domain (Accounting l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMap (Accounting l pos s
forall l pos s. Accounting l pos s
Accounting :: Accounting l pos s) Wrap l pos s (Module l l (Wrap l pos s) (Wrap l pos s))
Domain
  (Accounting l pos s)
  (Module
     l l (Domain (Accounting l pos s)) (Domain (Accounting l pos s)))
m
         declaredExtensions :: Map Extension Bool
declaredExtensions = (Bool -> Bool) -> Map Extension Bool -> Map Extension Bool
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter Bool -> Bool
forall a. a -> a
id (Map Extension Bool -> Map Extension Bool
withImplications (Map Extension Bool
localExtensions Map Extension Bool -> Map Extension Bool -> Map Extension Bool
forall a. Semigroup a => a -> a -> a
<> Map Extension Bool
extensions)
                                             Map Extension Bool -> Map Extension Bool -> Map Extension Bool
forall a. Semigroup a => a -> a -> a
<> (Extension -> Bool) -> Set Extension -> Map Extension Bool
forall k a. (k -> a) -> Set k -> Map k a
Map.fromSet (Bool -> Extension -> Bool
forall a b. a -> b -> a
const Bool
True) Set Extension
Extensions.includedByDefault)
         (Set ExtensionSwitch
contradictions, Map Extension Bool
localExtensions) = Set ExtensionSwitch -> (Set ExtensionSwitch, Map Extension Bool)
partitionContradictory ([ExtensionSwitch] -> Set ExtensionSwitch
forall a. Ord a => [a] -> Set a
Set.fromList [ExtensionSwitch]
localExtensionSwitches)
         usedExtensionsWithPremises :: Set Extension
usedExtensionsWithPremises = (Extension -> [(pos, pos)] -> Set Extension)
-> Map Extension [(pos, pos)] -> Set Extension
forall m k a. Monoid m => (k -> a -> m) -> Map k a -> m
Map.foldMapWithKey Extension -> [(pos, pos)] -> Set Extension
forall {p}. Extension -> p -> Set Extension
extensionAndPremises Map Extension [(pos, pos)]
usedExtensions
         extensionAndPremises :: Extension -> p -> Set Extension
extensionAndPremises Extension
x p
_ = Extension -> Set Extension
forall a. a -> Set a
Set.singleton Extension
x Set Extension -> Set Extension -> Set Extension
forall a. Semigroup a => a -> a -> a
<> Set Extension
-> Extension -> Map Extension (Set Extension) -> Set Extension
forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault Set Extension
forall a. Monoid a => a
mempty Extension
x Map Extension (Set Extension)
Extensions.inverseImplications
verifyModuleExtensions Map Extension Bool
extensions Compose
  ((,) (Attributes l))
  (Wrapped pos s)
  (Module l l (Wrap l pos s) (Wrap l pos s))
m =
   ((Extension -> [(pos, pos)] -> Error pos)
-> (Extension, [(pos, pos)]) -> Error pos
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Extension -> [(pos, pos)] -> Error pos
forall pos. Extension -> [(pos, pos)] -> Error pos
UndeclaredExtensionUse
    ((Extension, [(pos, pos)]) -> Error pos)
-> [(Extension, [(pos, pos)])] -> [Error pos]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map Extension [(pos, pos)] -> [(Extension, [(pos, pos)])]
forall k a. Map k a -> [(k, a)]
Map.toList (Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall pos.
(Num pos, Ord pos) =>
Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
filterExtensions (Map Extension [(pos, pos)] -> Map Extension [(pos, pos)])
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
                    UnionWith (Map Extension) [(pos, pos)]
-> Map Extension [(pos, pos)]
forall (f :: * -> *) m. UnionWith f m -> f m
getUnionWith (Accounting l pos s
-> Domain
     (Accounting l pos s)
     (Module
        l l (Domain (Accounting l pos s)) (Domain (Accounting l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
forall m.
(Codomain (Accounting l pos s) ~ Const m, Monoid m) =>
Accounting l pos s
-> Domain
     (Accounting l pos s)
     (Module
        l l (Domain (Accounting l pos s)) (Domain (Accounting l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMap (Accounting l pos s
forall l pos s. Accounting l pos s
Accounting :: Accounting l pos s) Compose
  ((,) (Attributes l))
  (Wrapped pos s)
  (Module l l (Wrap l pos s) (Wrap l pos s))
Domain
  (Accounting l pos s)
  (Module
     l l (Domain (Accounting l pos s)) (Domain (Accounting l pos s)))
m) Map Extension [(pos, pos)]
-> Map Extension Bool -> Map Extension [(pos, pos)]
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.\\ Map Extension Bool
declaredExtensions),
    Map Extension Bool
declaredExtensions)
   where declaredExtensions :: Map Extension Bool
declaredExtensions = (Bool -> Bool) -> Map Extension Bool -> Map Extension Bool
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter Bool -> Bool
forall a. a -> a
id (Map Extension Bool -> Map Extension Bool
withImplications Map Extension Bool
extensions
                                             Map Extension Bool -> Map Extension Bool -> Map Extension Bool
forall a. Semigroup a => a -> a -> a
<> (Extension -> Bool) -> Set Extension -> Map Extension Bool
forall k a. (k -> a) -> Set k -> Map k a
Map.fromSet (Bool -> Extension -> Bool
forall a b. a -> b -> a
const Bool
True) Set Extension
Extensions.includedByDefault)

filterExtensions :: (Num pos, Ord pos) => Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
filterExtensions :: forall pos.
(Num pos, Ord pos) =>
Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
filterExtensions = (Extension -> [(pos, pos)] -> Maybe [(pos, pos)])
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a b. (k -> a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybeWithKey Extension -> [(pos, pos)] -> Maybe [(pos, pos)]
forall {a} {a}.
(Ord a, Ord a, Num a, Num a) =>
Extension -> [(a, a)] -> Maybe [(a, a)]
filterPatternGuards
   where filterPatternGuards :: Extension -> [(a, a)] -> Maybe [(a, a)]
filterPatternGuards Extension
Extensions.PatternGuards [(a, a)]
ranges =
            case [(a, a)] -> [(a, a)]
forall {a} {a}.
(Ord a, Ord a, Num a, Num a) =>
[(a, a)] -> [(a, a)]
filterActive [(a, a)]
ranges
            of [] -> Maybe [(a, a)]
forall a. Maybe a
Nothing
               [(a, a)]
rest -> [(a, a)] -> Maybe [(a, a)]
forall a. a -> Maybe a
Just [(a, a)]
rest
         filterPatternGuards Extension
_ [(a, a)]
ranges = [(a, a)] -> Maybe [(a, a)]
forall a. a -> Maybe a
Just [(a, a)]
ranges
         filterActive :: [(a, a)] -> [(a, a)]
filterActive (outer :: (a, a)
outer@(a
start1, a
end1) : inner :: (a, a)
inner@(a
start2, a
end2) : [(a, a)]
rest)
            | a
start1 a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
0, a
end1 a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
0, a
start2 a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>= -a
start1, a
end2 a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
0, a
end2 a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<= a
end1  = (a, a)
inner (a, a) -> [(a, a)] -> [(a, a)]
forall a. a -> [a] -> [a]
: [(a, a)] -> [(a, a)]
filterActive ((a, a)
outer (a, a) -> [(a, a)] -> [(a, a)]
forall a. a -> [a] -> [a]
: [(a, a)]
rest)
            | a
start1 a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
0, a
end1 a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
0, a
start2 a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>= a
start1, a
end2 a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<= -a
end1 = [(a, a)] -> [(a, a)]
filterActive ((a, a)
outer (a, a) -> [(a, a)] -> [(a, a)]
forall a. a -> [a] -> [a]
: [(a, a)]
rest)
         filterActive ((a
start, a
end) : [(a, a)]
rest) = [(a, a)] -> [(a, a)]
filterActive [(a, a)]
rest
         filterActive [] = []

instance {-# overlappable #-} Accounting l pos s
         `Transformation.At` g (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain (Accounting l pos s) (g (Wrap l pos s) (Wrap l pos s))
-> Codomain (Accounting l pos s) (g (Wrap l pos s) (Wrap l pos s))
$ Domain (Accounting l pos s) (g (Wrap l pos s) (Wrap l pos s))
_ = Const
  (UnionWith (Map Extension) [(pos, pos)])
  (g (Wrap l pos s) (Wrap l pos s))
Codomain (Accounting l pos s) (g (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty

instance {-# overlappable #-}
         Verification l pos s
         `Transformation.At` g (Wrap l pos s) (Wrap l pos s) where
   Verification l pos s
Verification $ :: Verification l pos s
-> Domain (Verification l pos s) (g (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Verification l pos s) (g (Wrap l pos s) (Wrap l pos s))
$ Domain (Verification l pos s) (g (Wrap l pos s) (Wrap l pos s))
_ = Const
  (Ap (AccumT (Map Extension Bool) Identity) [Error pos])
  (g (Wrap l pos s) (Wrap l pos s))
Codomain (Verification l pos s) (g (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty

instance (TextualMonoid s, Num pos, Ord pos, Abstract.DeeplyFoldable (Accounting l pos s) l,
          Abstract.Haskell l, Abstract.Module l l ~ AST.Module l l,
          Abstract.DeeplyFoldable (Accounting l pos s) l,
          Ord (Abstract.ModuleName l), Ord (Abstract.Name l)) =>
         Verification l pos s
         `Transformation.At` AST.Module l l (Wrap l pos s) (Wrap l pos s) where
   Verification l pos s
Verification $ :: Verification l pos s
-> Domain
     (Verification l pos s) (Module l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Verification l pos s) (Module l l (Wrap l pos s) (Wrap l pos s))
$ Domain
  (Verification l pos s) (Module l l (Wrap l pos s) (Wrap l pos s))
m = Ap (AccumT (Map Extension Bool) Identity) [Error pos]
-> Const
     (Ap (AccumT (Map Extension Bool) Identity) [Error pos])
     (Module l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (Ap (AccumT (Map Extension Bool) Identity) [Error pos]
 -> Const
      (Ap (AccumT (Map Extension Bool) Identity) [Error pos])
      (Module l l (Wrap l pos s) (Wrap l pos s)))
-> Ap (AccumT (Map Extension Bool) Identity) [Error pos]
-> Const
     (Ap (AccumT (Map Extension Bool) Identity) [Error pos])
     (Module l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ AccumT (Map Extension Bool) Identity [Error pos]
-> Ap (AccumT (Map Extension Bool) Identity) [Error pos]
forall {k} (f :: k -> *) (a :: k). f a -> Ap f a
Ap (AccumT (Map Extension Bool) Identity [Error pos]
 -> Ap (AccumT (Map Extension Bool) Identity) [Error pos])
-> AccumT (Map Extension Bool) Identity [Error pos]
-> Ap (AccumT (Map Extension Bool) Identity) [Error pos]
forall a b. (a -> b) -> a -> b
$ (Map Extension Bool -> ([Error pos], Map Extension Bool))
-> AccumT (Map Extension Bool) Identity [Error pos]
forall (m :: * -> *) w a. Monad m => (w -> (a, w)) -> AccumT w m a
accum ((Map Extension Bool -> ([Error pos], Map Extension Bool))
 -> AccumT (Map Extension Bool) Identity [Error pos])
-> (Map Extension Bool -> ([Error pos], Map Extension Bool))
-> AccumT (Map Extension Bool) Identity [Error pos]
forall a b. (a -> b) -> a -> b
$ (Map Extension Bool
 -> Wrap l pos s (Module l l (Wrap l pos s) (Wrap l pos s))
 -> ([Error pos], Map Extension Bool))
-> Wrap l pos s (Module l l (Wrap l pos s) (Wrap l pos s))
-> Map Extension Bool
-> ([Error pos], Map Extension Bool)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Map Extension Bool
-> Wrap l pos s (Module l l (Wrap l pos s) (Wrap l pos s))
-> ([Error pos], Map Extension Bool)
forall l pos s.
(TextualMonoid s, Num pos, Ord pos,
 DeeplyFoldable (Accounting l pos s) l, Haskell l,
 Module l l ~ Module l l, Ord (ModuleName l), Ord (Name l)) =>
Map Extension Bool
-> Wrap l pos s (Module l l (Wrap l pos s) (Wrap l pos s))
-> ([Error pos], Map Extension Bool)
verifyModuleExtensions Wrap l pos s (Module l l (Wrap l pos s) (Wrap l pos s))
Domain
  (Verification l pos s) (Module l l (Wrap l pos s) (Wrap l pos s))
m

instance (Full.Foldable (Accounting l pos s) (Abstract.DataConstructor l l),
          Full.Foldable (Accounting l pos s) (Abstract.GADTConstructor l l)) =>
         Verification l pos s
         `Transformation.At` ExtAST.Declaration l l (Wrap l pos s) (Wrap l pos s) where
   Verification l pos s
Verification $ :: Verification l pos s
-> Domain
     (Verification l pos s)
     (Declaration l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Verification l pos s)
     (Declaration l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos, ParsedLexemes s, pos)
_, Declaration l l (Wrap l pos s) (Wrap l pos s)
d))
     | ExtAST.TypeDataDeclaration SupportFor 'TypeData l
_sup Wrap l pos s (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
_lhs Maybe (Wrap l pos s (Kind l l (Wrap l pos s) (Wrap l pos s)))
_kind [Wrap l pos s (DataConstructor l l (Wrap l pos s) (Wrap l pos s))]
constructors <- Declaration l l (Wrap l pos s) (Wrap l pos s)
d = [Wrap l pos s (DataConstructor l l (Wrap l pos s) (Wrap l pos s))]
-> Const
     (Ap (AccumT (Map Extension Bool) Identity) [Error pos])
     (Declaration l l (Wrap l pos s) (Wrap l pos s))
forall (w :: * -> *) (g :: (* -> *) -> (* -> *) -> *) x.
(w ~ Wrap l pos s, Foldable (Accounting l pos s) g) =>
[w (g w w)] -> Verified pos x
verifyTypeData [Wrap l pos s (DataConstructor l l (Wrap l pos s) (Wrap l pos s))]
constructors
     | ExtAST.TypeGADTDeclaration SupportFor 'GADTs l
_sup1 SupportFor 'TypeData l
_sup2 Wrap l pos s (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
_lhs Maybe (Wrap l pos s (Kind l l (Wrap l pos s) (Wrap l pos s)))
_kind [Wrap l pos s (GADTConstructor l l (Wrap l pos s) (Wrap l pos s))]
constructors <- Declaration l l (Wrap l pos s) (Wrap l pos s)
d = [Wrap l pos s (GADTConstructor l l (Wrap l pos s) (Wrap l pos s))]
-> Const
     (Ap (AccumT (Map Extension Bool) Identity) [Error pos])
     (Declaration l l (Wrap l pos s) (Wrap l pos s))
forall (w :: * -> *) (g :: (* -> *) -> (* -> *) -> *) x.
(w ~ Wrap l pos s, Foldable (Accounting l pos s) g) =>
[w (g w w)] -> Verified pos x
verifyTypeData [Wrap l pos s (GADTConstructor l l (Wrap l pos s) (Wrap l pos s))]
constructors
     | Bool
otherwise = Const
  (Ap (AccumT (Map Extension Bool) Identity) [Error pos])
  (Declaration l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (Verification l pos s)
  (Declaration l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty
     where verifyTypeData :: (w ~ Wrap l pos s, Full.Foldable (Accounting l pos s) g) => [w (g w w)] -> Verified pos x
           verifyTypeData :: forall (w :: * -> *) (g :: (* -> *) -> (* -> *) -> *) x.
(w ~ Wrap l pos s, Foldable (Accounting l pos s) g) =>
[w (g w w)] -> Verified pos x
verifyTypeData =
              Ap (AccumT (Map Extension Bool) Identity) [Error pos]
-> Const (Ap (AccumT (Map Extension Bool) Identity) [Error pos]) x
forall {k} a (b :: k). a -> Const a b
Const
              (Ap (AccumT (Map Extension Bool) Identity) [Error pos]
 -> Const (Ap (AccumT (Map Extension Bool) Identity) [Error pos]) x)
-> ([w (g w w)]
    -> Ap (AccumT (Map Extension Bool) Identity) [Error pos])
-> [w (g w w)]
-> Const (Ap (AccumT (Map Extension Bool) Identity) [Error pos]) x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Accum (Map Extension Bool) [Error pos]
-> Ap (AccumT (Map Extension Bool) Identity) [Error pos]
forall {k} (f :: k -> *) (a :: k). f a -> Ap f a
Ap
              (Accum (Map Extension Bool) [Error pos]
 -> Ap (AccumT (Map Extension Bool) Identity) [Error pos])
-> ([w (g w w)] -> Accum (Map Extension Bool) [Error pos])
-> [w (g w w)]
-> Ap (AccumT (Map Extension Bool) Identity) [Error pos]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map Extension Bool -> ([Error pos], Map Extension Bool))
-> Accum (Map Extension Bool) [Error pos]
forall (m :: * -> *) w a. Monad m => (w -> (a, w)) -> AccumT w m a
accum
              ((Map Extension Bool -> ([Error pos], Map Extension Bool))
 -> Accum (Map Extension Bool) [Error pos])
-> ([w (g w w)]
    -> Map Extension Bool -> ([Error pos], Map Extension Bool))
-> [w (g w w)]
-> Accum (Map Extension Bool) [Error pos]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,)
              ([Error pos]
 -> Map Extension Bool -> ([Error pos], Map Extension Bool))
-> ([w (g w w)] -> [Error pos])
-> [w (g w w)]
-> Map Extension Bool
-> ([Error pos], Map Extension Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Extension -> [(pos, pos)] -> [Error pos])
-> Map Extension [(pos, pos)] -> [Error pos]
forall m k a. Monoid m => (k -> a -> m) -> Map k a -> m
Map.foldMapWithKey (\Extension
k [(pos, pos)]
v-> case Extension
k of Extension
Extensions.BangDataFields -> [[(pos, pos)] -> Error pos
forall pos. [(pos, pos)] -> Error pos
StrictTypeDataFields [(pos, pos)]
v]
                                                     Extension
Extensions.TraditionalRecordSyntax -> [[(pos, pos)] -> Error pos
forall pos. [(pos, pos)] -> Error pos
RecordTypeDataFields [(pos, pos)]
v]
                                                     Extension
_ -> [])
              (Map Extension [(pos, pos)] -> [Error pos])
-> ([w (g w w)] -> Map Extension [(pos, pos)])
-> [w (g w w)]
-> [Error pos]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnionWith (Map Extension) [(pos, pos)]
-> Map Extension [(pos, pos)]
forall (f :: * -> *) m. UnionWith f m -> f m
getUnionWith
              (UnionWith (Map Extension) [(pos, pos)]
 -> Map Extension [(pos, pos)])
-> ([w (g w w)] -> UnionWith (Map Extension) [(pos, pos)])
-> [w (g w w)]
-> Map Extension [(pos, pos)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (w (g w w) -> UnionWith (Map Extension) [(pos, pos)])
-> [w (g w w)] -> UnionWith (Map Extension) [(pos, pos)]
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Accounting l pos s
-> Domain
     (Accounting l pos s)
     (g (Domain (Accounting l pos s)) (Domain (Accounting l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
forall m.
(Codomain (Accounting l pos s) ~ Const m, Monoid m) =>
Accounting l pos s
-> Domain
     (Accounting l pos s)
     (g (Domain (Accounting l pos s)) (Domain (Accounting l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMap Accounting l pos s
forall l pos s. Accounting l pos s
Accounting)

instance (TextualMonoid s, Abstract.Module l l ~ AST.Module l l, Ord (Abstract.ModuleName l), Ord (Abstract.Name l)) =>
         Accounting l pos s
         `Transformation.At` AST.Module l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s) (Module l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s) (Module l l (Wrap l pos s) (Wrap l pos s))
$ d :: Domain
  (Accounting l pos s) (Module l l (Wrap l pos s) (Wrap l pos s))
d@(Compose (Attributes l
_, ((pos, ParsedLexemes s, pos)
_, AST.AnonymousModule [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (Import l l (Wrap l pos s) (Wrap l pos s))]
_ [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (Declaration l l (Wrap l pos s) (Wrap l pos s))]
declarations)))
      | Just [(pos, pos)]
clashingFieldLocations <- [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (Declaration l l (Wrap l pos s) (Wrap l pos s))]
-> Maybe [(pos, pos)]
forall l pos s node.
(Ord (ModuleName l), Ord (Name l)) =>
[Wrap l pos s node] -> Maybe [(pos, pos)]
checkDuplicateRecordFields [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (Declaration l l (Wrap l pos s) (Wrap l pos s))]
declarations
      = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Module l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Module l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Module l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.DuplicateRecordFields [(pos, pos)]
clashingFieldLocations
   Accounting l pos s
Accounting $ d :: Domain
  (Accounting l pos s) (Module l l (Wrap l pos s) (Wrap l pos s))
d@(Compose (Attributes l
_, ((pos, ParsedLexemes s, pos)
_, AST.NamedModule ModuleName l
_ Maybe
  [Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (Export l l (Wrap l pos s) (Wrap l pos s))]
_ [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (Import l l (Wrap l pos s) (Wrap l pos s))]
_ [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (Declaration l l (Wrap l pos s) (Wrap l pos s))]
declarations)))
      | Just [(pos, pos)]
clashingFieldLocations <- [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (Declaration l l (Wrap l pos s) (Wrap l pos s))]
-> Maybe [(pos, pos)]
forall l pos s node.
(Ord (ModuleName l), Ord (Name l)) =>
[Wrap l pos s node] -> Maybe [(pos, pos)]
checkDuplicateRecordFields [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (Declaration l l (Wrap l pos s) (Wrap l pos s))]
declarations
      = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Module l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Module l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Module l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.DuplicateRecordFields [(pos, pos)]
clashingFieldLocations
   Accounting l pos s
Accounting $ Compose (Attributes l
_, ((pos, ParsedLexemes s, pos)
_, Module l l (Wrap l pos s) (Wrap l pos s)
m)) = Const
  (UnionWith (Map Extension) [(pos, pos)])
  (Module l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (Accounting l pos s) (Module l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty

instance (Eq s, IsString s, Show s) =>
         Accounting l pos s
         `Transformation.At` ExtAST.Import l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s) (Import l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s) (Import l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, Trailing [Lexeme s]
lexemes, pos
end), ExtAST.Import Bool
safe Bool
_qualified Maybe Text
package ModuleName l
name Maybe (ModuleName l)
alias Maybe
  (Wrap
     l pos s (ImportSpecification l l (Wrap l pos s) (Wrap l pos s)))
spec)) =
      UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Import l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Import l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Import l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
         (if Bool
safe then Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.SafeImports [(pos
start, pos
end)] else Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)
         Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<>
         (if Maybe Text -> Bool
forall a. Maybe a -> Bool
isJust Maybe Text
package then Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.PackageImports [(pos
start, pos
end)] else Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)
         Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<>
         (if [Lexeme s] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Lexeme s]
qualifiedAndAfter Bool -> Bool -> Bool
|| (Lexeme s -> Bool) -> [Lexeme s] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Lexeme s -> Bool
forall s. Lexeme s -> Bool
isAnyKeyword [Lexeme s]
beforeQualified then Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty
          else Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ImportQualifiedPost [(pos
start, pos
end)])
      where x :: ([Lexeme s], [Lexeme s])
x@([Lexeme s]
beforeQualified, [Lexeme s]
qualifiedAndAfter) = (Lexeme s -> Bool) -> [Lexeme s] -> ([Lexeme s], [Lexeme s])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (s -> Lexeme s -> Bool
forall s. (Eq s, IsString s) => s -> Lexeme s -> Bool
isKeyword s
"qualified") ((Lexeme s -> Bool) -> [Lexeme s] -> [Lexeme s]
forall a. (a -> Bool) -> [a] -> [a]
filter Lexeme s -> Bool
forall s. Lexeme s -> Bool
isAnyToken [Lexeme s]
lexemes)

instance (Eq s, IsString s) =>
         Accounting l pos s
         `Transformation.At` AST.ImportItem l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s) (ImportItem l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s) (ImportItem l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, Trailing [Lexeme s]
lexemes, pos
end), AST.ImportClassOrType{})) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (ImportItem l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (ImportItem l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (ImportItem l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      if (Lexeme s -> Bool) -> [Lexeme s] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (s -> Lexeme s -> Bool
forall s. (Eq s, IsString s) => s -> Lexeme s -> Bool
isKeyword s
"type") [Lexeme s]
lexemes then Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ExplicitNamespaces [(pos
start, pos
end)] else Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty
   Accounting l pos s
Accounting $ Domain
  (Accounting l pos s) (ImportItem l l (Wrap l pos s) (Wrap l pos s))
_ = Const
  (UnionWith (Map Extension) [(pos, pos)])
  (ImportItem l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (Accounting l pos s) (ImportItem l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty

instance (Eq s, IsString s) =>
         Accounting l pos s
         `Transformation.At` ExtAST.ImportItem l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s) (ImportItem l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s) (ImportItem l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, Trailing [Lexeme s]
lexemes, pos
end), ExtAST.ImportClassOrType{})) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (ImportItem l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (ImportItem l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (ImportItem l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      if (Lexeme s -> Bool) -> [Lexeme s] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (s -> Lexeme s -> Bool
forall s. (Eq s, IsString s) => s -> Lexeme s -> Bool
isKeyword s
"type") [Lexeme s]
lexemes then Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ExplicitNamespaces [(pos
start, pos
end)] else Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty
   Accounting l pos s
Accounting $ Domain
  (Accounting l pos s) (ImportItem l l (Wrap l pos s) (Wrap l pos s))
_ = Const
  (UnionWith (Map Extension) [(pos, pos)])
  (ImportItem l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (Accounting l pos s) (ImportItem l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty

instance (Abstract.Context l ~ ExtAST.Context l, Eq s, IsString s,
          Abstract.DeeplyFoldable (UnicodeSyntaxAccounting l pos s) l,
          Deep.Foldable (UnicodeSyntaxAccounting l pos s) (ExtAST.Declaration l l),
          FlexibleInstanceHeadAccounting l pos s
          `Transformation.At` Abstract.ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s),
          Full.Foldable (MPTCAccounting l pos s) (Abstract.TypeLHS l l)) =>
         Accounting l pos s
         `Transformation.At` ExtAST.Declaration l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s)
     (Declaration l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s)
     (Declaration l l (Wrap l pos s) (Wrap l pos s))
$ d :: Domain
  (Accounting l pos s)
  (Declaration l l (Wrap l pos s) (Wrap l pos s))
d@(Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), Declaration l l (Wrap l pos s) (Wrap l pos s)
dec))) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Declaration l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Declaration l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Declaration l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      case Declaration l l (Wrap l pos s) (Wrap l pos s)
dec
      of ExtAST.DataDeclaration Wrap l pos s (Context l l (Wrap l pos s) (Wrap l pos s))
context Wrap l pos s (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
_lhs Maybe (Wrap l pos s (Kind l l (Wrap l pos s) (Wrap l pos s)))
_kind [Wrap l pos s (DataConstructor l l (Wrap l pos s) (Wrap l pos s))]
constructors [Wrap l pos s (DerivingClause l l (Wrap l pos s) (Wrap l pos s))]
_derivings ->
            (if [Wrap l pos s (DataConstructor l l (Wrap l pos s) (Wrap l pos s))]
-> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Wrap l pos s (DataConstructor l l (Wrap l pos s) (Wrap l pos s))]
constructors
             then Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.EmptyDataDeclarations [(pos
start, pos
end)]
             else Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)
            Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<>
            (case ((pos, ParsedLexemes s, pos),
 Context l l (Wrap l pos s) (Wrap l pos s))
-> Context l l (Wrap l pos s) (Wrap l pos s)
forall a b. (a, b) -> b
snd (((pos, ParsedLexemes s, pos),
  Context l l (Wrap l pos s) (Wrap l pos s))
 -> Context l l (Wrap l pos s) (Wrap l pos s))
-> (Wrap l pos s (Context l l (Wrap l pos s) (Wrap l pos s))
    -> ((pos, ParsedLexemes s, pos),
        Context l l (Wrap l pos s) (Wrap l pos s)))
-> Wrap l pos s (Context l l (Wrap l pos s) (Wrap l pos s))
-> Context l l (Wrap l pos s) (Wrap l pos s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Attributes l,
 ((pos, ParsedLexemes s, pos),
  Context l l (Wrap l pos s) (Wrap l pos s)))
-> ((pos, ParsedLexemes s, pos),
    Context l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a, b) -> b
snd ((Attributes l,
  ((pos, ParsedLexemes s, pos),
   Context l l (Wrap l pos s) (Wrap l pos s)))
 -> ((pos, ParsedLexemes s, pos),
     Context l l (Wrap l pos s) (Wrap l pos s)))
-> (Compose
      ((,) (Attributes l))
      ((,) (pos, ParsedLexemes s, pos))
      (Context l l (Wrap l pos s) (Wrap l pos s))
    -> (Attributes l,
        ((pos, ParsedLexemes s, pos),
         Context l l (Wrap l pos s) (Wrap l pos s))))
-> Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (Context l l (Wrap l pos s) (Wrap l pos s))
-> ((pos, ParsedLexemes s, pos),
    Context l l (Wrap l pos s) (Wrap l pos s))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compose
  ((,) (Attributes l))
  ((,) (pos, ParsedLexemes s, pos))
  (Context l l (Wrap l pos s) (Wrap l pos s))
-> (Attributes l,
    ((pos, ParsedLexemes s, pos),
     Context l l (Wrap l pos s) (Wrap l pos s)))
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose (Wrap l pos s (Context l l (Wrap l pos s) (Wrap l pos s))
 -> Context l l (Wrap l pos s) (Wrap l pos s))
-> Wrap l pos s (Context l l (Wrap l pos s) (Wrap l pos s))
-> Context l l (Wrap l pos s) (Wrap l pos s)
forall a b. (a -> b) -> a -> b
$ Wrap l pos s (Context l l (Wrap l pos s) (Wrap l pos s))
context
             of Context l l (Wrap l pos s) (Wrap l pos s)
ExtAST.NoContext -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty
                Context l l (Wrap l pos s) (Wrap l pos s)
_ -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.DatatypeContexts [(pos
start, pos
end)])
         ExtAST.GADTDeclaration Wrap l pos s (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
context Maybe (Wrap l pos s (Kind l l (Wrap l pos s) (Wrap l pos s)))
_lhs [Wrap l pos s (GADTConstructor l l (Wrap l pos s) (Wrap l pos s))]
constructors [Wrap l pos s (DerivingClause l l (Wrap l pos s) (Wrap l pos s))]
_derivings ->
            Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.GADTSyntax [(pos
start, pos
end)]
         ExtAST.NamedDefaultDeclaration{} ->
            Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.NamedDefaults [(pos
start, pos
end)]
         ExtAST.TypeDataDeclaration SupportFor 'TypeData l
_sup Wrap l pos s (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
_lhs Maybe (Wrap l pos s (Kind l l (Wrap l pos s) (Wrap l pos s)))
_kind [Wrap l pos s (DataConstructor l l (Wrap l pos s) (Wrap l pos s))]
constructors ->
            (if [Wrap l pos s (DataConstructor l l (Wrap l pos s) (Wrap l pos s))]
-> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Wrap l pos s (DataConstructor l l (Wrap l pos s) (Wrap l pos s))]
constructors
             then Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.EmptyDataDeclarations [(pos
start, pos
end)]
             else Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)
            Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TypeData [(pos
start, pos
end)]
         ExtAST.TypeGADTDeclaration{} ->
            (Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.GADTSyntax [(pos
start, pos
end)]
                         Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TypeData [(pos
start, pos
end)])
         ExtAST.ImplicitParameterDeclaration{} ->
            Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ImplicitParameters [(pos
start, pos
end)]
         ExtAST.StandaloneDerivingDeclaration{} ->
            Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.StandaloneDeriving [(pos
start, pos
end)]
         ExtAST.ForeignExport CallingConvention l
convention Maybe Text
id Name l
name Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
ty ->
            Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ForeignFunctionInterface [(pos
start, pos
end)]
            Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> UnionWith (Map Extension) [(pos, pos)]
-> Map Extension [(pos, pos)]
forall (f :: * -> *) m. UnionWith f m -> f m
getUnionWith (Const
  (UnionWith (Map Extension) [(pos, pos)]) (CallingConvention l)
-> UnionWith (Map Extension) [(pos, pos)]
forall {k} a (b :: k). Const a b -> a
getConst (Const
   (UnionWith (Map Extension) [(pos, pos)]) (CallingConvention l)
 -> UnionWith (Map Extension) [(pos, pos)])
-> Const
     (UnionWith (Map Extension) [(pos, pos)]) (CallingConvention l)
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ Accounting l pos s
forall l pos s. Accounting l pos s
Accounting Accounting l pos s
-> Domain (Accounting l pos s) (CallingConvention l)
-> Codomain (Accounting l pos s) (CallingConvention l)
forall t x. At t x => t -> Domain t x -> Codomain t x
Transformation.$ (CallingConvention l
convention CallingConvention l
-> Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (Declaration l l (Wrap l pos s) (Wrap l pos s))
-> Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (CallingConvention l)
forall a b.
a
-> Compose ((,) (Attributes l)) ((,) (pos, ParsedLexemes s, pos)) b
-> Compose ((,) (Attributes l)) ((,) (pos, ParsedLexemes s, pos)) a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Compose
  ((,) (Attributes l))
  ((,) (pos, ParsedLexemes s, pos))
  (Declaration l l (Wrap l pos s) (Wrap l pos s))
Domain
  (Accounting l pos s)
  (Declaration l l (Wrap l pos s) (Wrap l pos s))
d))
         ExtAST.ForeignImport CallingConvention l
convention Maybe (CallSafety l)
safety Maybe Text
id Name l
name Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
ty ->
            Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ForeignFunctionInterface [(pos
start, pos
end)]
            Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> UnionWith (Map Extension) [(pos, pos)]
-> Map Extension [(pos, pos)]
forall (f :: * -> *) m. UnionWith f m -> f m
getUnionWith (Const
  (UnionWith (Map Extension) [(pos, pos)]) (CallingConvention l)
-> UnionWith (Map Extension) [(pos, pos)]
forall {k} a (b :: k). Const a b -> a
getConst (Accounting l pos s
forall l pos s. Accounting l pos s
Accounting Accounting l pos s
-> Domain (Accounting l pos s) (CallingConvention l)
-> Codomain (Accounting l pos s) (CallingConvention l)
forall t x. At t x => t -> Domain t x -> Codomain t x
Transformation.$ (CallingConvention l
convention CallingConvention l
-> Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (Declaration l l (Wrap l pos s) (Wrap l pos s))
-> Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (CallingConvention l)
forall a b.
a
-> Compose ((,) (Attributes l)) ((,) (pos, ParsedLexemes s, pos)) b
-> Compose ((,) (Attributes l)) ((,) (pos, ParsedLexemes s, pos)) a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Compose
  ((,) (Attributes l))
  ((,) (pos, ParsedLexemes s, pos))
  (Declaration l l (Wrap l pos s) (Wrap l pos s))
Domain
  (Accounting l pos s)
  (Declaration l l (Wrap l pos s) (Wrap l pos s))
d))
                             UnionWith (Map Extension) [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> Const (UnionWith (Map Extension) [(pos, pos)]) (CallSafety l)
-> UnionWith (Map Extension) [(pos, pos)]
forall {k} a (b :: k). Const a b -> a
getConst ((CallSafety l
 -> Const (UnionWith (Map Extension) [(pos, pos)]) (CallSafety l))
-> Maybe (CallSafety l)
-> Const (UnionWith (Map Extension) [(pos, pos)]) (CallSafety l)
forall m a. Monoid m => (a -> m) -> Maybe a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((Accounting l pos s
forall l pos s. Accounting l pos s
Accounting Accounting l pos s
-> Domain (Accounting l pos s) (CallSafety l)
-> Codomain (Accounting l pos s) (CallSafety l)
forall t x. At t x => t -> Domain t x -> Codomain t x
Transformation.$) (Domain (Accounting l pos s) (CallSafety l)
 -> Const (UnionWith (Map Extension) [(pos, pos)]) (CallSafety l))
-> (CallSafety l -> Domain (Accounting l pos s) (CallSafety l))
-> CallSafety l
-> Const (UnionWith (Map Extension) [(pos, pos)]) (CallSafety l)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CallSafety l
-> Domain
     (Accounting l pos s)
     (Declaration l l (Wrap l pos s) (Wrap l pos s))
-> Domain (Accounting l pos s) (CallSafety l)
forall a b.
a -> Domain (Accounting l pos s) b -> Domain (Accounting l pos s) a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Domain
  (Accounting l pos s)
  (Declaration l l (Wrap l pos s) (Wrap l pos s))
d)) Maybe (CallSafety l)
safety))
         ExtAST.ClassDeclaration Wrap l pos s (Context l l (Wrap l pos s) (Wrap l pos s))
_ Wrap l pos s (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
lhs [Wrap l pos s (Declaration l l (Wrap l pos s) (Wrap l pos s))]
_ -> case MPTCAccounting l pos s
-> Domain
     (MPTCAccounting l pos s)
     (TypeLHS
        l
        l
        (Domain (MPTCAccounting l pos s))
        (Domain (MPTCAccounting l pos s)))
-> Sum Int
forall m.
(Codomain (MPTCAccounting l pos s) ~ Const m, Monoid m) =>
MPTCAccounting l pos s
-> Domain
     (MPTCAccounting l pos s)
     (TypeLHS
        l
        l
        (Domain (MPTCAccounting l pos s))
        (Domain (MPTCAccounting l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMap MPTCAccounting l pos s
forall l pos s. MPTCAccounting l pos s
MPTCAccounting Wrap l pos s (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
Domain
  (MPTCAccounting l pos s)
  (TypeLHS
     l
     l
     (Domain (MPTCAccounting l pos s))
     (Domain (MPTCAccounting l pos s)))
lhs of
            Sum Int
1 -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty
            Sum Int
_ -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.MultiParamTypeClasses [(pos
start, pos
end)]
         ExtAST.FunDepClassDeclaration{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.FunctionalDependencies [(pos
start, pos
end)]
         ExtAST.InstanceDeclaration [TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)]
_vars Wrap l pos s (Context l l (Wrap l pos s) (Wrap l pos s))
_context Wrap l pos s (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
lhs [Wrap l pos s (Declaration l l (Wrap l pos s) (Wrap l pos s))]
_methods ->
            UnionWith (Map Extension) [(pos, pos)]
-> Map Extension [(pos, pos)]
forall (f :: * -> *) m. UnionWith f m -> f m
getUnionWith (Const
  (UnionWith (Map Extension) [(pos, pos)])
  (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
-> UnionWith (Map Extension) [(pos, pos)]
forall {k} a (b :: k). Const a b -> a
getConst (Const
   (UnionWith (Map Extension) [(pos, pos)])
   (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
 -> UnionWith (Map Extension) [(pos, pos)])
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ FlexibleInstanceHeadAccounting l pos s
forall l pos s. FlexibleInstanceHeadAccounting l pos s
FlexibleInstanceHeadAccounting FlexibleInstanceHeadAccounting l pos s
-> Domain
     (FlexibleInstanceHeadAccounting l pos s)
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (FlexibleInstanceHeadAccounting l pos s)
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
forall t x. At t x => t -> Domain t x -> Codomain t x
Transformation.$ Wrap l pos s (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
Domain
  (FlexibleInstanceHeadAccounting l pos s)
  (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
lhs)
         ExtAST.ExplicitTypeFixityDeclaration{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ExplicitNamespaces [(pos
start, pos
end)]
         ExtAST.ExplicitDataFixityDeclaration{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ExplicitNamespaces [(pos
start, pos
end)]
         Declaration l l (Wrap l pos s) (Wrap l pos s)
_ -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty
      Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> UnionWith (Map Extension) [(pos, pos)]
-> Map Extension [(pos, pos)]
forall (f :: * -> *) m. UnionWith f m -> f m
getUnionWith (UnicodeSyntaxAccounting l pos s
-> Domain
     (UnicodeSyntaxAccounting l pos s)
     (Declaration
        l
        l
        (Domain (UnicodeSyntaxAccounting l pos s))
        (Domain (UnicodeSyntaxAccounting l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
forall m.
(Codomain (UnicodeSyntaxAccounting l pos s) ~ Const m, Monoid m) =>
UnicodeSyntaxAccounting l pos s
-> Domain
     (UnicodeSyntaxAccounting l pos s)
     (Declaration
        l
        l
        (Domain (UnicodeSyntaxAccounting l pos s))
        (Domain (UnicodeSyntaxAccounting l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMap UnicodeSyntaxAccounting l pos s
forall l pos s. UnicodeSyntaxAccounting l pos s
UnicodeSyntaxAccounting Domain
  (UnicodeSyntaxAccounting l pos s)
  (Declaration
     l
     l
     (Domain (UnicodeSyntaxAccounting l pos s))
     (Domain (UnicodeSyntaxAccounting l pos s)))
Domain
  (Accounting l pos s)
  (Declaration l l (Wrap l pos s) (Wrap l pos s))
d)

instance Accounting l pos s
         `Transformation.At` ExtAST.DataConstructor l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s)
     (DataConstructor l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s)
     (DataConstructor l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), ExtAST.ExistentialConstructor{})) =
      UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (DataConstructor l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ExistentialQuantification [(pos
start, pos
end)])
   Accounting l pos s
Accounting $ Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), ExtAST.RecordConstructor{})) =
      UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (DataConstructor l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TraditionalRecordSyntax [(pos
start, pos
end)])
   Accounting l pos s
Accounting $ Domain
  (Accounting l pos s)
  (DataConstructor l l (Wrap l pos s) (Wrap l pos s))
_ = Const
  (UnionWith (Map Extension) [(pos, pos)])
  (DataConstructor l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (Accounting l pos s)
  (DataConstructor l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty

instance (Abstract.Context l ~ ExtAST.Context l, Abstract.Type l ~ ExtAST.Type l, Eq s, IsString s) =>
         Accounting l pos s `Transformation.At` ExtAST.Context l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s) (Context l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s) (Context l l (Wrap l pos s) (Wrap l pos s))
$ d :: Domain
  (Accounting l pos s) (Context l l (Wrap l pos s) (Wrap l pos s))
d@(Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), Context l l (Wrap l pos s) (Wrap l pos s)
con))) =
      case Context l l (Wrap l pos s) (Wrap l pos s)
con
      of Context l l (Wrap l pos s) (Wrap l pos s)
ExtAST.NoContext -> Const
  (UnionWith (Map Extension) [(pos, pos)])
  (Context l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (Accounting l pos s) (Context l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty
         ExtAST.Constraints{} -> Const
  (UnionWith (Map Extension) [(pos, pos)])
  (Context l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (Accounting l pos s) (Context l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty
         ExtAST.ClassConstraint QualifiedName l
className Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
t -> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Context l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ (Type l l (Wrap l pos s) (Wrap l pos s)
 -> Map Extension [(pos, pos)])
-> Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
-> Map Extension [(pos, pos)]
forall m a. Monoid m => (a -> m) -> Wrap l pos s a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Type l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
checkFlexibleContextHead Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
t)
         ExtAST.TypeConstraint Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
t ->
            UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Context l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Context l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Context l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith ((Type l l (Wrap l pos s) (Wrap l pos s)
 -> Map Extension [(pos, pos)])
-> Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
-> Map Extension [(pos, pos)]
forall m a. Monoid m => (a -> m) -> Wrap l pos s a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Type l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
checkFlexibleContext Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
t) UnionWith (Map Extension) [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith ((Type l l (Wrap l pos s) (Wrap l pos s)
 -> Map Extension [(pos, pos)])
-> Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
-> Map Extension [(pos, pos)]
forall m a. Monoid m => (a -> m) -> Wrap l pos s a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Type l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
checkMPTC Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
t)
         ExtAST.TypeEquality{} -> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Context l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Context l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Context l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.EqualityConstraints [(pos
start, pos
end)]
         ExtAST.ImplicitParameterConstraint{} ->
            UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Context l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Context l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Context l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ImplicitParameters [(pos
start, pos
end)]
      where checkFlexibleContextHead :: Type l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
checkFlexibleContextHead ExtAST.TypeVariable{} = Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty
            checkFlexibleContextHead (ExtAST.TypeApplication Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
left Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
right) = (Type l l (Wrap l pos s) (Wrap l pos s)
 -> Map Extension [(pos, pos)])
-> Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
-> Map Extension [(pos, pos)]
forall m a. Monoid m => (a -> m) -> Wrap l pos s a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Type l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
checkFlexibleContextHead Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
left
            checkFlexibleContextHead Type l l (Wrap l pos s) (Wrap l pos s)
_ = Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.FlexibleContexts [(pos
start, pos
end)]
            checkFlexibleContext :: Type l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
checkFlexibleContext (ExtAST.TypeApplication Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
left Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
right)
               | (Type l l (Wrap l pos s) (Wrap l pos s) -> Bool)
-> Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s)) -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Type l l (Wrap l pos s) (Wrap l pos s) -> Bool
forall {λ} {l} {d :: * -> *} {s :: * -> *}. Type λ l d s -> Bool
isConstructor Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
left = (Type l l (Wrap l pos s) (Wrap l pos s)
 -> Map Extension [(pos, pos)])
-> Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
-> Map Extension [(pos, pos)]
forall m a. Monoid m => (a -> m) -> Wrap l pos s a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Type l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
checkFlexibleContextHead Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
right
               | Bool
otherwise = Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TypeVariableConstraints [(pos
start, pos
end)]
                             Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> (Type l l (Wrap l pos s) (Wrap l pos s)
 -> Map Extension [(pos, pos)])
-> Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
-> Map Extension [(pos, pos)]
forall m a. Monoid m => (a -> m) -> Wrap l pos s a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Type l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
checkFlexibleContext Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
left
            checkFlexibleContext Type l l (Wrap l pos s) (Wrap l pos s)
_ = Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty
            checkMPTC :: Type l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
checkMPTC (ExtAST.TypeApplication Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
left Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
_) = (Type l l (Wrap l pos s) (Wrap l pos s)
 -> Map Extension [(pos, pos)])
-> Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
-> Map Extension [(pos, pos)]
forall m a. Monoid m => (a -> m) -> Wrap l pos s a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Type l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
checkMPTC1 Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
left
            checkMPTC c :: Type l l (Wrap l pos s) (Wrap l pos s)
c@ExtAST.InfixTypeApplication{} = Type l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
checkMPTC1 Type l l (Wrap l pos s) (Wrap l pos s)
c
            checkMPTC Type l l (Wrap l pos s) (Wrap l pos s)
_ = Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty
            checkMPTC1 :: Type l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
checkMPTC1 ExtAST.TypeApplication{} = Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.MultiParameterConstraints [(pos
start, pos
end)]
            checkMPTC1 ExtAST.InfixTypeApplication{} = Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.MultiParameterConstraints [(pos
start, pos
end)]
            checkMPTC1 Type l l (Wrap l pos s) (Wrap l pos s)
_ = Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty
            isConstructor :: Type λ l d s -> Bool
isConstructor ExtAST.ConstructorType{} = Bool
True
            isConstructor Type λ l d s
_ = Bool
False

instance (Abstract.Expression l ~ ExtAST.Expression l, Abstract.QualifiedName l ~ AST.QualifiedName l,
          Ord (Abstract.QualifiedName l), Eq s, IsString s, Num pos) =>
         Accounting l pos s
         `Transformation.At` ExtAST.Expression l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s) (Expression l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s) (Expression l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Atts
  (UnionWith (Map (QualifiedName l)) (Binding l))
  (LocalEnvironment l)
bindings, ((pos
start, ParsedLexemes s
_, pos
end), Expression l l (Wrap l pos s) (Wrap l pos s)
e)) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Expression l l (Wrap l pos s) (Wrap l pos s))
UnionWith (Map Extension) [(pos, pos)]
-> Codomain
     (Accounting l pos s) (Expression l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Codomain
      (Accounting l pos s)
      (Expression l l (Wrap l pos s) (Wrap l pos s)))
-> (([(pos, pos)] -> Map Extension [(pos, pos)])
    -> UnionWith (Map Extension) [(pos, pos)])
-> ([(pos, pos)] -> Map Extension [(pos, pos)])
-> Codomain
     (Accounting l pos s) (Expression l l (Wrap l pos s) (Wrap l pos s))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> (([(pos, pos)] -> Map Extension [(pos, pos)])
    -> Map Extension [(pos, pos)])
-> ([(pos, pos)] -> Map Extension [(pos, pos)])
-> UnionWith (Map Extension) [(pos, pos)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (([(pos, pos)] -> Map Extension [(pos, pos)])
-> [(pos, pos)] -> Map Extension [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ [(pos
start, pos
end)]) (([(pos, pos)] -> Map Extension [(pos, pos)])
 -> Codomain
      (Accounting l pos s)
      (Expression l l (Wrap l pos s) (Wrap l pos s)))
-> ([(pos, pos)] -> Map Extension [(pos, pos)])
-> Codomain
     (Accounting l pos s) (Expression l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$
      (case Expression l l (Wrap l pos s) (Wrap l pos s)
e
       of ExtAST.ApplyExpression Compose
  ((,)
     (Atts
        (UnionWith (Map (QualifiedName l)) (Binding l))
        (LocalEnvironment l)))
  ((,) (pos, ParsedLexemes s, pos))
  (Expression l l (Wrap l pos s) (Wrap l pos s))
_ (Compose (Atts
  (UnionWith (Map (QualifiedName l)) (Binding l))
  (LocalEnvironment l)
_, ((pos
_, Trailing (Lexeme s
lexeme1 : [Lexeme s]
_), pos
_), Expression l l (Wrap l pos s) (Wrap l pos s)
r)))
             | Expression l l (Wrap l pos s) (Wrap l pos s) -> Bool
forall {λ} {l} {d :: * -> *} {s :: * -> *}.
Expression λ l d s -> Bool
isBlock Expression l l (Wrap l pos s) (Wrap l pos s)
r Bool -> Bool -> Bool
&& Bool -> Bool
not (s -> Lexeme s -> Bool
forall s. (Eq s, IsString s) => s -> Lexeme s -> Bool
isToken s
"(" Lexeme s
lexeme1) -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.BlockArguments
          ExtAST.CaseExpression Compose
  ((,)
     (Atts
        (UnionWith (Map (QualifiedName l)) (Binding l))
        (LocalEnvironment l)))
  ((,) (pos, ParsedLexemes s, pos))
  (Expression l l (Wrap l pos s) (Wrap l pos s))
_ [] -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.EmptyCase
          ExtAST.LambdaCaseExpression{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.LambdaCase
          ExtAST.MultiWayIfExpression{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.MultiWayIf
          -- negative end of the range means not really PatternGuards follow
          ExtAST.DoExpression{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.PatternGuards ([(pos, pos)] -> Map Extension [(pos, pos)])
-> ([(pos, pos)] -> [(pos, pos)])
-> [(pos, pos)]
-> Map Extension [(pos, pos)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((pos -> pos
forall a. Num a => a -> a
negate (pos -> pos) -> (pos, pos) -> (pos, pos)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) ((pos, pos) -> (pos, pos)) -> [(pos, pos)] -> [(pos, pos)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>)
          ExtAST.MDoExpression{} ->
             \[(pos, pos)]
ranges-> [(Extension, [(pos, pos)])] -> Map Extension [(pos, pos)]
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Extension
Extensions.RecursiveDo, [(pos, pos)]
ranges),
                                     (Extension
Extensions.PatternGuards, (pos -> pos
forall a. Num a => a -> a
negate (pos -> pos) -> (pos, pos) -> (pos, pos)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) ((pos, pos) -> (pos, pos)) -> [(pos, pos)] -> [(pos, pos)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(pos, pos)]
ranges)]
          ExtAST.QualifiedDoExpression{} ->
             Ap ((->) [(pos, pos)]) (Map Extension [(pos, pos)])
-> [(pos, pos)] -> Map Extension [(pos, pos)]
forall {k} (f :: k -> *) (a :: k). Ap f a -> f a
getAp (Ap ((->) [(pos, pos)]) (Map Extension [(pos, pos)])
 -> [(pos, pos)] -> Map Extension [(pos, pos)])
-> Ap ((->) [(pos, pos)]) (Map Extension [(pos, pos)])
-> [(pos, pos)]
-> Map Extension [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ (([(pos, pos)] -> Map Extension [(pos, pos)])
 -> Ap ((->) [(pos, pos)]) (Map Extension [(pos, pos)]))
-> [[(pos, pos)] -> Map Extension [(pos, pos)]]
-> Ap ((->) [(pos, pos)]) (Map Extension [(pos, pos)])
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ([(pos, pos)] -> Map Extension [(pos, pos)])
-> Ap ((->) [(pos, pos)]) (Map Extension [(pos, pos)])
forall {k} (f :: k -> *) (a :: k). f a -> Ap f a
Ap [Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.QualifiedDo,
                                 Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.PatternGuards ([(pos, pos)] -> Map Extension [(pos, pos)])
-> ([(pos, pos)] -> [(pos, pos)])
-> [(pos, pos)]
-> Map Extension [(pos, pos)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((pos, pos) -> (pos, pos)) -> [(pos, pos)] -> [(pos, pos)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (pos -> pos
forall a. Num a => a -> a
negate (pos -> pos) -> (pos, pos) -> (pos, pos)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>)]
          ExtAST.MDoQualifiedExpression{} ->
             Ap ((->) [(pos, pos)]) (Map Extension [(pos, pos)])
-> [(pos, pos)] -> Map Extension [(pos, pos)]
forall {k} (f :: k -> *) (a :: k). Ap f a -> f a
getAp (Ap ((->) [(pos, pos)]) (Map Extension [(pos, pos)])
 -> [(pos, pos)] -> Map Extension [(pos, pos)])
-> Ap ((->) [(pos, pos)]) (Map Extension [(pos, pos)])
-> [(pos, pos)]
-> Map Extension [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ (([(pos, pos)] -> Map Extension [(pos, pos)])
 -> Ap ((->) [(pos, pos)]) (Map Extension [(pos, pos)]))
-> [[(pos, pos)] -> Map Extension [(pos, pos)]]
-> Ap ((->) [(pos, pos)]) (Map Extension [(pos, pos)])
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ([(pos, pos)] -> Map Extension [(pos, pos)])
-> Ap ((->) [(pos, pos)]) (Map Extension [(pos, pos)])
forall {k} (f :: k -> *) (a :: k). f a -> Ap f a
Ap [Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.QualifiedDo,
                                 Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.RecursiveDo,
                                 Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.PatternGuards ([(pos, pos)] -> Map Extension [(pos, pos)])
-> ([(pos, pos)] -> [(pos, pos)])
-> [(pos, pos)]
-> Map Extension [(pos, pos)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((pos, pos) -> (pos, pos)) -> [(pos, pos)] -> [(pos, pos)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (pos -> pos
forall a. Num a => a -> a
negate (pos -> pos) -> (pos, pos) -> (pos, pos)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>)]
          ExtAST.ImplicitParameterExpression{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ImplicitParameters
          ExtAST.ListComprehension{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.PatternGuards ([(pos, pos)] -> Map Extension [(pos, pos)])
-> ([(pos, pos)] -> [(pos, pos)])
-> [(pos, pos)]
-> Map Extension [(pos, pos)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((pos -> pos
forall a. Num a => a -> a
negate (pos -> pos) -> (pos, pos) -> (pos, pos)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) ((pos, pos) -> (pos, pos)) -> [(pos, pos)] -> [(pos, pos)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>)
          ExtAST.ParallelListComprehension{} ->
             \[(pos, pos)]
ranges-> [(Extension, [(pos, pos)])] -> Map Extension [(pos, pos)]
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Extension
Extensions.ParallelListComprehensions, [(pos, pos)]
ranges),
                                     (Extension
Extensions.PatternGuards, (pos -> pos
forall a. Num a => a -> a
negate (pos -> pos) -> (pos, pos) -> (pos, pos)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) ((pos, pos) -> (pos, pos)) -> [(pos, pos)] -> [(pos, pos)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(pos, pos)]
ranges)]
          ExtAST.TupleSectionExpression{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TupleSections
          ExtAST.OverloadedLabel{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.OverloadedLabels
          ExtAST.ReferenceExpression QualifiedName l
q
             | Just (Binder.ValueBinding ValueBinding l
Binder.RecordField) <- QualifiedName l
-> Map (QualifiedName l) (Binding l) -> Maybe (Binding l)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup QualifiedName l
QualifiedName l
q (UnionWith (Map (QualifiedName l)) (Binding l)
-> Map (QualifiedName l) (Binding l)
forall (f :: * -> *) m. UnionWith f m -> f m
getUnionWith (UnionWith (Map (QualifiedName l)) (Binding l)
 -> Map (QualifiedName l) (Binding l))
-> UnionWith (Map (QualifiedName l)) (Binding l)
-> Map (QualifiedName l) (Binding l)
forall a b. (a -> b) -> a -> b
$ Atts
  (UnionWith (Map (QualifiedName l)) (Binding l))
  (LocalEnvironment l)
-> UnionWith (Map (QualifiedName l)) (Binding l)
forall a b. Atts a b -> a
AG.Di.inh Atts
  (UnionWith (Map (QualifiedName l)) (Binding l))
  (LocalEnvironment l)
bindings)
               -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.FieldSelectors
          ExtAST.UnboxedSumExpression{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.UnboxedSums
          ExtAST.UnboxedTupleExpression{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.UnboxedTuples
          ExtAST.UnboxedTupleSectionExpression{} ->
             \[(pos, pos)]
ranges-> [(Extension, [(pos, pos)])] -> Map Extension [(pos, pos)]
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Extension
Extensions.TupleSections, [(pos, pos)]
ranges), (Extension
Extensions.UnboxedTuples, [(pos, pos)]
ranges)]
          ExtAST.WildcardRecordExpression{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.RecordWildCards
          ExtAST.ExplicitTypeExpression{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ExplicitNamespaces
          Expression l l (Wrap l pos s) (Wrap l pos s)
_ -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)
      where isBlock :: Expression λ l d s -> Bool
isBlock ExtAST.CaseExpression{} = Bool
True
            isBlock ExtAST.ConditionalExpression{} = Bool
True
            isBlock ExtAST.DoExpression{} = Bool
True
            isBlock ExtAST.LambdaExpression{} = Bool
True
            isBlock ExtAST.LetExpression{} = Bool
True
            isBlock Expression λ l d s
_ = Bool
False

instance (Abstract.Expression l ~ ExtAST.Expression l, Abstract.QualifiedName l ~ AST.QualifiedName l,
          Ord (Abstract.QualifiedName l), Eq s, IsString s, Num pos) =>
         Accounting l pos s
         `Transformation.At` ExtAST.EquationRHS l l (Wrap l pos s) (Wrap l pos s) where
   -- negative start of the range means real PatternGuards follow
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s)
     (EquationRHS l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s)
     (EquationRHS l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), EquationRHS l l (Wrap l pos s) (Wrap l pos s)
e)) =
      UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (EquationRHS l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (EquationRHS l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (EquationRHS l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.PatternGuards [(-pos
start, pos
end)]

instance Accounting l pos s
         `Transformation.At` ExtAST.Statement l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s) (Statement l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s) (Statement l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), Statement l l (Wrap l pos s) (Wrap l pos s)
e)) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Statement l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Statement l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Statement l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      (case Statement l l (Wrap l pos s) (Wrap l pos s)
e
       of ExtAST.BindStatement{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.PatternGuards [(pos
start, pos
end)]
          ExtAST.RecursiveStatement{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.RecursiveDo [(pos
start, pos
end)]
          Statement l l (Wrap l pos s) (Wrap l pos s)
_ -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)

instance (Eq s, IsString s, LeftReductive s, Factorial s) =>
         Accounting l pos s
         `Transformation.At` ExtAST.Value l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s) (Value l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s) (Value l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, Trailing [Lexeme s]
lexemes, pos
end), Value l l (Wrap l pos s) (Wrap l pos s)
literal)) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Value l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Value l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Value l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      (if (Lexeme s -> Bool) -> [Lexeme s] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ((s -> s -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf s
"0b" (s -> Bool) -> (s -> Bool) -> s -> Bool
forall (f :: * -> *). Applicative f => f Bool -> f Bool -> f Bool
||| s -> s -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf s
"0B") (s -> Bool) -> (Lexeme s -> s) -> Lexeme s -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lexeme s -> s
forall s. Lexeme s -> s
lexemeText) [Lexeme s]
lexemes
      then Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.BinaryLiterals [(pos
start, pos
end)]
       else Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)
      Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<>
      (case Value l l (Wrap l pos s) (Wrap l pos s)
-> Value l l (Wrap l pos s) (Wrap l pos s)
forall {λ} {l} {d :: * -> *} {s :: * -> *}.
Value λ l d s -> Value λ l d s
hashless Value l l (Wrap l pos s) (Wrap l pos s)
literal
       of ExtAST.FloatingLiteral{} | (Lexeme s -> Bool) -> [Lexeme s] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ((s -> s -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf s
"0x" (s -> Bool) -> (s -> Bool) -> s -> Bool
forall (f :: * -> *). Applicative f => f Bool -> f Bool -> f Bool
||| s -> s -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf s
"0X") (s -> Bool) -> (Lexeme s -> s) -> Lexeme s -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lexeme s -> s
forall s. Lexeme s -> s
lexemeText) [Lexeme s]
lexemes
             -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.HexFloatLiterals [(pos
start, pos
end)]
          Value l l (Wrap l pos s) (Wrap l pos s)
_ -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)
      Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<>
      ((case Value l l (Wrap l pos s) (Wrap l pos s)
-> Value l l (Wrap l pos s) (Wrap l pos s)
forall {λ} {l} {d :: * -> *} {s :: * -> *}.
Value λ l d s -> Value λ l d s
hashless Value l l (Wrap l pos s) (Wrap l pos s)
literal
        of ExtAST.FloatingLiteral{} -> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. a -> a
id
           ExtAST.IntegerLiteral{} -> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. a -> a
id
           Value l l (Wrap l pos s) (Wrap l pos s)
_ -> Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a b. a -> b -> a
const Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)
       (Map Extension [(pos, pos)] -> Map Extension [(pos, pos)])
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
       (if (Lexeme s -> Bool) -> [Lexeme s] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Any -> Bool
getAny (Any -> Bool) -> (Lexeme s -> Any) -> Lexeme s -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (s -> Any) -> s -> Any
forall n. Monoid n => (s -> n) -> s -> n
forall m n. (Factorial m, Monoid n) => (m -> n) -> m -> n
Factorial.foldMap (Bool -> Any
Any (Bool -> Any) -> (s -> Bool) -> s -> Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (s
"_" s -> s -> Bool
forall a. Eq a => a -> a -> Bool
==)) (s -> Any) -> (Lexeme s -> s) -> Lexeme s -> Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lexeme s -> s
forall s. Lexeme s -> s
lexemeText) [Lexeme s]
lexemes
        then Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.NumericUnderscores [(pos
start, pos
end)]
        else Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)
       Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<>
       (if (Lexeme s -> Bool) -> [Lexeme s] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ((s
"-" s -> s -> Bool
forall m. LeftReductive m => m -> m -> Bool
`isPrefixOf`) (s -> Bool) -> (Lexeme s -> s) -> Lexeme s -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lexeme s -> s
forall s. Lexeme s -> s
lexemeText) [Lexeme s]
lexemes
        then Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.NegativeLiterals [(pos
start, pos
end)]
        else Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)
      )
      Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<>
      (case Value l l (Wrap l pos s) (Wrap l pos s)
literal
       of ExtAST.HashLiteral{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.MagicHash [(pos
start, pos
end)]
          ExtAST.ExtendedLiteral{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ExtendedLiterals [(pos
start, pos
end)]
          Value l l (Wrap l pos s) (Wrap l pos s)
_ -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)
      where hashless :: Value λ l d s -> Value λ l d s
hashless (ExtAST.HashLiteral SupportFor 'MagicHash λ
_ Value λ l d s
l) = Value λ l d s -> Value λ l d s
hashless Value λ l d s
l
            hashless Value λ l d s
l = Value λ l d s
l

instance (Eq s, IsString s, LeftReductive s, Factorial s) =>
         Accounting l pos s
         `Transformation.At` ExtAST.ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s)
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s)
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, Trailing [Lexeme s]
lexemes, pos
end), ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s)
t)) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      case ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s)
t
      of ExtAST.InfixTypeClassInstanceLHS{} -> Map Extension [(pos, pos)]
typeOperators
         ExtAST.TypeClassInstanceLHS{} | (Lexeme s -> Bool) -> [Lexeme s] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Lexeme s -> Bool
forall s. Lexeme s -> Bool
isAnyDelimiter [Lexeme s]
lexemes -> Map Extension [(pos, pos)]
typeOperators
         ExtAST.ClassReferenceInstanceLHS{} | (Lexeme s -> Bool) -> [Lexeme s] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Lexeme s -> Bool
forall s. Lexeme s -> Bool
isAnyDelimiter [Lexeme s]
lexemes -> Map Extension [(pos, pos)]
typeOperators
         ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s)
_ -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty
         where typeOperators :: Map Extension [(pos, pos)]
typeOperators = Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TypeOperators [(pos
start, pos
end)]

instance (Eq s, IsString s, LeftReductive s, TextualMonoid s) =>
         Accounting l pos s
         `Transformation.At` ExtAST.TypeLHS l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s) (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s) (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, Trailing [Lexeme s]
lexemes, pos
end), TypeLHS l l (Wrap l pos s) (Wrap l pos s)
t)) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (TypeLHS l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      case TypeLHS l l (Wrap l pos s) (Wrap l pos s)
t
      of ExtAST.SimpleTypeLHS Name l
op [TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)]
vars
            -> (if (Lexeme s -> Bool) -> [Lexeme s] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ((Char -> Bool) -> s -> Bool
forall t. TextualMonoid t => (Char -> Bool) -> t -> Bool
Textual.any Char -> Bool
isSymbol (s -> Bool) -> (Lexeme s -> s) -> Lexeme s -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lexeme s -> s
forall s. Lexeme s -> s
lexemeText) [Lexeme s]
lexemes
                then Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TypeOperators [(pos
start, pos
end)]
                else Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)
               Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> (TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)
 -> Map Extension [(pos, pos)])
-> [TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)]
-> Map Extension [(pos, pos)]
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((pos, pos)
-> TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
forall pos λ l (d :: * -> *) (s :: * -> *).
(pos, pos) -> TypeVarBinding λ l d s -> Map Extension [(pos, pos)]
checkKindedTypevar (pos
start, pos
end)) [TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)]
vars
         ExtAST.TypeLHSApplication Wrap l pos s (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
_ TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)
var -> (pos, pos)
-> TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
forall pos λ l (d :: * -> *) (s :: * -> *).
(pos, pos) -> TypeVarBinding λ l d s -> Map Extension [(pos, pos)]
checkKindedTypevar (pos
start, pos
end) TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)
var
         ExtAST.TypeLHSTypeApplication SupportFor 'TypeAbstractions l
_sup Wrap l pos s (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
_ TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)
var ->
            Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TypeOperators [(pos
start, pos
end)]
            Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> (pos, pos)
-> TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
forall pos λ l (d :: * -> *) (s :: * -> *).
(pos, pos) -> TypeVarBinding λ l d s -> Map Extension [(pos, pos)]
checkKindedTypevar (pos
start, pos
end) TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)
var

instance (Eq s, IsString s, LeftReductive s, Factorial s) =>
         Accounting l pos s
         `Transformation.At` ExtAST.FieldBinding l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s)
     (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s)
     (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), FieldBinding l l (Wrap l pos s) (Wrap l pos s)
t)) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (FieldBinding l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TraditionalRecordSyntax [(pos
start, pos
end)]
      Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> case FieldBinding l l (Wrap l pos s) (Wrap l pos s)
t of ExtAST.PunnedFieldBinding {} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.NamedFieldPuns [(pos
start, pos
end)]
                   FieldBinding l l (Wrap l pos s) (Wrap l pos s)
_ -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty

instance (Eq s, IsString s, LeftReductive s, Factorial s) =>
         Accounting l pos s
         `Transformation.At` ExtAST.FieldPattern l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s)
     (FieldPattern l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s)
     (FieldPattern l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), FieldPattern l l (Wrap l pos s) (Wrap l pos s)
t)) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (FieldPattern l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (FieldPattern l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (FieldPattern l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TraditionalRecordSyntax [(pos
start, pos
end)]
      Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> case FieldPattern l l (Wrap l pos s) (Wrap l pos s)
t of ExtAST.PunnedFieldPattern {} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.NamedFieldPuns [(pos
start, pos
end)]
                   FieldPattern l l (Wrap l pos s) (Wrap l pos s)
_ -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty

instance (Eq s, IsString s, LeftReductive s, Factorial s) =>
         Accounting l pos s
         `Transformation.At` ExtAST.Pattern l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s) (Pattern l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s) (Pattern l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), Pattern l l (Wrap l pos s) (Wrap l pos s)
t)) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Pattern l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Pattern l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Pattern l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      case Pattern l l (Wrap l pos s) (Wrap l pos s)
t of ExtAST.BangPattern {} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.BangPatterns [(pos
start, pos
end)]
                ExtAST.NPlusKPattern {} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.NPlusKPatterns [(pos
start, pos
end)]
                ExtAST.ViewPattern {} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ViewPatterns [(pos
start, pos
end)]
                ExtAST.UnboxedSumPattern{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.UnboxedSums [(pos
start, pos
end)]
                ExtAST.UnboxedTuplePattern{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.UnboxedTuples [(pos
start, pos
end)]
                ExtAST.InvisibleTypePattern {} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TypeAbstractions [(pos
start, pos
end)]
                ExtAST.ExplicitTypePattern{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ExplicitNamespaces [(pos
start, pos
end)]
                ExtAST.WildcardRecordPattern {} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.RecordWildCards [(pos
start, pos
end)]
                Pattern l l (Wrap l pos s) (Wrap l pos s)
_ -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty

instance (Eq s, IsString s, LeftReductive s, Factorial s) =>
         Accounting l pos s
         `Transformation.At` ExtAST.Type l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s) (Type l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s) (Type l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), Type l l (Wrap l pos s) (Wrap l pos s)
t)) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Type l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Type l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Type l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      case Type l l (Wrap l pos s) (Wrap l pos s)
t
      of ExtAST.InfixTypeApplication{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TypeOperators [(pos
start, pos
end)]
         ExtAST.PromotedInfixTypeApplication{} -> [(Extension, [(pos, pos)])] -> Map Extension [(pos, pos)]
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Extension
Extensions.DataKinds, [(pos
start, pos
end)]),
                                                                (Extension
Extensions.TypeOperators, [(pos
start, pos
end)])]
         ExtAST.PromotedConstructorType{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.DataKinds [(pos
start, pos
end)]
         ExtAST.PromotedTupleType{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.DataKinds [(pos
start, pos
end)]
         ExtAST.PromotedListType{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.DataKinds [(pos
start, pos
end)]
         ExtAST.PromotedIntegerLiteral{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.DataKinds [(pos
start, pos
end)]
         ExtAST.PromotedCharLiteral{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.DataKinds [(pos
start, pos
end)]
         ExtAST.PromotedStringLiteral{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.DataKinds [(pos
start, pos
end)]
         ExtAST.RecordFunctionType{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.TraditionalRecordSyntax [(pos
start, pos
end)]
         ExtAST.ForallType [TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)]
vars Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
_ ->
            Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.ExplicitForAll [(pos
start, pos
end)] Map Extension [(pos, pos)]
-> Map Extension [(pos, pos)] -> Map Extension [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> (TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)
 -> Map Extension [(pos, pos)])
-> [TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)]
-> Map Extension [(pos, pos)]
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((pos, pos)
-> TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)
-> Map Extension [(pos, pos)]
forall pos λ l (d :: * -> *) (s :: * -> *).
(pos, pos) -> TypeVarBinding λ l d s -> Map Extension [(pos, pos)]
checkKindedTypevar (pos
start, pos
end)) [TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)]
vars
         ExtAST.KindedType{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.KindSignatures [(pos
start, pos
end)]
         ExtAST.GroundTypeKind{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.StarIsType [(pos
start, pos
end)]
         ExtAST.StrictType{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.BangDataFields [(pos
start, pos
end)]
         ExtAST.TypeWildcard{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.PartialTypeSignatures [(pos
start, pos
end)]
         ExtAST.UnboxedSumType{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.UnboxedSums [(pos
start, pos
end)]
         ExtAST.UnboxedTupleType{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.UnboxedTuples [(pos
start, pos
end)]
         ExtAST.VisibleDependentType{} -> [(Extension, [(pos, pos)])] -> Map Extension [(pos, pos)]
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Extension
Extensions.ExplicitForAll, [(pos
start, pos
end)]),
                                                        (Extension
Extensions.PolyKinds, [(pos
start, pos
end)])]
         Type l l (Wrap l pos s) (Wrap l pos s)
_ -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty

instance (Eq s, IsString s, LeftReductive s, Factorial s) =>
         Accounting l pos s
         `Transformation.At` ExtAST.Constructor l l (Wrap l pos s) (Wrap l pos s) where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain
     (Accounting l pos s)
     (Constructor l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (Accounting l pos s)
     (Constructor l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), Constructor l l (Wrap l pos s) (Wrap l pos s)
t)) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Constructor l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Constructor l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Constructor l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      case Constructor l l (Wrap l pos s) (Wrap l pos s)
t
      of ExtAST.UnboxedTupleConstructor{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.UnboxedTuples [(pos
start, pos
end)]
         ExtAST.UnboxedSumConstructor{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.UnboxedSums [(pos
start, pos
end)]
         Constructor l l (Wrap l pos s) (Wrap l pos s)
_ -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty

instance Accounting l pos s `Transformation.At` ExtAST.CallingConvention l where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain (Accounting l pos s) (CallingConvention l)
-> Codomain (Accounting l pos s) (CallingConvention l)
$ Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), CallingConvention l
e)) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)]) (CallingConvention l)
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)]) (CallingConvention l))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)]) (CallingConvention l)
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      (case CallingConvention l
e
       of ExtAST.CApiCall{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.CApiFFI [(pos
start, pos
end)]
          CallingConvention l
_ -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)

instance Accounting l pos s `Transformation.At` ExtAST.CallSafety l where
   Accounting l pos s
Accounting $ :: Accounting l pos s
-> Domain (Accounting l pos s) (CallSafety l)
-> Codomain (Accounting l pos s) (CallSafety l)
$ Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), CallSafety l
e)) = UnionWith (Map Extension) [(pos, pos)]
-> Const (UnionWith (Map Extension) [(pos, pos)]) (CallSafety l)
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const (UnionWith (Map Extension) [(pos, pos)]) (CallSafety l))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const (UnionWith (Map Extension) [(pos, pos)]) (CallSafety l)
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$
      (case CallSafety l
e
       of ExtAST.InterruptibleCall{} -> Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.InterruptibleFFI [(pos
start, pos
end)]
          CallSafety l
_ -> Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty)

checkKindedTypevar :: (pos, pos) -> ExtAST.TypeVarBinding λ l d s -> Map Extension [(pos, pos)]
checkKindedTypevar :: forall pos λ l (d :: * -> *) (s :: * -> *).
(pos, pos) -> TypeVarBinding λ l d s -> Map Extension [(pos, pos)]
checkKindedTypevar (pos, pos)
span ExtAST.ExplicitlyKindedTypeVariable{} = Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.KindSignatures [(pos, pos)
span]
checkKindedTypevar (pos, pos)
_ ExtAST.ImplicitlyKindedTypeVariable{} = Map Extension [(pos, pos)]
forall a. Monoid a => a
mempty

(|||) :: Applicative f => f Bool -> f Bool -> f Bool
||| :: forall (f :: * -> *). Applicative f => f Bool -> f Bool -> f Bool
(|||) = (Bool -> Bool -> Bool) -> f Bool -> f Bool -> f Bool
forall a b c. (a -> b -> c) -> f a -> f b -> f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 Bool -> Bool -> Bool
(||)

instance {-# OVERLAPS #-} MPTCAccounting l pos s
                          `Transformation.At` ExtAST.TypeLHS l l (Wrap l pos s) (Wrap l pos s) where
   MPTCAccounting l pos s
MPTCAccounting $ :: MPTCAccounting l pos s
-> Domain
     (MPTCAccounting l pos s)
     (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (MPTCAccounting l pos s)
     (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos, ParsedLexemes s, pos)
_, TypeLHS l l (Wrap l pos s) (Wrap l pos s)
node)) = Sum Int
-> Const (Sum Int) (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (Sum Int
 -> Const (Sum Int) (TypeLHS l l (Wrap l pos s) (Wrap l pos s)))
-> Sum Int
-> Const (Sum Int) (TypeLHS l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Int -> Sum Int
forall a. a -> Sum a
Sum (Int -> Sum Int) -> Int -> Sum Int
forall a b. (a -> b) -> a -> b
$ case TypeLHS l l (Wrap l pos s) (Wrap l pos s)
node of
      ExtAST.SimpleTypeLHS Name l
_ [TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)]
args -> [TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [TypeVarBinding l l (Wrap l pos s) (Wrap l pos s)]
args
      ExtAST.TypeLHSApplication{} -> Int
1
      ExtAST.TypeLHSTypeApplication{} -> Int
0

instance MPTCAccounting l pos s `Transformation.At` g l l (Wrap l pos s) (Wrap l pos s) where
  MPTCAccounting l pos s
MPTCAccounting $ :: MPTCAccounting l pos s
-> Domain
     (MPTCAccounting l pos s) (g l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (MPTCAccounting l pos s) (g l l (Wrap l pos s) (Wrap l pos s))
$ Domain
  (MPTCAccounting l pos s) (g l l (Wrap l pos s) (Wrap l pos s))
_ = Const (Sum Int) (g l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (MPTCAccounting l pos s) (g l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty

instance {-# OVERLAPS #-}
   (Abstract.UniversallyApplicable (FlexibleInstanceHeadAccounting l pos s) l (Wrap l pos s),
    Abstract.UniversallyApplicable (FlexibleInstanceTypeAccounting l pos s) l (Wrap l pos s))
   => FlexibleInstanceHeadAccounting l pos s
      `Transformation.At` ExtAST.ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s) where
   FlexibleInstanceHeadAccounting l pos s
FlexibleInstanceHeadAccounting $ :: FlexibleInstanceHeadAccounting l pos s
-> Domain
     (FlexibleInstanceHeadAccounting l pos s)
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (FlexibleInstanceHeadAccounting l pos s)
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos, ParsedLexemes s, pos)
_, ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s)
node)) = case ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s)
node of
      ExtAST.ClassInstanceLHSKindApplication Wrap l pos s (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
inst Wrap l pos s (Kind l l (Wrap l pos s) (Wrap l pos s))
_kind ->
         UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Const
  (UnionWith (Map Extension) [(pos, pos)])
  (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
-> UnionWith (Map Extension) [(pos, pos)]
forall {k} a (b :: k). Const a b -> a
getConst (Const
   (UnionWith (Map Extension) [(pos, pos)])
   (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
 -> UnionWith (Map Extension) [(pos, pos)])
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ FlexibleInstanceHeadAccounting l pos s
forall l pos s. FlexibleInstanceHeadAccounting l pos s
FlexibleInstanceHeadAccounting FlexibleInstanceHeadAccounting l pos s
-> Domain
     (FlexibleInstanceHeadAccounting l pos s)
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (FlexibleInstanceHeadAccounting l pos s)
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
forall t x. At t x => t -> Domain t x -> Codomain t x
Transformation.$ Wrap l pos s (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
Domain
  (FlexibleInstanceHeadAccounting l pos s)
  (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
inst
      ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s)
inst -> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (FlexibleInstanceHeadAccounting l pos s
-> ClassInstanceLHS
     l
     l
     (Wrap l pos s)
     (Domain (FlexibleInstanceHeadAccounting l pos s))
-> UnionWith (Map Extension) [(pos, pos)]
forall m.
(Codomain (FlexibleInstanceHeadAccounting l pos s) ~ Const m,
 Monoid m) =>
FlexibleInstanceHeadAccounting l pos s
-> ClassInstanceLHS
     l
     l
     (Wrap l pos s)
     (Domain (FlexibleInstanceHeadAccounting l pos s))
-> m
forall t (g :: (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> g (Domain t) -> m
Shallow.foldMap FlexibleInstanceHeadAccounting l pos s
forall l pos s. FlexibleInstanceHeadAccounting l pos s
FlexibleInstanceHeadAccounting ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s)
ClassInstanceLHS
  l
  l
  (Wrap l pos s)
  (Domain (FlexibleInstanceHeadAccounting l pos s))
inst
                     UnionWith (Map Extension) [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a. Semigroup a => a -> a -> a
<> FlexibleInstanceTypeAccounting l pos s
-> ClassInstanceLHS
     l
     l
     (Wrap l pos s)
     (Domain (FlexibleInstanceTypeAccounting l pos s))
-> UnionWith (Map Extension) [(pos, pos)]
forall m.
(Codomain (FlexibleInstanceTypeAccounting l pos s) ~ Const m,
 Monoid m) =>
FlexibleInstanceTypeAccounting l pos s
-> ClassInstanceLHS
     l
     l
     (Wrap l pos s)
     (Domain (FlexibleInstanceTypeAccounting l pos s))
-> m
forall t (g :: (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> g (Domain t) -> m
Shallow.foldMap FlexibleInstanceTypeAccounting l pos s
forall l pos s. FlexibleInstanceTypeAccounting l pos s
FlexibleInstanceTypeAccounting ClassInstanceLHS l l (Wrap l pos s) (Wrap l pos s)
ClassInstanceLHS
  l
  l
  (Wrap l pos s)
  (Domain (FlexibleInstanceTypeAccounting l pos s))
inst)

instance FlexibleInstanceHeadAccounting l pos s `Transformation.At` g l l (Wrap l pos s) (Wrap l pos s) where
  FlexibleInstanceHeadAccounting l pos s
FlexibleInstanceHeadAccounting $ :: FlexibleInstanceHeadAccounting l pos s
-> Domain
     (FlexibleInstanceHeadAccounting l pos s)
     (g l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (FlexibleInstanceHeadAccounting l pos s)
     (g l l (Wrap l pos s) (Wrap l pos s))
$ Domain
  (FlexibleInstanceHeadAccounting l pos s)
  (g l l (Wrap l pos s) (Wrap l pos s))
_ = Const
  (UnionWith (Map Extension) [(pos, pos)])
  (g l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (FlexibleInstanceHeadAccounting l pos s)
  (g l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty

instance {-# OVERLAPS #-}
   Abstract.UniversallyApplicable (FlexibleInstanceTypeArgAccounting l pos s) l (Wrap l pos s)
   => FlexibleInstanceTypeAccounting l pos s `Transformation.At` ExtAST.Type l l (Wrap l pos s) (Wrap l pos s) where
   FlexibleInstanceTypeAccounting l pos s
FlexibleInstanceTypeAccounting $ :: FlexibleInstanceTypeAccounting l pos s
-> Domain
     (FlexibleInstanceTypeAccounting l pos s)
     (Type l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (FlexibleInstanceTypeAccounting l pos s)
     (Type l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos, ParsedLexemes s, pos)
_, Type l l (Wrap l pos s) (Wrap l pos s)
node)) = UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Type l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Type l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Type l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ FlexibleInstanceTypeArgAccounting l pos s
-> Type
     l
     l
     (Wrap l pos s)
     (Domain (FlexibleInstanceTypeArgAccounting l pos s))
-> UnionWith (Map Extension) [(pos, pos)]
forall m.
(Codomain (FlexibleInstanceTypeArgAccounting l pos s) ~ Const m,
 Monoid m) =>
FlexibleInstanceTypeArgAccounting l pos s
-> Type
     l
     l
     (Wrap l pos s)
     (Domain (FlexibleInstanceTypeArgAccounting l pos s))
-> m
forall t (g :: (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> g (Domain t) -> m
Shallow.foldMap FlexibleInstanceTypeArgAccounting l pos s
forall l pos s. FlexibleInstanceTypeArgAccounting l pos s
FlexibleInstanceTypeArgAccounting Type l l (Wrap l pos s) (Wrap l pos s)
Type
  l
  l
  (Wrap l pos s)
  (Domain (FlexibleInstanceTypeArgAccounting l pos s))
node

instance FlexibleInstanceTypeAccounting l pos s `Transformation.At` g l l (Wrap l pos s) (Wrap l pos s) where
  FlexibleInstanceTypeAccounting l pos s
FlexibleInstanceTypeAccounting $ :: FlexibleInstanceTypeAccounting l pos s
-> Domain
     (FlexibleInstanceTypeAccounting l pos s)
     (g l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (FlexibleInstanceTypeAccounting l pos s)
     (g l l (Wrap l pos s) (Wrap l pos s))
$ Domain
  (FlexibleInstanceTypeAccounting l pos s)
  (g l l (Wrap l pos s) (Wrap l pos s))
_ = Const
  (UnionWith (Map Extension) [(pos, pos)])
  (g l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (FlexibleInstanceTypeAccounting l pos s)
  (g l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty

instance {-# OVERLAPS #-}
   FlexibleInstanceTypeArgAccounting l pos s `Transformation.At` Abstract.Type l l (Wrap l pos s) (Wrap l pos s)
   => FlexibleInstanceTypeArgAccounting l pos s `Transformation.At` ExtAST.Type l l (Wrap l pos s) (Wrap l pos s) where
   FlexibleInstanceTypeArgAccounting l pos s
FlexibleInstanceTypeArgAccounting $ :: FlexibleInstanceTypeArgAccounting l pos s
-> Domain
     (FlexibleInstanceTypeArgAccounting l pos s)
     (Type l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (FlexibleInstanceTypeArgAccounting l pos s)
     (Type l l (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, ParsedLexemes s
_, pos
end), Type l l (Wrap l pos s) (Wrap l pos s)
node)) = case Type l l (Wrap l pos s) (Wrap l pos s)
node of
      ExtAST.TypeVariable{} -> Const
  (UnionWith (Map Extension) [(pos, pos)])
  (Type l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (FlexibleInstanceTypeArgAccounting l pos s)
  (Type l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty
      Type l l (Wrap l pos s) (Wrap l pos s)
ExtAST.TypeWildcard -> Const
  (UnionWith (Map Extension) [(pos, pos)])
  (Type l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (FlexibleInstanceTypeArgAccounting l pos s)
  (Type l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty
      ExtAST.KindedType Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
t Wrap l pos s (Kind l l (Wrap l pos s) (Wrap l pos s))
k -> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Type l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Type l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Type l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Const
  (UnionWith (Map Extension) [(pos, pos)])
  (Type l l (Wrap l pos s) (Wrap l pos s))
-> UnionWith (Map Extension) [(pos, pos)]
forall {k} a (b :: k). Const a b -> a
getConst (Const
   (UnionWith (Map Extension) [(pos, pos)])
   (Type l l (Wrap l pos s) (Wrap l pos s))
 -> UnionWith (Map Extension) [(pos, pos)])
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Type l l (Wrap l pos s) (Wrap l pos s))
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ FlexibleInstanceTypeArgAccounting l pos s
forall l pos s. FlexibleInstanceTypeArgAccounting l pos s
FlexibleInstanceTypeArgAccounting FlexibleInstanceTypeArgAccounting l pos s
-> Domain
     (FlexibleInstanceTypeArgAccounting l pos s)
     (Type l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (FlexibleInstanceTypeArgAccounting l pos s)
     (Type l l (Wrap l pos s) (Wrap l pos s))
forall t x. At t x => t -> Domain t x -> Codomain t x
Transformation.$ Wrap l pos s (Type l l (Wrap l pos s) (Wrap l pos s))
Domain
  (FlexibleInstanceTypeArgAccounting l pos s)
  (Type l l (Wrap l pos s) (Wrap l pos s))
t
      Type l l (Wrap l pos s) (Wrap l pos s)
_ -> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Type l l (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (UnionWith (Map Extension) [(pos, pos)]
 -> Const
      (UnionWith (Map Extension) [(pos, pos)])
      (Type l l (Wrap l pos s) (Wrap l pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (Type l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a -> b) -> a -> b
$ Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.FlexibleInstances [(pos
start, pos
end)]

instance FlexibleInstanceTypeArgAccounting l pos s `Transformation.At` g l l (Wrap l pos s) (Wrap l pos s) where
  FlexibleInstanceTypeArgAccounting l pos s
FlexibleInstanceTypeArgAccounting $ :: FlexibleInstanceTypeArgAccounting l pos s
-> Domain
     (FlexibleInstanceTypeArgAccounting l pos s)
     (g l l (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (FlexibleInstanceTypeArgAccounting l pos s)
     (g l l (Wrap l pos s) (Wrap l pos s))
$ Domain
  (FlexibleInstanceTypeArgAccounting l pos s)
  (g l l (Wrap l pos s) (Wrap l pos s))
_ = Const
  (UnionWith (Map Extension) [(pos, pos)])
  (g l l (Wrap l pos s) (Wrap l pos s))
Codomain
  (FlexibleInstanceTypeArgAccounting l pos s)
  (g l l (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty

instance (Eq s, IsString s) =>
         UnicodeSyntaxAccounting l pos s
         `Transformation.At` g (Wrap l pos s) (Wrap l pos s) where
   UnicodeSyntaxAccounting l pos s
UnicodeSyntaxAccounting $ :: UnicodeSyntaxAccounting l pos s
-> Domain
     (UnicodeSyntaxAccounting l pos s) (g (Wrap l pos s) (Wrap l pos s))
-> Codomain
     (UnicodeSyntaxAccounting l pos s) (g (Wrap l pos s) (Wrap l pos s))
$ Compose (Attributes l
_, ((pos
start, Trailing [Lexeme s]
lexemes, pos
end), g (Wrap l pos s) (Wrap l pos s)
_))
      | (Lexeme s -> Bool) -> [Lexeme s] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Lexeme s -> [Lexeme s] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Lexeme s]
unicodeDelimiters) [Lexeme s]
lexemes =
        UnionWith (Map Extension) [(pos, pos)]
-> Const
     (UnionWith (Map Extension) [(pos, pos)])
     (g (Wrap l pos s) (Wrap l pos s))
forall {k} a (b :: k). a -> Const a b
Const (Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall (f :: * -> *) m. f m -> UnionWith f m
UnionWith (Map Extension [(pos, pos)]
 -> UnionWith (Map Extension) [(pos, pos)])
-> Map Extension [(pos, pos)]
-> UnionWith (Map Extension) [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ Extension -> [(pos, pos)] -> Map Extension [(pos, pos)]
forall k a. k -> a -> Map k a
Map.singleton Extension
Extensions.UnicodeSyntax [(pos
start, pos
end)])
      | Bool
otherwise = Const
  (UnionWith (Map Extension) [(pos, pos)])
  (g (Wrap l pos s) (Wrap l pos s))
Codomain
  (UnicodeSyntaxAccounting l pos s) (g (Wrap l pos s) (Wrap l pos s))
forall a. Monoid a => a
mempty
      where unicodeDelimiters :: [Lexeme s]
            unicodeDelimiters :: [Lexeme s]
unicodeDelimiters = TokenType -> s -> Lexeme s
forall s. TokenType -> s -> Lexeme s
Token TokenType
Delimiter (s -> Lexeme s) -> [s] -> [Lexeme s]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [s
"∷", s
"⇒", s
"→", s
"←"]

instance (Rank2.Foldable (g (Wrap l pos s)), Deep.Foldable (Verification l pos s) g,
          Transformation.At (Verification l pos s) (g (Wrap l pos s) (Wrap l pos s))) =>
         Full.Foldable (Verification l pos s) g where
   foldMap :: forall m.
(Codomain (Verification l pos s) ~ Const m, Monoid m) =>
Verification l pos s
-> Domain
     (Verification l pos s)
     (g (Domain (Verification l pos s)) (Domain (Verification l pos s)))
-> m
foldMap = Verification l pos s
-> Domain
     (Verification l pos s)
     (g (Domain (Verification l pos s)) (Domain (Verification l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(At t (g (Domain t) (Domain t)), Foldable t g,
 Codomain t ~ Const m, Foldable (Domain t), Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMapDownDefault

instance (Rank2.Foldable (g (Wrap l pos s)), Deep.Foldable (Accounting l pos s) g,
          Transformation.At (Accounting l pos s) (g (Wrap l pos s) (Wrap l pos s))) =>
         Full.Foldable (Accounting l pos s) g where
   foldMap :: forall m.
(Codomain (Accounting l pos s) ~ Const m, Monoid m) =>
Accounting l pos s
-> Domain
     (Accounting l pos s)
     (g (Domain (Accounting l pos s)) (Domain (Accounting l pos s)))
-> m
foldMap = Accounting l pos s
-> Domain
     (Accounting l pos s)
     (g (Domain (Accounting l pos s)) (Domain (Accounting l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(At t (g (Domain t) (Domain t)), Foldable t g,
 Codomain t ~ Const m, Foldable (Domain t), Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMapDownDefault

instance (Rank2.Foldable (g (Wrap l pos s)), Deep.Foldable (MPTCAccounting l pos s) g,
          Transformation.At (MPTCAccounting l pos s)
                            (g (Wrap l pos s) (Wrap l pos s))) =>
         Full.Foldable (MPTCAccounting l pos s) g where
   foldMap :: forall m.
(Codomain (MPTCAccounting l pos s) ~ Const m, Monoid m) =>
MPTCAccounting l pos s
-> Domain
     (MPTCAccounting l pos s)
     (g (Domain (MPTCAccounting l pos s))
        (Domain (MPTCAccounting l pos s)))
-> m
foldMap = MPTCAccounting l pos s
-> Domain
     (MPTCAccounting l pos s)
     (g (Domain (MPTCAccounting l pos s))
        (Domain (MPTCAccounting l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(At t (g (Domain t) (Domain t)), Foldable t g,
 Codomain t ~ Const m, Foldable (Domain t), Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMapDownDefault

instance (Rank2.Foldable (g (Wrap l pos s)), Deep.Foldable (FlexibleInstanceHeadAccounting l pos s) g,
          Transformation.At (FlexibleInstanceHeadAccounting l pos s)
                            (g (Wrap l pos s) (Wrap l pos s))) =>
         Full.Foldable (FlexibleInstanceHeadAccounting l pos s) g where
   foldMap :: forall m.
(Codomain (FlexibleInstanceHeadAccounting l pos s) ~ Const m,
 Monoid m) =>
FlexibleInstanceHeadAccounting l pos s
-> Domain
     (FlexibleInstanceHeadAccounting l pos s)
     (g (Domain (FlexibleInstanceHeadAccounting l pos s))
        (Domain (FlexibleInstanceHeadAccounting l pos s)))
-> m
foldMap = FlexibleInstanceHeadAccounting l pos s
-> Domain
     (FlexibleInstanceHeadAccounting l pos s)
     (g (Domain (FlexibleInstanceHeadAccounting l pos s))
        (Domain (FlexibleInstanceHeadAccounting l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(At t (g (Domain t) (Domain t)), Foldable t g,
 Codomain t ~ Const m, Foldable (Domain t), Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMapDownDefault

instance (Rank2.Foldable (g (Wrap l pos s)), Deep.Foldable (FlexibleInstanceTypeAccounting l pos s) g,
          Transformation.At (FlexibleInstanceTypeAccounting l pos s)
                            (g (Wrap l pos s) (Wrap l pos s))) =>
         Full.Foldable (FlexibleInstanceTypeAccounting l pos s) g where
   foldMap :: forall m.
(Codomain (FlexibleInstanceTypeAccounting l pos s) ~ Const m,
 Monoid m) =>
FlexibleInstanceTypeAccounting l pos s
-> Domain
     (FlexibleInstanceTypeAccounting l pos s)
     (g (Domain (FlexibleInstanceTypeAccounting l pos s))
        (Domain (FlexibleInstanceTypeAccounting l pos s)))
-> m
foldMap = FlexibleInstanceTypeAccounting l pos s
-> Domain
     (FlexibleInstanceTypeAccounting l pos s)
     (g (Domain (FlexibleInstanceTypeAccounting l pos s))
        (Domain (FlexibleInstanceTypeAccounting l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(At t (g (Domain t) (Domain t)), Foldable t g,
 Codomain t ~ Const m, Foldable (Domain t), Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMapDownDefault

instance (Rank2.Foldable (g (Wrap l pos s)), Deep.Foldable (FlexibleInstanceTypeArgAccounting l pos s) g,
          Transformation.At (FlexibleInstanceTypeArgAccounting l pos s)
                            (g (Wrap l pos s) (Wrap l pos s))) =>
         Full.Foldable (FlexibleInstanceTypeArgAccounting l pos s) g where
   foldMap :: forall m.
(Codomain (FlexibleInstanceTypeArgAccounting l pos s) ~ Const m,
 Monoid m) =>
FlexibleInstanceTypeArgAccounting l pos s
-> Domain
     (FlexibleInstanceTypeArgAccounting l pos s)
     (g (Domain (FlexibleInstanceTypeArgAccounting l pos s))
        (Domain (FlexibleInstanceTypeArgAccounting l pos s)))
-> m
foldMap = FlexibleInstanceTypeArgAccounting l pos s
-> Domain
     (FlexibleInstanceTypeArgAccounting l pos s)
     (g (Domain (FlexibleInstanceTypeArgAccounting l pos s))
        (Domain (FlexibleInstanceTypeArgAccounting l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(At t (g (Domain t) (Domain t)), Foldable t g,
 Codomain t ~ Const m, Foldable (Domain t), Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMapDownDefault

instance (Rank2.Foldable (g (Wrap l pos s)), Deep.Foldable (UnicodeSyntaxAccounting l pos s) g,
          Transformation.At (UnicodeSyntaxAccounting l pos s)
                            (g (Wrap l pos s) (Wrap l pos s))) =>
         Full.Foldable (UnicodeSyntaxAccounting l pos s) g where
   foldMap :: forall m.
(Codomain (UnicodeSyntaxAccounting l pos s) ~ Const m, Monoid m) =>
UnicodeSyntaxAccounting l pos s
-> Domain
     (UnicodeSyntaxAccounting l pos s)
     (g (Domain (UnicodeSyntaxAccounting l pos s))
        (Domain (UnicodeSyntaxAccounting l pos s)))
-> m
foldMap = UnicodeSyntaxAccounting l pos s
-> Domain
     (UnicodeSyntaxAccounting l pos s)
     (g (Domain (UnicodeSyntaxAccounting l pos s))
        (Domain (UnicodeSyntaxAccounting l pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(At t (g (Domain t) (Domain t)), Foldable t g,
 Codomain t ~ Const m, Foldable (Domain t), Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMapDownDefault

checkDuplicateRecordFields :: forall l pos s node. (Ord (Abstract.ModuleName l), Ord (Abstract.Name l))
                           => [Wrap l pos s node] -> Maybe [(pos, pos)]
checkDuplicateRecordFields :: forall l pos s node.
(Ord (ModuleName l), Ord (Name l)) =>
[Wrap l pos s node] -> Maybe [(pos, pos)]
checkDuplicateRecordFields [Wrap l pos s node]
declarations
  | Map (Name l) (Binding l) -> Bool
forall k a. Map k a -> Bool
Map.null Map (Name l) (Binding l)
duplicateBindings = Maybe [(pos, pos)]
forall a. Maybe a
Nothing
  | Bool
otherwise = [(pos, pos)] -> Maybe [(pos, pos)]
forall a. a -> Maybe a
Just ((Wrap l pos s node -> (pos, pos))
-> [Wrap l pos s node] -> [(pos, pos)]
forall a b. (a -> b) -> [a] -> [b]
map Wrap l pos s node -> (pos, pos)
forall {a} {a} {b} {b} {a}.
Compose ((,) a) ((,) (a, b, b)) a -> (a, b)
location ([Wrap l pos s node] -> [(pos, pos)])
-> [Wrap l pos s node] -> [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ (Wrap l pos s node -> Bool)
-> [Wrap l pos s node] -> [Wrap l pos s node]
forall a. (a -> Bool) -> [a] -> [a]
filter Wrap l pos s node -> Bool
isDuplicate [Wrap l pos s node]
declarations)
  where duplicateBindings :: Map (Name l) (Binding l)
duplicateBindings = (Binding l -> Bool)
-> Map (Name l) (Binding l) -> Map (Name l) (Binding l)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter Binding l -> Bool
forall {l}. Binding l -> Bool
duplicateRecordField Map (Name l) (Binding l)
allDeclarationBindings
        UnionWith Map (Name l) (Binding l)
allDeclarationBindings = (Wrap l pos s node -> LocalEnvironment l)
-> [Wrap l pos s node] -> LocalEnvironment l
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Wrap l pos s node -> LocalEnvironment l
forall {a} {b} {g :: * -> *} {a}. Compose ((,) (Atts a b)) g a -> b
declarationBindings [Wrap l pos s node]
declarations
        declarationBindings :: Compose ((,) (Atts a b)) g a -> b
declarationBindings (Compose (Atts a b
bindings, g a
_)) = Atts a b -> b
forall a b. Atts a b -> b
AG.Di.syn Atts a b
bindings
        duplicateRecordField :: Binding l -> Bool
duplicateRecordField Binding l
b = Binding l
b Binding l -> Binding l -> Bool
forall a. Eq a => a -> a -> Bool
== BindingError l -> Binding l
forall l. BindingError l -> Binding l
Binder.ErroneousBinding BindingError l
forall l. BindingError l
Binder.DuplicateRecordField
        isDuplicate :: Wrap l pos s node -> Bool
        isDuplicate :: Wrap l pos s node -> Bool
isDuplicate = Bool -> Bool
not (Bool -> Bool)
-> (Wrap l pos s node -> Bool) -> Wrap l pos s node -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map (Name l) (Binding l) -> Map (Name l) (Binding l) -> Bool
forall k a b. Ord k => Map k a -> Map k b -> Bool
Map.disjoint Map (Name l) (Binding l)
duplicateBindings (Map (Name l) (Binding l) -> Bool)
-> (Wrap l pos s node -> Map (Name l) (Binding l))
-> Wrap l pos s node
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalEnvironment l -> Map (Name l) (Binding l)
forall (f :: * -> *) m. UnionWith f m -> f m
getUnionWith (LocalEnvironment l -> Map (Name l) (Binding l))
-> (Wrap l pos s node -> LocalEnvironment l)
-> Wrap l pos s node
-> Map (Name l) (Binding l)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Wrap l pos s node -> LocalEnvironment l
forall {a} {b} {g :: * -> *} {a}. Compose ((,) (Atts a b)) g a -> b
declarationBindings
        location :: Compose ((,) a) ((,) (a, b, b)) a -> (a, b)
location (Compose (a
_, ((a
start, b
_, b
end), a
_))) = (a
start, b
end)

isAnyToken :: Lexeme s -> Bool
isAnyToken :: forall s. Lexeme s -> Bool
isAnyToken Token{} = Bool
True
isAnyToken Lexeme s
_ = Bool
False

isAnyDelimiter :: Lexeme s -> Bool
isAnyDelimiter :: forall s. Lexeme s -> Bool
isAnyDelimiter Token{lexemeType :: forall s. Lexeme s -> TokenType
lexemeType= TokenType
Delimiter} = Bool
True
isAnyDelimiter Lexeme s
_ = Bool
False

isAnyKeyword :: Lexeme s -> Bool
isAnyKeyword :: forall s. Lexeme s -> Bool
isAnyKeyword Token{lexemeType :: forall s. Lexeme s -> TokenType
lexemeType= TokenType
Keyword} = Bool
True
isAnyKeyword Lexeme s
_ = Bool
False

isKeyword :: (Eq s, IsString s) => s -> Lexeme s -> Bool
isKeyword :: forall s. (Eq s, IsString s) => s -> Lexeme s -> Bool
isKeyword s
s Token{lexemeType :: forall s. Lexeme s -> TokenType
lexemeType= TokenType
Keyword, lexemeText :: forall s. Lexeme s -> s
lexemeText= s
t} = s
s s -> s -> Bool
forall a. Eq a => a -> a -> Bool
== s
t
isKeyword s
_ Lexeme s
_ = Bool
False

isToken :: (Eq s, IsString s) => s -> Lexeme s -> Bool
isToken :: forall s. (Eq s, IsString s) => s -> Lexeme s -> Bool
isToken s
s Token{lexemeText :: forall s. Lexeme s -> s
lexemeText= s
t} = s
s s -> s -> Bool
forall a. Eq a => a -> a -> Bool
== s
t
isToken s
_ Lexeme s
_ = Bool
False