helium-1.8: src/Helium/StaticAnalysis/Inferencers/TypeInferencing.hs
{-# LANGUAGE Rank2Types, GADTs #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Helium.StaticAnalysis.Inferencers.TypeInferencing where
-- types
import Top.Types
import Helium.StaticAnalysis.Miscellaneous.TypeConversion
-- error messages and warnings
import Helium.StaticAnalysis.Messages.Messages
import Helium.StaticAnalysis.Messages.TypeErrors
import Helium.StaticAnalysis.Messages.Warnings
import Helium.StaticAnalysis.Miscellaneous.ConstraintInfo
import Helium.StaticAnalysis.Miscellaneous.DoublyLinkedTree
import Helium.StaticAnalysis.Miscellaneous.UHA_Source
-- constraints and constraint trees
import Helium.StaticAnalysis.Miscellaneous.TypeConstraints
import Top.Ordering.Tree
-- constraint solving
import Helium.StaticAnalysis.Inferencers.SelectConstraintSolver (selectConstraintSolver)
import Top.Solver (SolveResult(..), LogEntries)
import Helium.StaticAnalysis.Heuristics.HeuristicsInfo (makeUnifier, skip_UHA_FB_RHS)
import Helium.StaticAnalysis.Inferencers.BindingGroupAnalysis
-- UHA syntax
import Helium.Syntax.UHA_Syntax
import Helium.Syntax.UHA_Range
-- other
import Helium.Utils.Utils (internalError, hole)
import Helium.ModuleSystem.ImportEnvironment hiding (setTypeSynonyms)
import Helium.ModuleSystem.DictionaryEnvironment
import Helium.Main.Args
-- standard
import qualified Data.Map as M
import Data.Maybe
import Data.List
import Helium.StaticAnalysis.Directives.Matchers
import Helium.StaticAnalysis.Directives.TS_Apply (applyTypingStrategy, matchInformation)
import Helium.StaticAnalysis.Directives.TS_CoreSyntax
import Helium.StaticAnalysis.Directives.TS_Attributes
import Helium.Syntax.UHA_Utils
import Control.Monad.Identity (Identity)
import qualified Control.Monad.Identity
typeInferencing :: [Option] -> ImportEnvironment -> Module
-> (IO (), DictionaryEnvironment, TypeEnvironment, TypeErrors, Warnings)
typeInferencing options importEnv module_ =
let res = wrap_Module (sem_Module module_) Inh_Module {
importEnvironment_Inh_Module = importEnv,
options_Inh_Module = options }
debugIO = putStrLn (show $ logEntries_Syn_Module res)
in (debugIO, dictionaryEnvironment_Syn_Module res, toplevelTypes_Syn_Module res, typeErrors_Syn_Module res, warnings_Syn_Module res)
proximaTypeInferencing :: [Option] -> ImportEnvironment -> Module
-> (TypeErrors, Warnings, TypeEnvironment, [(Range, TpScheme)])
proximaTypeInferencing options importEnv module_ =
let res = wrap_Module (sem_Module module_) Inh_Module {
importEnvironment_Inh_Module = importEnv,
options_Inh_Module = options }
localTypeSchemes = typeSchemesInInfoTree (substitutionFromResult $ solveResult_Syn_Module res)
(qualifiersFromResult $ solveResult_Syn_Module res)
(infoTree_Syn_Module res)
in (typeErrors_Syn_Module res, warnings_Syn_Module res, toplevelTypes_Syn_Module res, localTypeSchemes)
getRequiredDictionaries :: OrderedTypeSynonyms -> Tp -> TpScheme -> Predicates
getRequiredDictionaries synonyms useType defType =
expandPredicates synonyms (matchTypeWithScheme synonyms useType defType)
matchTypeWithScheme :: OrderedTypeSynonyms -> Tp -> TpScheme -> Predicates
matchTypeWithScheme synonyms tp scheme =
let (ips, itp) = split . snd . instantiate 0 . freezeFTV $ scheme
in case mguWithTypeSynonyms synonyms itp (freezeVariablesInType tp) of
Left _ -> internalError "TypeInferenceOverloading.ag" "matchTypeWithScheme" "no unification"
Right (_, sub) ->
let f (Predicate s typ) = Predicate s (unfreezeVariablesInType $ sub |-> typ)
in map f ips
resolveOverloading :: ClassEnvironment -> Name -> Predicates -> Predicates ->
DictionaryEnvironment -> DictionaryEnvironment
resolveOverloading classEnv name availablePredicates predicates dEnv =
let maybeTrees = map (makeDictionaryTree classEnv availablePredicates) predicates
in if all isJust maybeTrees
then addForVariable name (map fromJust maybeTrees) dEnv
else internalError "TypeInferenceOverloading.ag" "resolveOverloading" ("cannot resolve overloading (" ++ show name ++ ")")
expandPredicates :: OrderedTypeSynonyms -> Predicates -> Predicates
expandPredicates synonyms = map (expandPredicate synonyms)
expandPredicate :: OrderedTypeSynonyms -> Predicate -> Predicate
expandPredicate (_, synonyms) (Predicate className tp) = Predicate className (expandType synonyms tp)
findInferredTypes :: M.Map Int (Scheme Predicates) -> M.Map Name (Sigma Predicates) -> TypeEnvironment
findInferredTypes typeschemeMap =
let err = internalError "TypeInferenceCollect.ag" "findInferredTypes" "could not find type scheme variable"
f :: Sigma Predicates -> TpScheme
f (SigmaVar i) = M.findWithDefault err i typeschemeMap
f (SigmaScheme ts) = ts
in M.map f
missingTypeSignature :: Bool -> Names -> TypeEnvironment -> Warnings
missingTypeSignature topLevel simplePats =
let -- for the moment, only missing type signature for top-level functions are reported (unless monomorphic).
makeWarning (name, scheme) =
let fromSimple = name `elem` simplePats && isOverloaded scheme
in [ NoTypeDef name scheme topLevel fromSimple | null (ftv scheme) && (topLevel || fromSimple) ]
in concatMap makeWarning . M.assocs
restrictedNameErrors :: TypeEnvironment -> Names -> TypeErrors
restrictedNameErrors env =
let f name = case M.lookup name env of
Just scheme -> [ makeRestrictedButOverloadedError name scheme | isOverloaded scheme ]
Nothing -> []
in concatMap f
makeLocalTypeEnv :: TypeEnvironment -> BindingGroups -> M.Map NameWithRange TpScheme
makeLocalTypeEnv local groups =
let (environment, _, _) = concatBindingGroups groups
names = M.keys environment
f x = maybe err id (find (==x) names)
err = internalError "TypeInferenceCollect.ag" "makeLocalTypeEnv" "could not find name"
in M.fromList [ (NameWithRange (f name), scheme) | (name, scheme) <- M.assocs local ]
isSimplePattern :: Pattern -> Bool
isSimplePattern pattern =
case pattern of
Pattern_Variable _ _ -> True
Pattern_Parenthesized _ p -> isSimplePattern p
_ -> False
globalInfoError :: a
globalInfoError = internalError "GlobalInfo.ag" "n/a" "global info not available"
type ScopeInfo = ( [Names] -- duplicated variables
, [Name] -- unused variables
, [(Name, Name)] -- shadowed variables
)
changeOfScope :: Names -> Names -> Names -> (Names, Names, ScopeInfo)
changeOfScope names unboundNames namesInScope =
let (uniqueNames, duplicatedNames) = uniqueAppearance names
unusedNames = uniqueNames \\ unboundNames
shadowedNames = let f n = [ (n, n') | n' <- namesInScope, n == n' ]
in concatMap f uniqueNames
in ( uniqueNames ++ map head duplicatedNames ++ (namesInScope \\ names)
, unboundNames \\ names
, (duplicatedNames, unusedNames, shadowedNames)
)
uniqueAppearance :: Ord a => [a] -> ([a],[[a]])
uniqueAppearance = Prelude.foldr myInsert ([],[]) . group . sort
where myInsert [x] (as,bs) = (x:as,bs)
myInsert xs (as,bs) = (as,xs:bs)
nextUnique :: Num a => a -> (a, a)
nextUnique n = (n+1, n)
matchConverter0 :: [([String],())] -> ()
matchConverter0 = const ()
matchConverter1 :: [([String],a)] -> [(a,[String])]
matchConverter1 = map (\(a,b) -> (b,a))
matchConverter2 :: [([String],(a,b))] -> ([(a,[String])],[(b,[String])])
matchConverter2 = let localInsert (metas,(a,b)) (as,bs) = ((a,metas):as,(b,metas):bs)
in foldr localInsert ([],[])
matchConverter3 :: [([String],(a,b,c))] -> ([(a,[String])],[(b,[String])],[(c,[String])])
matchConverter3 = let localInsert (metas,(a,b,c)) (as,bs,cs) = ((a,metas):as,(b,metas):bs,(c,metas):cs)
in foldr localInsert ([],[],[])
allMatch :: [Maybe [a]] -> Maybe [a]
allMatch = rec_ []
where rec_ xs [] = Just xs
rec_ _ (Nothing:_) = Nothing
rec_ xs (Just ys:rest) = rec_ (ys ++ xs) rest
data Match a = NoMatch | NonTerminalMatch a | MetaVariableMatch String
instance Show (Match a) where
show (NoMatch) = "NoMatch"
show (NonTerminalMatch _) = "NonTerminal ??"
show (MetaVariableMatch s) = "MetaVariableMatch "++show s
expressionVariableMatcher :: Expression -> Maybe String
expressionVariableMatcher expr =
case expr of
Expression_Variable _ name -> Just (show name)
_ -> Nothing
match0 :: MetaVariableInfo -> Int -> (Expression -> Maybe ())
-> [(Expression, [String])]
-> [((Expression, [String]), Core_TypingStrategy)]
-> [[Maybe MetaVariableTable]]
-> ((), [Maybe MetaVariableTable], ConstraintSet, Assumptions, Int, IO ())
match0 = generalMatch expressionVariableMatcher matchConverter0
match1 :: MetaVariableInfo -> Int -> (Expression -> Maybe a)
-> [(Expression, [String])]
-> [((Expression, [String]), Core_TypingStrategy)]
-> [[Maybe MetaVariableTable]]
-> ([(a, [String])], [Maybe MetaVariableTable],
ConstraintSet, Assumptions, Int, IO ())
match1 = generalMatch expressionVariableMatcher matchConverter1
match2 :: MetaVariableInfo -> Int -> (Expression -> Maybe (a, b))
-> [(Expression, [String])]
-> [((Expression, [String]), Core_TypingStrategy)]
-> [[Maybe MetaVariableTable]]
-> (([(a, [String])], [(b, [String])]), [Maybe MetaVariableTable],
ConstraintSet, Assumptions, Int, IO ())
match2 = generalMatch expressionVariableMatcher matchConverter2
match3 :: MetaVariableInfo -> Int -> (Expression -> Maybe (a, b, c))
-> [(Expression, [String])]
-> [((Expression, [String]), Core_TypingStrategy)]
-> [[Maybe MetaVariableTable]]
-> (([(a, [String])], [(b, [String])], [(c, [String])]),
[Maybe MetaVariableTable], ConstraintSet,
Assumptions, Int, IO ())
match3 = generalMatch expressionVariableMatcher matchConverter3
match0' :: (a -> Maybe ()) -> [(a, [String])]
-> [((a, [String]), Core_TypingStrategy)]
-> [[Maybe MetaVariableTable]]
-> ((), [Maybe MetaVariableTable], ConstraintSet,
Assumptions, Int, IO ())
match0' = generalMatch noMatch matchConverter0 noMetaVariableInfo 0
match1' :: (a -> Maybe b) -> [(a, [String])]
-> [((a, [String]), Core_TypingStrategy)]
-> [[Maybe MetaVariableTable]] ->
([(b, [String])], [Maybe MetaVariableTable],
ConstraintSet, Assumptions, Int, IO ())
match1' = generalMatch noMatch matchConverter1 noMetaVariableInfo 0
match2' :: (n -> Maybe (a, b)) -> [(n, [String])]
-> [((n, [String]), Core_TypingStrategy)]
-> [[Maybe MetaVariableTable]]
-> (([(a, [String])], [(b, [String])]),
[Maybe MetaVariableTable], ConstraintSet, Assumptions, Int, IO ())
match2' = generalMatch noMatch matchConverter2 noMetaVariableInfo 0
matchOnlyVariable :: MetaVariableInfo -> [(Expression, [String])] -> [Maybe MetaVariableTable]
matchOnlyVariable infoTuple tryPats =
let ((),matches,_,_,_,_) = match0 infoTuple 0 noMatch tryPats [] []
in matches
noMatch :: a -> Maybe b
noMatch = const Nothing
noMetaVariableInfo :: a
noMetaVariableInfo = internalError "PatternMatching.ag" "noMetaVariableInfo" ""
generalMatch :: (nonTerminal -> Maybe String)
-> ([([String], childrenTuple)] -> childrenResult)
-> MetaVariableInfo
-> Int
-> (nonTerminal -> Maybe childrenTuple)
-> [(nonTerminal, [String])]
-> [((nonTerminal, [String]), Core_TypingStrategy)]
-> [[Maybe MetaVariableTable]]
-> ( childrenResult
, [Maybe MetaVariableTable]
, ConstraintSet
, Assumptions
, Int
, IO ()
)
generalMatch exprVarMatcher converter metaInfo unique matcher tryPats allPats childrenResults =
let match (expr,metas) =
case exprVarMatcher expr of
Just s | s `elem` metas -> MetaVariableMatch s
_ -> case matcher expr of
Just x -> NonTerminalMatch (metas,x)
Nothing -> NoMatch
(allPatterns, allStrategies) = unzip allPats
matchListTry = map match tryPats
matchListNew = map match allPatterns
matchNTTry = [ x | NonTerminalMatch x <- matchListTry ]
matchNTNew = [ x | NonTerminalMatch x <- matchListNew ]
forChildren = converter (matchNTTry ++ matchNTNew)
numberOfTry = length matchNTTry
(resultTry,resultNew) = unzip . map (splitAt numberOfTry) $
if null childrenResults
then [repeat (Just [])]
else childrenResults
inspectMatch m (res, nts) =
case m of
NoMatch -> (Nothing:res, nts)
NonTerminalMatch _ -> (allMatch (head nts):res, tail nts)
MetaVariableMatch s -> (Just [(s, metaInfo)]:res, nts) -- !!!
result = fst (foldr inspectMatch ([],reverse $ transpose resultTry) matchListTry)
complete = let (list,_) = foldr inspectMatch ([],reverse $ transpose resultNew) matchListNew
in [ (x, y) | (Just x, y) <- zip list allStrategies ]
(assumptions, constraintSet, debugIO, newUnique) =
case complete of
[] -> (getAssumptions metaInfo, getConstraintSet metaInfo, return (), unique)
(childrenInfo, typingStrategy):_
-> applyTypingStrategy typingStrategy metaInfo childrenInfo unique
in (forChildren, result, constraintSet, assumptions, newUnique, debugIO)
pmError :: String -> String -> a
pmError = internalError "PatternMatchWarnings"
expandTypeFromImportEnvironment :: ImportEnvironment -> Tp -> Tp
expandTypeFromImportEnvironment env = expandType (snd $ getOrderedTypeSynonyms env)
patternMatchWarnings :: Substitution substitution
=> ImportEnvironment -- the importenvironment
-> substitution -- substitution that contains the real types
-> Tp -- type of the patterns, unsubstituted
-> (Tp -> Tps) -- how should the type be interpreted?
-> [([PatternElement], Bool)] -- the patterns to be processed
-> Range -- range for the missing-warnings
-> Maybe Name -- maybe the name of the function
-> Bool -- should there be parentheses around the patterns?
-> [Warning] -- list of overlap-warnings for all of the patterns
-> String -- description of the place where the patterns are
-> String -- symbol after the patterns
-> [Warning] -- returns: list of warnings
patternMatchWarnings impenv sub tp strip elementss rng name parens unrwars place sym
= unreachablewarnings ++ missingwarnings
where
env = importEnvironmentToEnv impenv
exprtype = expandTypeFromImportEnvironment impenv $ sub |-> tp
types = strip exprtype
unreachables = unreachable impenv types $ map (\((a, _), c) -> (a, c)) $ filter (not.snd.fst) $ zip elementss [0..]
missing = complement impenv types $ map fst elementss
unreachablewarnings = map (unrwars !!) unreachables
missingwarnings
| null $ unMissing missing = []
| otherwise = [MissingPatterns rng name exprtype (map (nicePattern parens env) $ missingList missing) place sym]
----------
-- misc --
----------
-- lifted or
(|^|) :: (a -> Bool) -> (a -> Bool) -> a -> Bool
(|^|) f g x = f x || g x
----------------------------------------------
--- environments and substitution of types ---
----------------------------------------------
-- environment of constructors [(type, (constructorname, arguments))]
type Env = [(Tp, (Name, [Tp]))]
importEnvironmentToEnv :: ImportEnvironment -> [(Tp, (Name, [Tp]))]
importEnvironmentToEnv = map rearrange . M.assocs . valueConstructors
-- return the number of arguments of a constructor
-- tuples ar not in the Env so they require special treatment
nrOfArguments :: Env -> String -> Int
nrOfArguments env con | isTupleConstructor con = length con - 1
| otherwise = case lookup (nameFromString con) $ map snd env
of Just args -> length args
Nothing -> 0
-- convert constructor to fit in an Env
rearrange :: (Name, TpScheme) -> (Tp, (Name, [Tp]))
rearrange (name, tpscheme) = let (args, res) = functionSpine $ unqualify $ unquantify tpscheme
in (res, (name, args))
-- get the constructors of a given type out of an Env
-- tuples ar not in the Env so they require special treatment
constructors :: ImportEnvironment -> Tp -> [(Name, [Tp])]
constructors _ (TVar _) = []
constructors impenv tp | isTupleConstructor name = [tupleconstructor]
| otherwise = map expand $ concatMap (substitute tp) $ importEnvironmentToEnv impenv
where
name :: String
name = unTCon $ fst $ leftSpine tp
tupleconstructor :: (Name, [Tp])
tupleconstructor = (nameFromString name, snd $ leftSpine tp)
unTCon :: Tp -> String
unTCon (TCon c) = c
unTCon tp' = pmError "unTCon" $ "type " ++ show tp' ++ " is not a TCon"
expand :: (Name, [Tp]) -> (Name, [Tp])
expand (n, ts) = (n, map (expandTypeFromImportEnvironment impenv) ts)
-- check of an entry in an Env is a constructor for the given type
-- if so, return this constructor, but with variables substituted for whatever is in the given type
-- the list returns zero or one elements
-- for example: substitute (Maybe Int) (Maybe a, (Just, [a])) will return [(Just, [Int])]
substitute :: Tp -> (Tp, (Name, [Tp])) -> [(Name, [Tp])]
substitute t1 (t2, (con, args)) = let (c1, ts1) = leftSpine t1
(c2, ts2) = leftSpine t2
sub = listToSubstitution $ zip (map unTVar ts2) ts1
in if c1 == c2
then [(con, map (sub |->) args)]
else []
where
unTVar :: Tp -> Int
unTVar (TVar v) = v
unTVar _ = pmError "unTVar" "type is not a TVar"
---------------------------------------------------------------
--- datastructures and functions for the solution structure ---
---------------------------------------------------------------
-- a pattern is a list of patternelements
data PatternElement = WildcardElement | InfiniteElement String | FiniteElement String deriving Eq
isInfiniteElement :: PatternElement -> Bool
isInfiniteElement (InfiniteElement _) = True
isInfiniteElement _ = False
elementString :: PatternElement -> String
elementString (InfiniteElement s) = s
elementString ( FiniteElement s) = s
elementString _ = []
-- needed for Pattern_List and Literal_String occurences
listPat :: [[PatternElement]] -> [PatternElement]
listPat [] = [FiniteElement "[]"]
listPat (ps:pss) = FiniteElement ":" : ps ++ listPat pss
stringPat :: String -> [PatternElement]
stringPat [] = [FiniteElement "[]"]
stringPat (c:cs) = FiniteElement ":" : InfiniteElement [c] : stringPat cs
-- tree of missing patterns
data PatternsMissing = PatternsMissing [(PatternElement, PatternsMissing)]
unMissing :: PatternsMissing -> [(PatternElement, PatternsMissing)]
unMissing (PatternsMissing l) = l
-- create a branch consisting of only wildcards
wildMissing :: Int -> PatternsMissing
wildMissing 0 = PatternsMissing []
wildMissing n = PatternsMissing [(WildcardElement, wildMissing $ n - 1)]
-- convert a missing patterns tree to a list of seperated missing patterns
missingList :: PatternsMissing -> [[PatternElement]]
missingList (PatternsMissing []) = [[]]
missingList (PatternsMissing [(d,t)]) = map (d:) $ missingList t
missingList (PatternsMissing (d:ds)) = (missingList $ PatternsMissing [d]) ++ (missingList $ PatternsMissing ds)
-------------------------------------------------------------------
--- functions to create a UHA_Pattern out of a [PatternElement] ---
-------------------------------------------------------------------
-- nice creates the actual pattern without parentheses
-- [Just, True, True, (,), Just, Nothing, False] -> [Just True, True, (Just Nothing, False)]
nicePattern :: Bool -> Env -> [PatternElement] -> [Pattern]
nicePattern b env = map (parensPattern b) . nice
where
nice :: [PatternElement] -> [Pattern]
nice [] = []
nice (WildcardElement :ps) = Pattern_Wildcard noRange : nice ps
nice (InfiniteElement _ :_) = pmError "nicePattern" "InfiniteElement in pattern!"
nice (FiniteElement con:ps) =
let rest = nice ps
name = nameFromString con
n = nrOfArguments env con
in case name
of Name_Identifier _ _ _ -> Pattern_Constructor noRange name (take n rest) : drop n rest -- !!!Name
Name_Operator _ _ _ | con == ":" -> case head $ tail rest -- !!!Name
of Pattern_List _ pats -> Pattern_List noRange (head rest:pats) : (tail $ tail rest)
_ -> Pattern_InfixConstructor noRange (head rest) name (head $ tail rest) : (tail $ tail rest)
| otherwise -> Pattern_InfixConstructor noRange (head rest) name (head $ tail rest) : (tail $ tail rest)
Name_Special _ _ _ | isTupleConstructor con -> Pattern_Tuple noRange (take n rest) : drop n rest -- !!!Name
| con == "[]" -> Pattern_List noRange [] : rest
| otherwise -> Pattern_Constructor noRange name (take n rest) : drop n rest
-- add parentheses to a pattern in the correct places
-- bool means: if needed, should there be parenthesis around the complete pattern?
parensPattern :: Bool -> Pattern -> Pattern
parensPattern b = if b then rap . par else fst . par
where
par :: Pattern -> (Pattern, Bool) -- Bool means: are parentheses needed around this pattern, shoud it be used in a more complex pattern
par p@(Pattern_Literal _ _ ) = (p, False)
par p@(Pattern_Variable _ _ ) = (p, False)
par (Pattern_Constructor r n ps ) = (Pattern_Constructor r n $ map (rap.par) ps, length ps > 0)
par (Pattern_Parenthesized _ p ) = par p
par (Pattern_InfixConstructor r l n k) = (Pattern_InfixConstructor r (rap $ par l) n (rap $ par k), True)
par (Pattern_List r ps ) = (Pattern_List r $ map (fst.par) ps, False)
par (Pattern_Tuple r ps ) = (Pattern_Tuple r $ map (fst.par) ps, False)
par (Pattern_Record _ _ _ ) = pmError "parensPattern" "Records are not supported"
par p@(Pattern_Negate _ _ ) = (p, True)
par p@(Pattern_NegateFloat _ _ ) = (p, True)
par (Pattern_As r n p ) = (Pattern_As r n (rap $ par p), False)
par p@(Pattern_Wildcard _ ) = (p, False)
par (Pattern_Irrefutable _ _ ) = pmError "parensPattern" "Irrefutable patterns are not supported"
par (Pattern_Successor _ _ _ ) = pmError "parensPattern" "Successors are not supported"
par (Pattern_Hole _ _ ) = error "not supported"
rap :: (Pattern, Bool) -> Pattern
rap (p, False) = p
rap (p, True ) = Pattern_Parenthesized noRange p
--------------------------------------
--- finally, the algorithm itself! ---
--------------------------------------
-- returns the tree of missing patterns for a given list of patterns
complement :: ImportEnvironment -> [Tp] -> [[PatternElement]] -> PatternsMissing
complement _ [] _ = PatternsMissing []
complement _ _ ([]:_) = PatternsMissing []
complement env (tp:tps) pss | null $ unMissing anyComplement = PatternsMissing []
| all (((== WildcardElement) |^| isInfiniteElement).head) pss = anyComplement
| otherwise = finComplement
where
patComplement :: [[PatternElement]] -> PatternElement -> [Tp] -> PatternsMissing
patComplement [] current typs = PatternsMissing [(current, wildMissing $ length typs)]
patComplement patss current typs = case unMissing $ complement env typs $ map tail $ patss
of [] -> PatternsMissing []
tegs -> PatternsMissing [(current, PatternsMissing tegs)]
anyComplement :: PatternsMissing
anyComplement = patComplement (filter ((== WildcardElement).head) pss) WildcardElement tps
conComplement :: (Name, [Tp]) -> PatternsMissing
conComplement (con, args) = patComplement ( filter ((== FiniteElement (getNameName con)).head) pss
++ map (\ps -> FiniteElement (getNameName con) : replicate (length args) WildcardElement ++ tail ps)
(filter ((== WildcardElement).head) pss)
)
(FiniteElement (getNameName con)) (args ++ tps)
finComplement :: PatternsMissing
finComplement = case constructors env tp
of [] -> wildMissing $ 1 + length tps
cons -> PatternsMissing $ concatMap (unMissing.conComplement) cons
----------------------------
--- unreachable patterns ---
----------------------------
-- complements the list of reachable patterns
unreachable :: ImportEnvironment -> [Tp] -> [([PatternElement], Int)] -> [Int]
unreachable env tps ps = let reach = reachable env tps ps
in filter (not . flip elem reach) (map snd ps)
-- determines which patterns are reachable
-- possibly multiple occurances of indices
reachable :: ImportEnvironment -> [Tp] -> [([PatternElement], Int)] -> [Int]
reachable _ [] _ = pmError "reachable" "empty type list!"
reachable env (tp:tps) ps
| all ((== WildcardElement).head.fst) ps = conReachable ps
| otherwise = concat $ map (conReachable.conPats) $ stop cons
where
cons :: [PatternElement]
cons = thin $ map (head.fst) ps
conPats :: PatternElement -> [([PatternElement], Int)]
conPats con = map (\(es, i) -> (fill con es, i)) $ filter (((== con) |^| (== WildcardElement)).head.fst) ps
fill :: PatternElement -> [PatternElement] -> [PatternElement]
fill e@(FiniteElement c) (WildcardElement : es) = e : replicate (nrOfArguments (importEnvironmentToEnv env) c) WildcardElement ++ es
fill e (_ : es) = e : es
fill _ [] = error "Pattern match failure in StaticAnalysis.Inferencers.reachable"
stop :: [PatternElement] -> [PatternElement]
stop es | length (constructors env tp) > length es = FiniteElement "[*]" : es
| length (constructors env tp) == 0 = FiniteElement "[*]" : es
| otherwise = es
conReachable :: [([PatternElement], Int)] -> [Int]
conReachable [] = []
conReachable pats
| null.tail.fst.head $ pats = [snd.head $ pats]
| otherwise = reachable env (arguments (elementString.head.fst.head $ pats) ++ tps)
$ map (\(es, i) -> (tail es, i)) pats
arguments :: String -> [Tp]
arguments c = maybe [] id $ lookup c $ map (\(n, typs) -> (getNameName n, typs)) $ constructors env tp
-- remove double occurances and wildcards
thin :: [PatternElement] -> [PatternElement]
thin [] = []
thin (WildcardElement : es) = thin es
thin (e : es) | elem e thines = thines
| otherwise = e : thines
where thines = thin es
-- Alternative -------------------------------------------------
-- wrapper
data Inh_Alternative = Inh_Alternative { allPatterns_Inh_Alternative :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Alternative :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Alternative :: (Predicates), betaLeft_Inh_Alternative :: (Tp), betaRight_Inh_Alternative :: (Tp), betaUnique_Inh_Alternative :: (Int), classEnvironment_Inh_Alternative :: (ClassEnvironment), collectErrors_Inh_Alternative :: (TypeErrors), collectWarnings_Inh_Alternative :: (Warnings), counter_Inh_Alternative :: (Int), currentChunk_Inh_Alternative :: (Int), dictionaryEnvironment_Inh_Alternative :: (DictionaryEnvironment), importEnvironment_Inh_Alternative :: (ImportEnvironment), matchIO_Inh_Alternative :: (IO ()), monos_Inh_Alternative :: (Monos), namesInScope_Inh_Alternative :: (Names), orderedTypeSynonyms_Inh_Alternative :: (OrderedTypeSynonyms), parentTree_Inh_Alternative :: (InfoTree), patternMatchWarnings_Inh_Alternative :: ([Warning]), substitution_Inh_Alternative :: (FixpointSubstitution), typeschemeMap_Inh_Alternative :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Alternative :: (Int) }
data Syn_Alternative = Syn_Alternative { assumptions_Syn_Alternative :: (Assumptions), betaUnique_Syn_Alternative :: (Int), collectErrors_Syn_Alternative :: (TypeErrors), collectInstances_Syn_Alternative :: ([(Name, Instance)]), collectWarnings_Syn_Alternative :: (Warnings), constraints_Syn_Alternative :: (ConstraintSet), counter_Syn_Alternative :: (Int), dictionaryEnvironment_Syn_Alternative :: (DictionaryEnvironment), elements_Syn_Alternative :: ( ([PatternElement], Bool) ), infoTrees_Syn_Alternative :: (InfoTrees), matchIO_Syn_Alternative :: (IO ()), patternMatchWarnings_Syn_Alternative :: ([Warning]), self_Syn_Alternative :: (Alternative), unboundNames_Syn_Alternative :: (Names), uniqueChunk_Syn_Alternative :: (Int), unrwar_Syn_Alternative :: (Warning) }
{-# INLINABLE wrap_Alternative #-}
wrap_Alternative :: T_Alternative -> Inh_Alternative -> (Syn_Alternative )
wrap_Alternative (T_Alternative act) (Inh_Alternative _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Alternative_vIn1 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
(T_Alternative_vOut1 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar) <- return (inv_Alternative_s2 sem arg)
return (Syn_Alternative _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar)
)
-- cata
{-# NOINLINE sem_Alternative #-}
sem_Alternative :: Alternative -> T_Alternative
sem_Alternative ( Alternative_Hole range_ id_ ) = sem_Alternative_Hole ( sem_Range range_ ) id_
sem_Alternative ( Alternative_Feedback range_ feedback_ alternative_ ) = sem_Alternative_Feedback ( sem_Range range_ ) feedback_ ( sem_Alternative alternative_ )
sem_Alternative ( Alternative_Alternative range_ pattern_ righthandside_ ) = sem_Alternative_Alternative ( sem_Range range_ ) ( sem_Pattern pattern_ ) ( sem_RightHandSide righthandside_ )
sem_Alternative ( Alternative_Empty range_ ) = sem_Alternative_Empty ( sem_Range range_ )
-- semantic domain
newtype T_Alternative = T_Alternative {
attach_T_Alternative :: Identity (T_Alternative_s2 )
}
newtype T_Alternative_s2 = C_Alternative_s2 {
inv_Alternative_s2 :: (T_Alternative_v1 )
}
data T_Alternative_s3 = C_Alternative_s3
type T_Alternative_v1 = (T_Alternative_vIn1 ) -> (T_Alternative_vOut1 )
data T_Alternative_vIn1 = T_Alternative_vIn1 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Tp) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_Alternative_vOut1 = T_Alternative_vOut1 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) ( ([PatternElement], Bool) ) (InfoTrees) (IO ()) ([Warning]) (Alternative) (Names) (Int) (Warning)
{-# NOINLINE sem_Alternative_Hole #-}
sem_Alternative_Hole :: T_Range -> (Integer) -> T_Alternative
sem_Alternative_Hole arg_range_ arg_id_ = T_Alternative (return st2) where
{-# NOINLINE st2 #-}
st2 = let
v1 :: T_Alternative_v1
v1 = \ (T_Alternative_vIn1 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule0 ()
_constraints = rule1 ()
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2 ()
_lhsOelements :: ([PatternElement], Bool)
_lhsOelements = rule3 ()
_lhsOunrwar :: Warning
_lhsOunrwar = rule4 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule5 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule6 ()
_self = rule7 _rangeIself arg_id_
_lhsOself :: Alternative
_lhsOself = rule8 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule9 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule10 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule11 _lhsIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule12 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule13 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule14 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule15 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule16 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule17 _lhsIuniqueChunk
__result_ = T_Alternative_vOut1 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
in __result_ )
in C_Alternative_s2 v1
{-# INLINE rule0 #-}
rule0 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule1 #-}
rule1 = \ (_ :: ()) ->
emptyTree
{-# INLINE rule2 #-}
rule2 = \ (_ :: ()) ->
[]
{-# INLINE rule3 #-}
rule3 = \ (_ :: ()) ->
([], False)
{-# INLINE rule4 #-}
rule4 = \ (_ :: ()) ->
pmError "Alternative_Empty.unrwar" "empty alternative"
{-# INLINE rule5 #-}
rule5 = \ (_ :: ()) ->
[]
{-# INLINE rule6 #-}
rule6 = \ (_ :: ()) ->
[]
{-# INLINE rule7 #-}
rule7 = \ ((_rangeIself) :: Range) id_ ->
Alternative_Hole _rangeIself id_
{-# INLINE rule8 #-}
rule8 = \ _self ->
_self
{-# INLINE rule9 #-}
rule9 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule10 #-}
rule10 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule11 #-}
rule11 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule12 #-}
rule12 = \ _constraints ->
_constraints
{-# INLINE rule13 #-}
rule13 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule14 #-}
rule14 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule15 #-}
rule15 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule16 #-}
rule16 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule17 #-}
rule17 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Alternative_Feedback #-}
sem_Alternative_Feedback :: T_Range -> (String) -> T_Alternative -> T_Alternative
sem_Alternative_Feedback arg_range_ arg_feedback_ arg_alternative_ = T_Alternative (return st2) where
{-# NOINLINE st2 #-}
st2 = let
v1 :: T_Alternative_v1
v1 = \ (T_Alternative_vIn1 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_alternativeX2 = Control.Monad.Identity.runIdentity (attach_T_Alternative (arg_alternative_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Alternative_vOut1 _alternativeIassumptions _alternativeIbetaUnique _alternativeIcollectErrors _alternativeIcollectInstances _alternativeIcollectWarnings _alternativeIconstraints _alternativeIcounter _alternativeIdictionaryEnvironment _alternativeIelements _alternativeIinfoTrees _alternativeImatchIO _alternativeIpatternMatchWarnings _alternativeIself _alternativeIunboundNames _alternativeIuniqueChunk _alternativeIunrwar) = inv_Alternative_s2 _alternativeX2 (T_Alternative_vIn1 _alternativeOallPatterns _alternativeOallTypeSchemes _alternativeOavailablePredicates _alternativeObetaLeft _alternativeObetaRight _alternativeObetaUnique _alternativeOclassEnvironment _alternativeOcollectErrors _alternativeOcollectWarnings _alternativeOcounter _alternativeOcurrentChunk _alternativeOdictionaryEnvironment _alternativeOimportEnvironment _alternativeOmatchIO _alternativeOmonos _alternativeOnamesInScope _alternativeOorderedTypeSynonyms _alternativeOparentTree _alternativeOpatternMatchWarnings _alternativeOsubstitution _alternativeOtypeschemeMap _alternativeOuniqueChunk)
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule18 _alternativeIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule19 _alternativeIunboundNames
_self = rule20 _alternativeIself _rangeIself arg_feedback_
_lhsOself :: Alternative
_lhsOself = rule21 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule22 _alternativeIassumptions
_lhsObetaUnique :: Int
_lhsObetaUnique = rule23 _alternativeIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule24 _alternativeIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule25 _alternativeIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule26 _alternativeIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule27 _alternativeIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule28 _alternativeIdictionaryEnvironment
_lhsOelements :: ([PatternElement], Bool)
_lhsOelements = rule29 _alternativeIelements
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule30 _alternativeIinfoTrees
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule31 _alternativeImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule32 _alternativeIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule33 _alternativeIuniqueChunk
_lhsOunrwar :: Warning
_lhsOunrwar = rule34 _alternativeIunrwar
_alternativeOallPatterns = rule35 _lhsIallPatterns
_alternativeOallTypeSchemes = rule36 _lhsIallTypeSchemes
_alternativeOavailablePredicates = rule37 _lhsIavailablePredicates
_alternativeObetaLeft = rule38 _lhsIbetaLeft
_alternativeObetaRight = rule39 _lhsIbetaRight
_alternativeObetaUnique = rule40 _lhsIbetaUnique
_alternativeOclassEnvironment = rule41 _lhsIclassEnvironment
_alternativeOcollectErrors = rule42 _lhsIcollectErrors
_alternativeOcollectWarnings = rule43 _lhsIcollectWarnings
_alternativeOcounter = rule44 _lhsIcounter
_alternativeOcurrentChunk = rule45 _lhsIcurrentChunk
_alternativeOdictionaryEnvironment = rule46 _lhsIdictionaryEnvironment
_alternativeOimportEnvironment = rule47 _lhsIimportEnvironment
_alternativeOmatchIO = rule48 _lhsImatchIO
_alternativeOmonos = rule49 _lhsImonos
_alternativeOnamesInScope = rule50 _lhsInamesInScope
_alternativeOorderedTypeSynonyms = rule51 _lhsIorderedTypeSynonyms
_alternativeOparentTree = rule52 _lhsIparentTree
_alternativeOpatternMatchWarnings = rule53 _lhsIpatternMatchWarnings
_alternativeOsubstitution = rule54 _lhsIsubstitution
_alternativeOtypeschemeMap = rule55 _lhsItypeschemeMap
_alternativeOuniqueChunk = rule56 _lhsIuniqueChunk
__result_ = T_Alternative_vOut1 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
in __result_ )
in C_Alternative_s2 v1
{-# INLINE rule18 #-}
rule18 = \ ((_alternativeIcollectInstances) :: [(Name, Instance)]) ->
_alternativeIcollectInstances
{-# INLINE rule19 #-}
rule19 = \ ((_alternativeIunboundNames) :: Names) ->
_alternativeIunboundNames
{-# INLINE rule20 #-}
rule20 = \ ((_alternativeIself) :: Alternative) ((_rangeIself) :: Range) feedback_ ->
Alternative_Feedback _rangeIself feedback_ _alternativeIself
{-# INLINE rule21 #-}
rule21 = \ _self ->
_self
{-# INLINE rule22 #-}
rule22 = \ ((_alternativeIassumptions) :: Assumptions) ->
_alternativeIassumptions
{-# INLINE rule23 #-}
rule23 = \ ((_alternativeIbetaUnique) :: Int) ->
_alternativeIbetaUnique
{-# INLINE rule24 #-}
rule24 = \ ((_alternativeIcollectErrors) :: TypeErrors) ->
_alternativeIcollectErrors
{-# INLINE rule25 #-}
rule25 = \ ((_alternativeIcollectWarnings) :: Warnings) ->
_alternativeIcollectWarnings
{-# INLINE rule26 #-}
rule26 = \ ((_alternativeIconstraints) :: ConstraintSet) ->
_alternativeIconstraints
{-# INLINE rule27 #-}
rule27 = \ ((_alternativeIcounter) :: Int) ->
_alternativeIcounter
{-# INLINE rule28 #-}
rule28 = \ ((_alternativeIdictionaryEnvironment) :: DictionaryEnvironment) ->
_alternativeIdictionaryEnvironment
{-# INLINE rule29 #-}
rule29 = \ ((_alternativeIelements) :: ([PatternElement], Bool) ) ->
_alternativeIelements
{-# INLINE rule30 #-}
rule30 = \ ((_alternativeIinfoTrees) :: InfoTrees) ->
_alternativeIinfoTrees
{-# INLINE rule31 #-}
rule31 = \ ((_alternativeImatchIO) :: IO ()) ->
_alternativeImatchIO
{-# INLINE rule32 #-}
rule32 = \ ((_alternativeIpatternMatchWarnings) :: [Warning]) ->
_alternativeIpatternMatchWarnings
{-# INLINE rule33 #-}
rule33 = \ ((_alternativeIuniqueChunk) :: Int) ->
_alternativeIuniqueChunk
{-# INLINE rule34 #-}
rule34 = \ ((_alternativeIunrwar) :: Warning) ->
_alternativeIunrwar
{-# INLINE rule35 #-}
rule35 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule36 #-}
rule36 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule37 #-}
rule37 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule38 #-}
rule38 = \ ((_lhsIbetaLeft) :: Tp) ->
_lhsIbetaLeft
{-# INLINE rule39 #-}
rule39 = \ ((_lhsIbetaRight) :: Tp) ->
_lhsIbetaRight
{-# INLINE rule40 #-}
rule40 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule41 #-}
rule41 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule42 #-}
rule42 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule43 #-}
rule43 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule44 #-}
rule44 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule45 #-}
rule45 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule46 #-}
rule46 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule47 #-}
rule47 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule48 #-}
rule48 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule49 #-}
rule49 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule50 #-}
rule50 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule51 #-}
rule51 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule52 #-}
rule52 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule53 #-}
rule53 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule54 #-}
rule54 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule55 #-}
rule55 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule56 #-}
rule56 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Alternative_Alternative #-}
sem_Alternative_Alternative :: T_Range -> T_Pattern -> T_RightHandSide -> T_Alternative
sem_Alternative_Alternative arg_range_ arg_pattern_ arg_righthandside_ = T_Alternative (return st2) where
{-# NOINLINE st2 #-}
st2 = let
v1 :: T_Alternative_v1
v1 = \ (T_Alternative_vIn1 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
_righthandsideX149 = Control.Monad.Identity.runIdentity (attach_T_RightHandSide (arg_righthandside_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
(T_RightHandSide_vOut148 _righthandsideIassumptions _righthandsideIbetaUnique _righthandsideIcollectErrors _righthandsideIcollectInstances _righthandsideIcollectWarnings _righthandsideIconstraints _righthandsideIcounter _righthandsideIdictionaryEnvironment _righthandsideIfallthrough _righthandsideIinfoTree _righthandsideImatchIO _righthandsideIpatternMatchWarnings _righthandsideIself _righthandsideIunboundNames _righthandsideIuniqueChunk) = inv_RightHandSide_s149 _righthandsideX149 (T_RightHandSide_vIn148 _righthandsideOallPatterns _righthandsideOallTypeSchemes _righthandsideOavailablePredicates _righthandsideObetaRight _righthandsideObetaUnique _righthandsideOclassEnvironment _righthandsideOcollectErrors _righthandsideOcollectWarnings _righthandsideOcounter _righthandsideOcurrentChunk _righthandsideOdictionaryEnvironment _righthandsideOimportEnvironment _righthandsideOmatchIO _righthandsideOmonos _righthandsideOnamesInScope _righthandsideOorderedTypeSynonyms _righthandsideOparentTree _righthandsideOpatternMatchWarnings _righthandsideOsubstitution _righthandsideOtypeschemeMap _righthandsideOuniqueChunk)
_righthandsideOmonos = rule57 _csetBinds _lhsImonos _patternIenvironment
_constraints = rule58 _conLeft _csetBinds _patternIconstraints _righthandsideIconstraints
_conLeft = rule59 _cinfoLeft _lhsIbetaLeft _patternIbeta
_lhsOassumptions :: Assumptions
(_csetBinds,_lhsOassumptions) = rule60 _cinfoBind _patternIenvironment _righthandsideIassumptions
_cinfoLeft = rule61 _lhsIbetaLeft _lhsIparentTree _patternIinfoTree
_cinfoBind = rule62 _lhsIparentTree _patternIenvironment
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule63 _patternIinfoTree _righthandsideIinfoTree
(_namesInScope,_unboundNames,_scopeInfo) = rule64 _lhsInamesInScope _patternIpatVarNames _righthandsideIunboundNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule65 _unboundNames
_lhsOelements :: ([PatternElement], Bool)
_lhsOelements = rule66 _patternIelements _righthandsideIfallthrough
_lhsOunrwar :: Warning
_lhsOunrwar = rule67 _patternIself _rangeIself
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule68 _righthandsideIcollectInstances
_self = rule69 _patternIself _rangeIself _righthandsideIself
_lhsOself :: Alternative
_lhsOself = rule70 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule71 _righthandsideIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule72 _righthandsideIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule73 _righthandsideIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule74 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule75 _righthandsideIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule76 _righthandsideIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule77 _righthandsideImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule78 _righthandsideIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule79 _righthandsideIuniqueChunk
_patternObetaUnique = rule80 _lhsIbetaUnique
_patternOcounter = rule81 _lhsIcounter
_patternOimportEnvironment = rule82 _lhsIimportEnvironment
_patternOmonos = rule83 _lhsImonos
_patternOnamesInScope = rule84 _namesInScope
_patternOparentTree = rule85 _lhsIparentTree
_patternOpatternMatchWarnings = rule86 _lhsIpatternMatchWarnings
_righthandsideOallPatterns = rule87 _lhsIallPatterns
_righthandsideOallTypeSchemes = rule88 _lhsIallTypeSchemes
_righthandsideOavailablePredicates = rule89 _lhsIavailablePredicates
_righthandsideObetaRight = rule90 _lhsIbetaRight
_righthandsideObetaUnique = rule91 _patternIbetaUnique
_righthandsideOclassEnvironment = rule92 _lhsIclassEnvironment
_righthandsideOcollectErrors = rule93 _lhsIcollectErrors
_righthandsideOcollectWarnings = rule94 _lhsIcollectWarnings
_righthandsideOcounter = rule95 _patternIcounter
_righthandsideOcurrentChunk = rule96 _lhsIcurrentChunk
_righthandsideOdictionaryEnvironment = rule97 _lhsIdictionaryEnvironment
_righthandsideOimportEnvironment = rule98 _lhsIimportEnvironment
_righthandsideOmatchIO = rule99 _lhsImatchIO
_righthandsideOnamesInScope = rule100 _namesInScope
_righthandsideOorderedTypeSynonyms = rule101 _lhsIorderedTypeSynonyms
_righthandsideOparentTree = rule102 _lhsIparentTree
_righthandsideOpatternMatchWarnings = rule103 _patternIpatternMatchWarnings
_righthandsideOsubstitution = rule104 _lhsIsubstitution
_righthandsideOtypeschemeMap = rule105 _lhsItypeschemeMap
_righthandsideOuniqueChunk = rule106 _lhsIuniqueChunk
__result_ = T_Alternative_vOut1 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
in __result_ )
in C_Alternative_s2 v1
{-# INLINE rule57 #-}
rule57 = \ _csetBinds ((_lhsImonos) :: Monos) ((_patternIenvironment) :: PatternAssumptions) ->
M.elems _patternIenvironment ++ getMonos _csetBinds ++ _lhsImonos
{-# INLINE rule58 #-}
rule58 = \ _conLeft _csetBinds ((_patternIconstraints) :: ConstraintSet) ((_righthandsideIconstraints) :: ConstraintSet) ->
_csetBinds .>>.
Node [ _conLeft .<. _patternIconstraints
, _righthandsideIconstraints
]
{-# INLINE rule59 #-}
rule59 = \ _cinfoLeft ((_lhsIbetaLeft) :: Tp) ((_patternIbeta) :: Tp) ->
[ (_patternIbeta .==. _lhsIbetaLeft) _cinfoLeft ]
{-# INLINE rule60 #-}
rule60 = \ _cinfoBind ((_patternIenvironment) :: PatternAssumptions) ((_righthandsideIassumptions) :: Assumptions) ->
(_patternIenvironment .===. _righthandsideIassumptions) _cinfoBind
{-# INLINE rule61 #-}
rule61 = \ ((_lhsIbetaLeft) :: Tp) ((_lhsIparentTree) :: InfoTree) ((_patternIinfoTree) :: InfoTree) ->
resultConstraint "case pattern" _patternIinfoTree
[ Unifier (head (ftv _lhsIbetaLeft)) ("case patterns", attribute _lhsIparentTree, "case pattern") ]
{-# INLINE rule62 #-}
rule62 = \ ((_lhsIparentTree) :: InfoTree) ((_patternIenvironment) :: PatternAssumptions) ->
\name -> variableConstraint "variable" (nameToUHA_Expr name)
[ FolkloreConstraint
, makeUnifier name "case alternative" _patternIenvironment _lhsIparentTree
]
{-# INLINE rule63 #-}
rule63 = \ ((_patternIinfoTree) :: InfoTree) ((_righthandsideIinfoTree) :: InfoTree) ->
[_patternIinfoTree, _righthandsideIinfoTree]
{-# INLINE rule64 #-}
rule64 = \ ((_lhsInamesInScope) :: Names) ((_patternIpatVarNames) :: Names) ((_righthandsideIunboundNames) :: Names) ->
changeOfScope _patternIpatVarNames _righthandsideIunboundNames _lhsInamesInScope
{-# INLINE rule65 #-}
rule65 = \ _unboundNames ->
_unboundNames
{-# INLINE rule66 #-}
rule66 = \ ((_patternIelements) :: [PatternElement] ) ((_righthandsideIfallthrough) :: Bool) ->
(_patternIelements, _righthandsideIfallthrough)
{-# INLINE rule67 #-}
rule67 = \ ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
UnreachablePatternCase _rangeIself _patternIself
{-# INLINE rule68 #-}
rule68 = \ ((_righthandsideIcollectInstances) :: [(Name, Instance)]) ->
_righthandsideIcollectInstances
{-# INLINE rule69 #-}
rule69 = \ ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ((_righthandsideIself) :: RightHandSide) ->
Alternative_Alternative _rangeIself _patternIself _righthandsideIself
{-# INLINE rule70 #-}
rule70 = \ _self ->
_self
{-# INLINE rule71 #-}
rule71 = \ ((_righthandsideIbetaUnique) :: Int) ->
_righthandsideIbetaUnique
{-# INLINE rule72 #-}
rule72 = \ ((_righthandsideIcollectErrors) :: TypeErrors) ->
_righthandsideIcollectErrors
{-# INLINE rule73 #-}
rule73 = \ ((_righthandsideIcollectWarnings) :: Warnings) ->
_righthandsideIcollectWarnings
{-# INLINE rule74 #-}
rule74 = \ _constraints ->
_constraints
{-# INLINE rule75 #-}
rule75 = \ ((_righthandsideIcounter) :: Int) ->
_righthandsideIcounter
{-# INLINE rule76 #-}
rule76 = \ ((_righthandsideIdictionaryEnvironment) :: DictionaryEnvironment) ->
_righthandsideIdictionaryEnvironment
{-# INLINE rule77 #-}
rule77 = \ ((_righthandsideImatchIO) :: IO ()) ->
_righthandsideImatchIO
{-# INLINE rule78 #-}
rule78 = \ ((_righthandsideIpatternMatchWarnings) :: [Warning]) ->
_righthandsideIpatternMatchWarnings
{-# INLINE rule79 #-}
rule79 = \ ((_righthandsideIuniqueChunk) :: Int) ->
_righthandsideIuniqueChunk
{-# INLINE rule80 #-}
rule80 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule81 #-}
rule81 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule82 #-}
rule82 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule83 #-}
rule83 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule84 #-}
rule84 = \ _namesInScope ->
_namesInScope
{-# INLINE rule85 #-}
rule85 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule86 #-}
rule86 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule87 #-}
rule87 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule88 #-}
rule88 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule89 #-}
rule89 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule90 #-}
rule90 = \ ((_lhsIbetaRight) :: Tp) ->
_lhsIbetaRight
{-# INLINE rule91 #-}
rule91 = \ ((_patternIbetaUnique) :: Int) ->
_patternIbetaUnique
{-# INLINE rule92 #-}
rule92 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule93 #-}
rule93 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule94 #-}
rule94 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule95 #-}
rule95 = \ ((_patternIcounter) :: Int) ->
_patternIcounter
{-# INLINE rule96 #-}
rule96 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule97 #-}
rule97 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule98 #-}
rule98 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule99 #-}
rule99 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule100 #-}
rule100 = \ _namesInScope ->
_namesInScope
{-# INLINE rule101 #-}
rule101 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule102 #-}
rule102 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule103 #-}
rule103 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
_patternIpatternMatchWarnings
{-# INLINE rule104 #-}
rule104 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule105 #-}
rule105 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule106 #-}
rule106 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Alternative_Empty #-}
sem_Alternative_Empty :: T_Range -> T_Alternative
sem_Alternative_Empty arg_range_ = T_Alternative (return st2) where
{-# NOINLINE st2 #-}
st2 = let
v1 :: T_Alternative_v1
v1 = \ (T_Alternative_vIn1 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule107 ()
_constraints = rule108 ()
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule109 ()
_lhsOelements :: ([PatternElement], Bool)
_lhsOelements = rule110 ()
_lhsOunrwar :: Warning
_lhsOunrwar = rule111 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule112 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule113 ()
_self = rule114 _rangeIself
_lhsOself :: Alternative
_lhsOself = rule115 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule116 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule117 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule118 _lhsIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule119 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule120 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule121 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule122 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule123 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule124 _lhsIuniqueChunk
__result_ = T_Alternative_vOut1 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
in __result_ )
in C_Alternative_s2 v1
{-# INLINE rule107 #-}
rule107 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule108 #-}
rule108 = \ (_ :: ()) ->
emptyTree
{-# INLINE rule109 #-}
rule109 = \ (_ :: ()) ->
[]
{-# INLINE rule110 #-}
rule110 = \ (_ :: ()) ->
([], False)
{-# INLINE rule111 #-}
rule111 = \ (_ :: ()) ->
pmError "Alternative_Empty.unrwar" "empty alternative"
{-# INLINE rule112 #-}
rule112 = \ (_ :: ()) ->
[]
{-# INLINE rule113 #-}
rule113 = \ (_ :: ()) ->
[]
{-# INLINE rule114 #-}
rule114 = \ ((_rangeIself) :: Range) ->
Alternative_Empty _rangeIself
{-# INLINE rule115 #-}
rule115 = \ _self ->
_self
{-# INLINE rule116 #-}
rule116 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule117 #-}
rule117 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule118 #-}
rule118 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule119 #-}
rule119 = \ _constraints ->
_constraints
{-# INLINE rule120 #-}
rule120 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule121 #-}
rule121 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule122 #-}
rule122 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule123 #-}
rule123 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule124 #-}
rule124 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
-- Alternatives ------------------------------------------------
-- wrapper
data Inh_Alternatives = Inh_Alternatives { allPatterns_Inh_Alternatives :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Alternatives :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Alternatives :: (Predicates), betaLeft_Inh_Alternatives :: (Tp), betaRight_Inh_Alternatives :: (Tp), betaUnique_Inh_Alternatives :: (Int), classEnvironment_Inh_Alternatives :: (ClassEnvironment), collectErrors_Inh_Alternatives :: (TypeErrors), collectWarnings_Inh_Alternatives :: (Warnings), counter_Inh_Alternatives :: (Int), currentChunk_Inh_Alternatives :: (Int), dictionaryEnvironment_Inh_Alternatives :: (DictionaryEnvironment), importEnvironment_Inh_Alternatives :: (ImportEnvironment), matchIO_Inh_Alternatives :: (IO ()), monos_Inh_Alternatives :: (Monos), namesInScope_Inh_Alternatives :: (Names), orderedTypeSynonyms_Inh_Alternatives :: (OrderedTypeSynonyms), parentTree_Inh_Alternatives :: (InfoTree), patternMatchWarnings_Inh_Alternatives :: ([Warning]), substitution_Inh_Alternatives :: (FixpointSubstitution), typeschemeMap_Inh_Alternatives :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Alternatives :: (Int) }
data Syn_Alternatives = Syn_Alternatives { assumptions_Syn_Alternatives :: (Assumptions), betaUnique_Syn_Alternatives :: (Int), collectErrors_Syn_Alternatives :: (TypeErrors), collectInstances_Syn_Alternatives :: ([(Name, Instance)]), collectWarnings_Syn_Alternatives :: (Warnings), constraintslist_Syn_Alternatives :: (ConstraintSets), counter_Syn_Alternatives :: (Int), dictionaryEnvironment_Syn_Alternatives :: (DictionaryEnvironment), elementss_Syn_Alternatives :: ([([PatternElement], Bool)]), infoTrees_Syn_Alternatives :: (InfoTrees), matchIO_Syn_Alternatives :: (IO ()), patternMatchWarnings_Syn_Alternatives :: ([Warning]), self_Syn_Alternatives :: (Alternatives), unboundNames_Syn_Alternatives :: (Names), uniqueChunk_Syn_Alternatives :: (Int), unrwars_Syn_Alternatives :: ([Warning]) }
{-# INLINABLE wrap_Alternatives #-}
wrap_Alternatives :: T_Alternatives -> Inh_Alternatives -> (Syn_Alternatives )
wrap_Alternatives (T_Alternatives act) (Inh_Alternatives _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Alternatives_vIn4 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
(T_Alternatives_vOut4 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars) <- return (inv_Alternatives_s5 sem arg)
return (Syn_Alternatives _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars)
)
-- cata
{-# NOINLINE sem_Alternatives #-}
sem_Alternatives :: Alternatives -> T_Alternatives
sem_Alternatives list = Prelude.foldr sem_Alternatives_Cons sem_Alternatives_Nil (Prelude.map sem_Alternative list)
-- semantic domain
newtype T_Alternatives = T_Alternatives {
attach_T_Alternatives :: Identity (T_Alternatives_s5 )
}
newtype T_Alternatives_s5 = C_Alternatives_s5 {
inv_Alternatives_s5 :: (T_Alternatives_v4 )
}
data T_Alternatives_s6 = C_Alternatives_s6
type T_Alternatives_v4 = (T_Alternatives_vIn4 ) -> (T_Alternatives_vOut4 )
data T_Alternatives_vIn4 = T_Alternatives_vIn4 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Tp) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_Alternatives_vOut4 = T_Alternatives_vOut4 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSets) (Int) (DictionaryEnvironment) ([([PatternElement], Bool)]) (InfoTrees) (IO ()) ([Warning]) (Alternatives) (Names) (Int) ([Warning])
{-# NOINLINE sem_Alternatives_Cons #-}
sem_Alternatives_Cons :: T_Alternative -> T_Alternatives -> T_Alternatives
sem_Alternatives_Cons arg_hd_ arg_tl_ = T_Alternatives (return st5) where
{-# NOINLINE st5 #-}
st5 = let
v4 :: T_Alternatives_v4
v4 = \ (T_Alternatives_vIn4 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_hdX2 = Control.Monad.Identity.runIdentity (attach_T_Alternative (arg_hd_))
_tlX5 = Control.Monad.Identity.runIdentity (attach_T_Alternatives (arg_tl_))
(T_Alternative_vOut1 _hdIassumptions _hdIbetaUnique _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIconstraints _hdIcounter _hdIdictionaryEnvironment _hdIelements _hdIinfoTrees _hdImatchIO _hdIpatternMatchWarnings _hdIself _hdIunboundNames _hdIuniqueChunk _hdIunrwar) = inv_Alternative_s2 _hdX2 (T_Alternative_vIn1 _hdOallPatterns _hdOallTypeSchemes _hdOavailablePredicates _hdObetaLeft _hdObetaRight _hdObetaUnique _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeschemeMap _hdOuniqueChunk)
(T_Alternatives_vOut4 _tlIassumptions _tlIbetaUnique _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIconstraintslist _tlIcounter _tlIdictionaryEnvironment _tlIelementss _tlIinfoTrees _tlImatchIO _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk _tlIunrwars) = inv_Alternatives_s5 _tlX5 (T_Alternatives_vIn4 _tlOallPatterns _tlOallTypeSchemes _tlOavailablePredicates _tlObetaLeft _tlObetaRight _tlObetaUnique _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeschemeMap _tlOuniqueChunk)
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule125 _hdIassumptions _tlIassumptions
_lhsOconstraintslist :: ConstraintSets
_lhsOconstraintslist = rule126 _hdIconstraints _tlIconstraintslist
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule127 _hdIinfoTrees _tlIinfoTrees
_lhsOelementss :: [([PatternElement], Bool)]
_lhsOelementss = rule128 _hdIelements _tlIelementss
_lhsOunrwars :: [Warning]
_lhsOunrwars = rule129 _hdIunrwar _tlIunrwars
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule130 _hdIcollectInstances _tlIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule131 _hdIunboundNames _tlIunboundNames
_self = rule132 _hdIself _tlIself
_lhsOself :: Alternatives
_lhsOself = rule133 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule134 _tlIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule135 _tlIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule136 _tlIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule137 _tlIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule138 _tlIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule139 _tlImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule140 _tlIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule141 _tlIuniqueChunk
_hdOallPatterns = rule142 _lhsIallPatterns
_hdOallTypeSchemes = rule143 _lhsIallTypeSchemes
_hdOavailablePredicates = rule144 _lhsIavailablePredicates
_hdObetaLeft = rule145 _lhsIbetaLeft
_hdObetaRight = rule146 _lhsIbetaRight
_hdObetaUnique = rule147 _lhsIbetaUnique
_hdOclassEnvironment = rule148 _lhsIclassEnvironment
_hdOcollectErrors = rule149 _lhsIcollectErrors
_hdOcollectWarnings = rule150 _lhsIcollectWarnings
_hdOcounter = rule151 _lhsIcounter
_hdOcurrentChunk = rule152 _lhsIcurrentChunk
_hdOdictionaryEnvironment = rule153 _lhsIdictionaryEnvironment
_hdOimportEnvironment = rule154 _lhsIimportEnvironment
_hdOmatchIO = rule155 _lhsImatchIO
_hdOmonos = rule156 _lhsImonos
_hdOnamesInScope = rule157 _lhsInamesInScope
_hdOorderedTypeSynonyms = rule158 _lhsIorderedTypeSynonyms
_hdOparentTree = rule159 _lhsIparentTree
_hdOpatternMatchWarnings = rule160 _lhsIpatternMatchWarnings
_hdOsubstitution = rule161 _lhsIsubstitution
_hdOtypeschemeMap = rule162 _lhsItypeschemeMap
_hdOuniqueChunk = rule163 _lhsIuniqueChunk
_tlOallPatterns = rule164 _lhsIallPatterns
_tlOallTypeSchemes = rule165 _lhsIallTypeSchemes
_tlOavailablePredicates = rule166 _lhsIavailablePredicates
_tlObetaLeft = rule167 _lhsIbetaLeft
_tlObetaRight = rule168 _lhsIbetaRight
_tlObetaUnique = rule169 _hdIbetaUnique
_tlOclassEnvironment = rule170 _lhsIclassEnvironment
_tlOcollectErrors = rule171 _hdIcollectErrors
_tlOcollectWarnings = rule172 _hdIcollectWarnings
_tlOcounter = rule173 _hdIcounter
_tlOcurrentChunk = rule174 _lhsIcurrentChunk
_tlOdictionaryEnvironment = rule175 _hdIdictionaryEnvironment
_tlOimportEnvironment = rule176 _lhsIimportEnvironment
_tlOmatchIO = rule177 _hdImatchIO
_tlOmonos = rule178 _lhsImonos
_tlOnamesInScope = rule179 _lhsInamesInScope
_tlOorderedTypeSynonyms = rule180 _lhsIorderedTypeSynonyms
_tlOparentTree = rule181 _lhsIparentTree
_tlOpatternMatchWarnings = rule182 _hdIpatternMatchWarnings
_tlOsubstitution = rule183 _lhsIsubstitution
_tlOtypeschemeMap = rule184 _lhsItypeschemeMap
_tlOuniqueChunk = rule185 _hdIuniqueChunk
__result_ = T_Alternatives_vOut4 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars
in __result_ )
in C_Alternatives_s5 v4
{-# INLINE rule125 #-}
rule125 = \ ((_hdIassumptions) :: Assumptions) ((_tlIassumptions) :: Assumptions) ->
_hdIassumptions `combine` _tlIassumptions
{-# INLINE rule126 #-}
rule126 = \ ((_hdIconstraints) :: ConstraintSet) ((_tlIconstraintslist) :: ConstraintSets) ->
_hdIconstraints : _tlIconstraintslist
{-# INLINE rule127 #-}
rule127 = \ ((_hdIinfoTrees) :: InfoTrees) ((_tlIinfoTrees) :: InfoTrees) ->
_hdIinfoTrees ++ _tlIinfoTrees
{-# INLINE rule128 #-}
rule128 = \ ((_hdIelements) :: ([PatternElement], Bool) ) ((_tlIelementss) :: [([PatternElement], Bool)]) ->
_hdIelements : _tlIelementss
{-# INLINE rule129 #-}
rule129 = \ ((_hdIunrwar) :: Warning) ((_tlIunrwars) :: [Warning]) ->
_hdIunrwar : _tlIunrwars
{-# INLINE rule130 #-}
rule130 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
_hdIcollectInstances ++ _tlIcollectInstances
{-# INLINE rule131 #-}
rule131 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
_hdIunboundNames ++ _tlIunboundNames
{-# INLINE rule132 #-}
rule132 = \ ((_hdIself) :: Alternative) ((_tlIself) :: Alternatives) ->
(:) _hdIself _tlIself
{-# INLINE rule133 #-}
rule133 = \ _self ->
_self
{-# INLINE rule134 #-}
rule134 = \ ((_tlIbetaUnique) :: Int) ->
_tlIbetaUnique
{-# INLINE rule135 #-}
rule135 = \ ((_tlIcollectErrors) :: TypeErrors) ->
_tlIcollectErrors
{-# INLINE rule136 #-}
rule136 = \ ((_tlIcollectWarnings) :: Warnings) ->
_tlIcollectWarnings
{-# INLINE rule137 #-}
rule137 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule138 #-}
rule138 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
_tlIdictionaryEnvironment
{-# INLINE rule139 #-}
rule139 = \ ((_tlImatchIO) :: IO ()) ->
_tlImatchIO
{-# INLINE rule140 #-}
rule140 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
_tlIpatternMatchWarnings
{-# INLINE rule141 #-}
rule141 = \ ((_tlIuniqueChunk) :: Int) ->
_tlIuniqueChunk
{-# INLINE rule142 #-}
rule142 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule143 #-}
rule143 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule144 #-}
rule144 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule145 #-}
rule145 = \ ((_lhsIbetaLeft) :: Tp) ->
_lhsIbetaLeft
{-# INLINE rule146 #-}
rule146 = \ ((_lhsIbetaRight) :: Tp) ->
_lhsIbetaRight
{-# INLINE rule147 #-}
rule147 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule148 #-}
rule148 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule149 #-}
rule149 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule150 #-}
rule150 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule151 #-}
rule151 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule152 #-}
rule152 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule153 #-}
rule153 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule154 #-}
rule154 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule155 #-}
rule155 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule156 #-}
rule156 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule157 #-}
rule157 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule158 #-}
rule158 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule159 #-}
rule159 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule160 #-}
rule160 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule161 #-}
rule161 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule162 #-}
rule162 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule163 #-}
rule163 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule164 #-}
rule164 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule165 #-}
rule165 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule166 #-}
rule166 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule167 #-}
rule167 = \ ((_lhsIbetaLeft) :: Tp) ->
_lhsIbetaLeft
{-# INLINE rule168 #-}
rule168 = \ ((_lhsIbetaRight) :: Tp) ->
_lhsIbetaRight
{-# INLINE rule169 #-}
rule169 = \ ((_hdIbetaUnique) :: Int) ->
_hdIbetaUnique
{-# INLINE rule170 #-}
rule170 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule171 #-}
rule171 = \ ((_hdIcollectErrors) :: TypeErrors) ->
_hdIcollectErrors
{-# INLINE rule172 #-}
rule172 = \ ((_hdIcollectWarnings) :: Warnings) ->
_hdIcollectWarnings
{-# INLINE rule173 #-}
rule173 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule174 #-}
rule174 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule175 #-}
rule175 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
_hdIdictionaryEnvironment
{-# INLINE rule176 #-}
rule176 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule177 #-}
rule177 = \ ((_hdImatchIO) :: IO ()) ->
_hdImatchIO
{-# INLINE rule178 #-}
rule178 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule179 #-}
rule179 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule180 #-}
rule180 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule181 #-}
rule181 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule182 #-}
rule182 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
_hdIpatternMatchWarnings
{-# INLINE rule183 #-}
rule183 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule184 #-}
rule184 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule185 #-}
rule185 = \ ((_hdIuniqueChunk) :: Int) ->
_hdIuniqueChunk
{-# NOINLINE sem_Alternatives_Nil #-}
sem_Alternatives_Nil :: T_Alternatives
sem_Alternatives_Nil = T_Alternatives (return st5) where
{-# NOINLINE st5 #-}
st5 = let
v4 :: T_Alternatives_v4
v4 = \ (T_Alternatives_vIn4 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule186 ()
_lhsOconstraintslist :: ConstraintSets
_lhsOconstraintslist = rule187 ()
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule188 ()
_lhsOelementss :: [([PatternElement], Bool)]
_lhsOelementss = rule189 ()
_lhsOunrwars :: [Warning]
_lhsOunrwars = rule190 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule191 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule192 ()
_self = rule193 ()
_lhsOself :: Alternatives
_lhsOself = rule194 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule195 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule196 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule197 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule198 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule199 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule200 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule201 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule202 _lhsIuniqueChunk
__result_ = T_Alternatives_vOut4 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars
in __result_ )
in C_Alternatives_s5 v4
{-# INLINE rule186 #-}
rule186 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule187 #-}
rule187 = \ (_ :: ()) ->
[]
{-# INLINE rule188 #-}
rule188 = \ (_ :: ()) ->
[]
{-# INLINE rule189 #-}
rule189 = \ (_ :: ()) ->
[]
{-# INLINE rule190 #-}
rule190 = \ (_ :: ()) ->
[]
{-# INLINE rule191 #-}
rule191 = \ (_ :: ()) ->
[]
{-# INLINE rule192 #-}
rule192 = \ (_ :: ()) ->
[]
{-# INLINE rule193 #-}
rule193 = \ (_ :: ()) ->
[]
{-# INLINE rule194 #-}
rule194 = \ _self ->
_self
{-# INLINE rule195 #-}
rule195 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule196 #-}
rule196 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule197 #-}
rule197 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule198 #-}
rule198 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule199 #-}
rule199 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule200 #-}
rule200 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule201 #-}
rule201 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule202 #-}
rule202 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
-- AnnotatedType -----------------------------------------------
-- wrapper
data Inh_AnnotatedType = Inh_AnnotatedType { counter_Inh_AnnotatedType :: (Int), namesInScope_Inh_AnnotatedType :: (Names) }
data Syn_AnnotatedType = Syn_AnnotatedType { counter_Syn_AnnotatedType :: (Int), self_Syn_AnnotatedType :: (AnnotatedType), unboundNames_Syn_AnnotatedType :: (Names) }
{-# INLINABLE wrap_AnnotatedType #-}
wrap_AnnotatedType :: T_AnnotatedType -> Inh_AnnotatedType -> (Syn_AnnotatedType )
wrap_AnnotatedType (T_AnnotatedType act) (Inh_AnnotatedType _lhsIcounter _lhsInamesInScope) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_AnnotatedType_vIn7 _lhsIcounter _lhsInamesInScope
(T_AnnotatedType_vOut7 _lhsOcounter _lhsOself _lhsOunboundNames) <- return (inv_AnnotatedType_s8 sem arg)
return (Syn_AnnotatedType _lhsOcounter _lhsOself _lhsOunboundNames)
)
-- cata
{-# INLINE sem_AnnotatedType #-}
sem_AnnotatedType :: AnnotatedType -> T_AnnotatedType
sem_AnnotatedType ( AnnotatedType_AnnotatedType range_ strict_ type_ ) = sem_AnnotatedType_AnnotatedType ( sem_Range range_ ) strict_ ( sem_Type type_ )
-- semantic domain
newtype T_AnnotatedType = T_AnnotatedType {
attach_T_AnnotatedType :: Identity (T_AnnotatedType_s8 )
}
newtype T_AnnotatedType_s8 = C_AnnotatedType_s8 {
inv_AnnotatedType_s8 :: (T_AnnotatedType_v7 )
}
data T_AnnotatedType_s9 = C_AnnotatedType_s9
type T_AnnotatedType_v7 = (T_AnnotatedType_vIn7 ) -> (T_AnnotatedType_vOut7 )
data T_AnnotatedType_vIn7 = T_AnnotatedType_vIn7 (Int) (Names)
data T_AnnotatedType_vOut7 = T_AnnotatedType_vOut7 (Int) (AnnotatedType) (Names)
{-# NOINLINE sem_AnnotatedType_AnnotatedType #-}
sem_AnnotatedType_AnnotatedType :: T_Range -> (Bool) -> T_Type -> T_AnnotatedType
sem_AnnotatedType_AnnotatedType arg_range_ arg_strict_ arg_type_ = T_AnnotatedType (return st8) where
{-# NOINLINE st8 #-}
st8 = let
v7 :: T_AnnotatedType_v7
v7 = \ (T_AnnotatedType_vIn7 _lhsIcounter _lhsInamesInScope) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
_lhsOunboundNames :: Names
_lhsOunboundNames = rule203 ()
_self = rule204 _rangeIself _typeIself arg_strict_
_lhsOself :: AnnotatedType
_lhsOself = rule205 _self
_lhsOcounter :: Int
_lhsOcounter = rule206 _lhsIcounter
__result_ = T_AnnotatedType_vOut7 _lhsOcounter _lhsOself _lhsOunboundNames
in __result_ )
in C_AnnotatedType_s8 v7
{-# INLINE rule203 #-}
rule203 = \ (_ :: ()) ->
[]
{-# INLINE rule204 #-}
rule204 = \ ((_rangeIself) :: Range) ((_typeIself) :: Type) strict_ ->
AnnotatedType_AnnotatedType _rangeIself strict_ _typeIself
{-# INLINE rule205 #-}
rule205 = \ _self ->
_self
{-# INLINE rule206 #-}
rule206 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
-- AnnotatedTypes ----------------------------------------------
-- wrapper
data Inh_AnnotatedTypes = Inh_AnnotatedTypes { counter_Inh_AnnotatedTypes :: (Int), namesInScope_Inh_AnnotatedTypes :: (Names) }
data Syn_AnnotatedTypes = Syn_AnnotatedTypes { counter_Syn_AnnotatedTypes :: (Int), self_Syn_AnnotatedTypes :: (AnnotatedTypes), unboundNames_Syn_AnnotatedTypes :: (Names) }
{-# INLINABLE wrap_AnnotatedTypes #-}
wrap_AnnotatedTypes :: T_AnnotatedTypes -> Inh_AnnotatedTypes -> (Syn_AnnotatedTypes )
wrap_AnnotatedTypes (T_AnnotatedTypes act) (Inh_AnnotatedTypes _lhsIcounter _lhsInamesInScope) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_AnnotatedTypes_vIn10 _lhsIcounter _lhsInamesInScope
(T_AnnotatedTypes_vOut10 _lhsOcounter _lhsOself _lhsOunboundNames) <- return (inv_AnnotatedTypes_s11 sem arg)
return (Syn_AnnotatedTypes _lhsOcounter _lhsOself _lhsOunboundNames)
)
-- cata
{-# NOINLINE sem_AnnotatedTypes #-}
sem_AnnotatedTypes :: AnnotatedTypes -> T_AnnotatedTypes
sem_AnnotatedTypes list = Prelude.foldr sem_AnnotatedTypes_Cons sem_AnnotatedTypes_Nil (Prelude.map sem_AnnotatedType list)
-- semantic domain
newtype T_AnnotatedTypes = T_AnnotatedTypes {
attach_T_AnnotatedTypes :: Identity (T_AnnotatedTypes_s11 )
}
newtype T_AnnotatedTypes_s11 = C_AnnotatedTypes_s11 {
inv_AnnotatedTypes_s11 :: (T_AnnotatedTypes_v10 )
}
data T_AnnotatedTypes_s12 = C_AnnotatedTypes_s12
type T_AnnotatedTypes_v10 = (T_AnnotatedTypes_vIn10 ) -> (T_AnnotatedTypes_vOut10 )
data T_AnnotatedTypes_vIn10 = T_AnnotatedTypes_vIn10 (Int) (Names)
data T_AnnotatedTypes_vOut10 = T_AnnotatedTypes_vOut10 (Int) (AnnotatedTypes) (Names)
{-# NOINLINE sem_AnnotatedTypes_Cons #-}
sem_AnnotatedTypes_Cons :: T_AnnotatedType -> T_AnnotatedTypes -> T_AnnotatedTypes
sem_AnnotatedTypes_Cons arg_hd_ arg_tl_ = T_AnnotatedTypes (return st11) where
{-# NOINLINE st11 #-}
st11 = let
v10 :: T_AnnotatedTypes_v10
v10 = \ (T_AnnotatedTypes_vIn10 _lhsIcounter _lhsInamesInScope) -> ( let
_hdX8 = Control.Monad.Identity.runIdentity (attach_T_AnnotatedType (arg_hd_))
_tlX11 = Control.Monad.Identity.runIdentity (attach_T_AnnotatedTypes (arg_tl_))
(T_AnnotatedType_vOut7 _hdIcounter _hdIself _hdIunboundNames) = inv_AnnotatedType_s8 _hdX8 (T_AnnotatedType_vIn7 _hdOcounter _hdOnamesInScope)
(T_AnnotatedTypes_vOut10 _tlIcounter _tlIself _tlIunboundNames) = inv_AnnotatedTypes_s11 _tlX11 (T_AnnotatedTypes_vIn10 _tlOcounter _tlOnamesInScope)
_lhsOunboundNames :: Names
_lhsOunboundNames = rule207 _hdIunboundNames _tlIunboundNames
_self = rule208 _hdIself _tlIself
_lhsOself :: AnnotatedTypes
_lhsOself = rule209 _self
_lhsOcounter :: Int
_lhsOcounter = rule210 _tlIcounter
_hdOcounter = rule211 _lhsIcounter
_hdOnamesInScope = rule212 _lhsInamesInScope
_tlOcounter = rule213 _hdIcounter
_tlOnamesInScope = rule214 _lhsInamesInScope
__result_ = T_AnnotatedTypes_vOut10 _lhsOcounter _lhsOself _lhsOunboundNames
in __result_ )
in C_AnnotatedTypes_s11 v10
{-# INLINE rule207 #-}
rule207 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
_hdIunboundNames ++ _tlIunboundNames
{-# INLINE rule208 #-}
rule208 = \ ((_hdIself) :: AnnotatedType) ((_tlIself) :: AnnotatedTypes) ->
(:) _hdIself _tlIself
{-# INLINE rule209 #-}
rule209 = \ _self ->
_self
{-# INLINE rule210 #-}
rule210 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule211 #-}
rule211 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule212 #-}
rule212 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule213 #-}
rule213 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule214 #-}
rule214 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# NOINLINE sem_AnnotatedTypes_Nil #-}
sem_AnnotatedTypes_Nil :: T_AnnotatedTypes
sem_AnnotatedTypes_Nil = T_AnnotatedTypes (return st11) where
{-# NOINLINE st11 #-}
st11 = let
v10 :: T_AnnotatedTypes_v10
v10 = \ (T_AnnotatedTypes_vIn10 _lhsIcounter _lhsInamesInScope) -> ( let
_lhsOunboundNames :: Names
_lhsOunboundNames = rule215 ()
_self = rule216 ()
_lhsOself :: AnnotatedTypes
_lhsOself = rule217 _self
_lhsOcounter :: Int
_lhsOcounter = rule218 _lhsIcounter
__result_ = T_AnnotatedTypes_vOut10 _lhsOcounter _lhsOself _lhsOunboundNames
in __result_ )
in C_AnnotatedTypes_s11 v10
{-# INLINE rule215 #-}
rule215 = \ (_ :: ()) ->
[]
{-# INLINE rule216 #-}
rule216 = \ (_ :: ()) ->
[]
{-# INLINE rule217 #-}
rule217 = \ _self ->
_self
{-# INLINE rule218 #-}
rule218 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
-- Body --------------------------------------------------------
-- wrapper
data Inh_Body = Inh_Body { allPatterns_Inh_Body :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Body :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Body :: (Predicates), betaUnique_Inh_Body :: (Int), classEnvironment_Inh_Body :: (ClassEnvironment), collectErrors_Inh_Body :: (TypeErrors), collectWarnings_Inh_Body :: (Warnings), counter_Inh_Body :: (Int), currentChunk_Inh_Body :: (Int), dictionaryEnvironment_Inh_Body :: (DictionaryEnvironment), importEnvironment_Inh_Body :: (ImportEnvironment), matchIO_Inh_Body :: (IO ()), monos_Inh_Body :: (Monos), namesInScope_Inh_Body :: (Names), orderedTypeSynonyms_Inh_Body :: (OrderedTypeSynonyms), patternMatchWarnings_Inh_Body :: ([Warning]), substitution_Inh_Body :: (FixpointSubstitution), typeschemeMap_Inh_Body :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Body :: (Int) }
data Syn_Body = Syn_Body { assumptions_Syn_Body :: (Assumptions), betaUnique_Syn_Body :: (Int), collectErrors_Syn_Body :: (TypeErrors), collectInstances_Syn_Body :: ([(Name, Instance)]), collectWarnings_Syn_Body :: (Warnings), constraints_Syn_Body :: (ConstraintSet), counter_Syn_Body :: (Int), declVarNames_Syn_Body :: (Names), dictionaryEnvironment_Syn_Body :: (DictionaryEnvironment), infoTree_Syn_Body :: (InfoTree), matchIO_Syn_Body :: (IO ()), patternMatchWarnings_Syn_Body :: ([Warning]), self_Syn_Body :: (Body), toplevelTypes_Syn_Body :: (TypeEnvironment), unboundNames_Syn_Body :: (Names), uniqueChunk_Syn_Body :: (Int) }
{-# INLINABLE wrap_Body #-}
wrap_Body :: T_Body -> Inh_Body -> (Syn_Body )
wrap_Body (T_Body act) (Inh_Body _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Body_vIn13 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
(T_Body_vOut13 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOtoplevelTypes _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_Body_s14 sem arg)
return (Syn_Body _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOtoplevelTypes _lhsOunboundNames _lhsOuniqueChunk)
)
-- cata
{-# NOINLINE sem_Body #-}
sem_Body :: Body -> T_Body
sem_Body ( Body_Hole range_ id_ ) = sem_Body_Hole ( sem_Range range_ ) id_
sem_Body ( Body_Body range_ importdeclarations_ declarations_ ) = sem_Body_Body ( sem_Range range_ ) ( sem_ImportDeclarations importdeclarations_ ) ( sem_Declarations declarations_ )
-- semantic domain
newtype T_Body = T_Body {
attach_T_Body :: Identity (T_Body_s14 )
}
newtype T_Body_s14 = C_Body_s14 {
inv_Body_s14 :: (T_Body_v13 )
}
data T_Body_s15 = C_Body_s15
type T_Body_v13 = (T_Body_vIn13 ) -> (T_Body_vOut13 )
data T_Body_vIn13 = T_Body_vIn13 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_Body_vOut13 = T_Body_vOut13 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (Names) (DictionaryEnvironment) (InfoTree) (IO ()) ([Warning]) (Body) (TypeEnvironment) (Names) (Int)
{-# NOINLINE sem_Body_Hole #-}
sem_Body_Hole :: T_Range -> (Integer) -> T_Body
sem_Body_Hole arg_range_ arg_id_ = T_Body (return st14) where
{-# NOINLINE st14 #-}
st14 = let
v13 :: T_Body_v13
v13 = \ (T_Body_vIn13 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule219 ()
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule220 ()
_lhsOtoplevelTypes :: TypeEnvironment
_lhsOtoplevelTypes = rule221 ()
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule222 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule223 ()
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule224 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule225 ()
_self = rule226 _rangeIself arg_id_
_lhsOself :: Body
_lhsOself = rule227 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule228 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule229 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule230 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule231 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule232 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule233 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule234 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule235 _lhsIuniqueChunk
__result_ = T_Body_vOut13 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOtoplevelTypes _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Body_s14 v13
{-# INLINE rule219 #-}
rule219 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule220 #-}
rule220 = \ (_ :: ()) ->
emptyTree
{-# INLINE rule221 #-}
rule221 = \ (_ :: ()) ->
M.empty
{-# INLINE rule222 #-}
rule222 = \ (_ :: ()) ->
root (LocalInfo {self = UHA_Decls [], assignedType = Nothing, monos = []}) []
{-# INLINE rule223 #-}
rule223 = \ (_ :: ()) ->
[]
{-# INLINE rule224 #-}
rule224 = \ (_ :: ()) ->
[]
{-# INLINE rule225 #-}
rule225 = \ (_ :: ()) ->
[]
{-# INLINE rule226 #-}
rule226 = \ ((_rangeIself) :: Range) id_ ->
Body_Hole _rangeIself id_
{-# INLINE rule227 #-}
rule227 = \ _self ->
_self
{-# INLINE rule228 #-}
rule228 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule229 #-}
rule229 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule230 #-}
rule230 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule231 #-}
rule231 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule232 #-}
rule232 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule233 #-}
rule233 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule234 #-}
rule234 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule235 #-}
rule235 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Body_Body #-}
sem_Body_Body :: T_Range -> T_ImportDeclarations -> T_Declarations -> T_Body
sem_Body_Body arg_range_ arg_importdeclarations_ arg_declarations_ = T_Body (return st14) where
{-# NOINLINE st14 #-}
st14 = let
v13 :: T_Body_v13
v13 = \ (T_Body_vIn13 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_importdeclarationsX74 = Control.Monad.Identity.runIdentity (attach_T_ImportDeclarations (arg_importdeclarations_))
_declarationsX32 = Control.Monad.Identity.runIdentity (attach_T_Declarations (arg_declarations_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_ImportDeclarations_vOut73 _importdeclarationsIself) = inv_ImportDeclarations_s74 _importdeclarationsX74 (T_ImportDeclarations_vIn73 )
(T_Declarations_vOut31 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsIcollectErrors _declarationsIcollectInstances _declarationsIcollectWarnings _declarationsIcounter _declarationsIdeclVarNames _declarationsIdictionaryEnvironment _declarationsIinfoTrees _declarationsImatchIO _declarationsIpatternMatchWarnings _declarationsIrestrictedNames _declarationsIself _declarationsIsimplePatNames _declarationsItypeSignatures _declarationsIunboundNames _declarationsIuniqueChunk) = inv_Declarations_s32 _declarationsX32 (T_Declarations_vIn31 _declarationsOallPatterns _declarationsOallTypeSchemes _declarationsOavailablePredicates _declarationsObetaUnique _declarationsObindingGroups _declarationsOclassEnvironment _declarationsOcollectErrors _declarationsOcollectWarnings _declarationsOcounter _declarationsOcurrentChunk _declarationsOdictionaryEnvironment _declarationsOimportEnvironment _declarationsOinheritedBDG _declarationsOmatchIO _declarationsOmonos _declarationsOnamesInScope _declarationsOorderedTypeSynonyms _declarationsOparentTree _declarationsOpatternMatchWarnings _declarationsOsubstitution _declarationsOtypeSignatures _declarationsOtypeschemeMap _declarationsOuniqueChunk)
_declarationsObindingGroups = rule236 ()
_lhsOassumptions :: Assumptions
(_csetBinds,_lhsOassumptions) = rule237 _aset _cinfo _lhsIimportEnvironment
_constraints = rule238 _cset _csetBinds
_lhsObetaUnique :: Int
(_aset,_cset,_inheritedBDG,_chunkNr,_lhsObetaUnique,_implicitsFM) = rule239 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsItypeSignatures _declarationsIuniqueChunk _lhsIcurrentChunk _lhsImonos
_inferredTypes = rule240 _implicitsFM _lhsItypeschemeMap
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule241 _declarationsIcollectWarnings _declarationsIsimplePatNames _inferredTypes
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule242 _declarationsIcollectErrors _declarationsIrestrictedNames _inferredTypes
_lhsOtoplevelTypes :: TypeEnvironment
_lhsOtoplevelTypes = rule243 _declarationsItypeSignatures _inferredTypes
_allTypeSchemes = rule244 _lhsIallTypeSchemes _localTypes
_localTypes = rule245 _declarationsIbindingGroups _declarationsItypeSignatures _inferredTypes
_declarationsOtypeSignatures = rule246 ()
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule247 _chunkNr
_cinfo = rule248 ()
_declInfo = rule249 _declarationsIself _lhsImonos
_parentTree = rule250 _declInfo _declarationsIinfoTrees
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule251 _parentTree
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule252 _declarationsIcollectInstances
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule253 _declarationsIdeclVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule254 _declarationsIunboundNames
_self = rule255 _declarationsIself _importdeclarationsIself _rangeIself
_lhsOself :: Body
_lhsOself = rule256 _self
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule257 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule258 _declarationsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule259 _declarationsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule260 _declarationsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule261 _declarationsIpatternMatchWarnings
_declarationsOallPatterns = rule262 _lhsIallPatterns
_declarationsOallTypeSchemes = rule263 _allTypeSchemes
_declarationsOavailablePredicates = rule264 _lhsIavailablePredicates
_declarationsObetaUnique = rule265 _lhsIbetaUnique
_declarationsOclassEnvironment = rule266 _lhsIclassEnvironment
_declarationsOcollectErrors = rule267 _lhsIcollectErrors
_declarationsOcollectWarnings = rule268 _lhsIcollectWarnings
_declarationsOcounter = rule269 _lhsIcounter
_declarationsOcurrentChunk = rule270 _lhsIcurrentChunk
_declarationsOdictionaryEnvironment = rule271 _lhsIdictionaryEnvironment
_declarationsOimportEnvironment = rule272 _lhsIimportEnvironment
_declarationsOinheritedBDG = rule273 _inheritedBDG
_declarationsOmatchIO = rule274 _lhsImatchIO
_declarationsOmonos = rule275 _lhsImonos
_declarationsOnamesInScope = rule276 _lhsInamesInScope
_declarationsOorderedTypeSynonyms = rule277 _lhsIorderedTypeSynonyms
_declarationsOparentTree = rule278 _parentTree
_declarationsOpatternMatchWarnings = rule279 _lhsIpatternMatchWarnings
_declarationsOsubstitution = rule280 _lhsIsubstitution
_declarationsOtypeschemeMap = rule281 _lhsItypeschemeMap
_declarationsOuniqueChunk = rule282 _lhsIuniqueChunk
__result_ = T_Body_vOut13 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOtoplevelTypes _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Body_s14 v13
{-# INLINE rule236 #-}
rule236 = \ (_ :: ()) ->
[]
{-# INLINE rule237 #-}
rule237 = \ _aset _cinfo ((_lhsIimportEnvironment) :: ImportEnvironment) ->
(typeEnvironment _lhsIimportEnvironment .:::. _aset) _cinfo
{-# INLINE rule238 #-}
rule238 = \ _cset _csetBinds ->
_csetBinds .>>. _cset
{-# INLINE rule239 #-}
rule239 = \ ((_declarationsIbetaUnique) :: Int) ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) ((_declarationsIuniqueChunk) :: Int) ((_lhsIcurrentChunk) :: Int) ((_lhsImonos) :: Monos) ->
let inputBDG = (True, _lhsIcurrentChunk, _declarationsIuniqueChunk, _lhsImonos, _declarationsItypeSignatures, Nothing, _declarationsIbetaUnique)
in performBindingGroup inputBDG _declarationsIbindingGroups
{-# INLINE rule240 #-}
rule240 = \ _implicitsFM ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
findInferredTypes _lhsItypeschemeMap _implicitsFM
{-# INLINE rule241 #-}
rule241 = \ ((_declarationsIcollectWarnings) :: Warnings) ((_declarationsIsimplePatNames) :: Names) _inferredTypes ->
missingTypeSignature True _declarationsIsimplePatNames _inferredTypes
++ _declarationsIcollectWarnings
{-# INLINE rule242 #-}
rule242 = \ ((_declarationsIcollectErrors) :: TypeErrors) ((_declarationsIrestrictedNames) :: Names) _inferredTypes ->
restrictedNameErrors _inferredTypes _declarationsIrestrictedNames
++ _declarationsIcollectErrors
{-# INLINE rule243 #-}
rule243 = \ ((_declarationsItypeSignatures) :: TypeEnvironment) _inferredTypes ->
_declarationsItypeSignatures `M.union` _inferredTypes
{-# INLINE rule244 #-}
rule244 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) _localTypes ->
_localTypes `M.union` _lhsIallTypeSchemes
{-# INLINE rule245 #-}
rule245 = \ ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) _inferredTypes ->
makeLocalTypeEnv (_declarationsItypeSignatures `M.union` _inferredTypes) _declarationsIbindingGroups
{-# INLINE rule246 #-}
rule246 = \ (_ :: ()) ->
M.empty
{-# INLINE rule247 #-}
rule247 = \ _chunkNr ->
_chunkNr
{-# INLINE rule248 #-}
rule248 = \ (_ :: ()) ->
\name -> variableConstraint "variable" (nameToUHA_Expr name)
[ FolkloreConstraint, HasTrustFactor 10.0, IsImported name ]
{-# INLINE rule249 #-}
rule249 = \ ((_declarationsIself) :: Declarations) ((_lhsImonos) :: Monos) ->
LocalInfo { self = UHA_Decls _declarationsIself
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule250 #-}
rule250 = \ _declInfo ((_declarationsIinfoTrees) :: InfoTrees) ->
root _declInfo _declarationsIinfoTrees
{-# INLINE rule251 #-}
rule251 = \ _parentTree ->
_parentTree
{-# INLINE rule252 #-}
rule252 = \ ((_declarationsIcollectInstances) :: [(Name, Instance)]) ->
_declarationsIcollectInstances
{-# INLINE rule253 #-}
rule253 = \ ((_declarationsIdeclVarNames) :: Names) ->
_declarationsIdeclVarNames
{-# INLINE rule254 #-}
rule254 = \ ((_declarationsIunboundNames) :: Names) ->
_declarationsIunboundNames
{-# INLINE rule255 #-}
rule255 = \ ((_declarationsIself) :: Declarations) ((_importdeclarationsIself) :: ImportDeclarations) ((_rangeIself) :: Range) ->
Body_Body _rangeIself _importdeclarationsIself _declarationsIself
{-# INLINE rule256 #-}
rule256 = \ _self ->
_self
{-# INLINE rule257 #-}
rule257 = \ _constraints ->
_constraints
{-# INLINE rule258 #-}
rule258 = \ ((_declarationsIcounter) :: Int) ->
_declarationsIcounter
{-# INLINE rule259 #-}
rule259 = \ ((_declarationsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_declarationsIdictionaryEnvironment
{-# INLINE rule260 #-}
rule260 = \ ((_declarationsImatchIO) :: IO ()) ->
_declarationsImatchIO
{-# INLINE rule261 #-}
rule261 = \ ((_declarationsIpatternMatchWarnings) :: [Warning]) ->
_declarationsIpatternMatchWarnings
{-# INLINE rule262 #-}
rule262 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule263 #-}
rule263 = \ _allTypeSchemes ->
_allTypeSchemes
{-# INLINE rule264 #-}
rule264 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule265 #-}
rule265 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule266 #-}
rule266 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule267 #-}
rule267 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule268 #-}
rule268 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule269 #-}
rule269 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule270 #-}
rule270 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule271 #-}
rule271 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule272 #-}
rule272 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule273 #-}
rule273 = \ _inheritedBDG ->
_inheritedBDG
{-# INLINE rule274 #-}
rule274 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule275 #-}
rule275 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule276 #-}
rule276 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule277 #-}
rule277 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule278 #-}
rule278 = \ _parentTree ->
_parentTree
{-# INLINE rule279 #-}
rule279 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule280 #-}
rule280 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule281 #-}
rule281 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule282 #-}
rule282 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
-- Constructor -------------------------------------------------
-- wrapper
data Inh_Constructor = Inh_Constructor { counter_Inh_Constructor :: (Int), namesInScope_Inh_Constructor :: (Names) }
data Syn_Constructor = Syn_Constructor { counter_Syn_Constructor :: (Int), self_Syn_Constructor :: (Constructor), unboundNames_Syn_Constructor :: (Names) }
{-# INLINABLE wrap_Constructor #-}
wrap_Constructor :: T_Constructor -> Inh_Constructor -> (Syn_Constructor )
wrap_Constructor (T_Constructor act) (Inh_Constructor _lhsIcounter _lhsInamesInScope) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Constructor_vIn16 _lhsIcounter _lhsInamesInScope
(T_Constructor_vOut16 _lhsOcounter _lhsOself _lhsOunboundNames) <- return (inv_Constructor_s17 sem arg)
return (Syn_Constructor _lhsOcounter _lhsOself _lhsOunboundNames)
)
-- cata
{-# NOINLINE sem_Constructor #-}
sem_Constructor :: Constructor -> T_Constructor
sem_Constructor ( Constructor_Constructor range_ constructor_ types_ ) = sem_Constructor_Constructor ( sem_Range range_ ) ( sem_Name constructor_ ) ( sem_AnnotatedTypes types_ )
sem_Constructor ( Constructor_Infix range_ leftType_ constructorOperator_ rightType_ ) = sem_Constructor_Infix ( sem_Range range_ ) ( sem_AnnotatedType leftType_ ) ( sem_Name constructorOperator_ ) ( sem_AnnotatedType rightType_ )
sem_Constructor ( Constructor_Record range_ constructor_ fieldDeclarations_ ) = sem_Constructor_Record ( sem_Range range_ ) ( sem_Name constructor_ ) ( sem_FieldDeclarations fieldDeclarations_ )
-- semantic domain
newtype T_Constructor = T_Constructor {
attach_T_Constructor :: Identity (T_Constructor_s17 )
}
newtype T_Constructor_s17 = C_Constructor_s17 {
inv_Constructor_s17 :: (T_Constructor_v16 )
}
data T_Constructor_s18 = C_Constructor_s18
type T_Constructor_v16 = (T_Constructor_vIn16 ) -> (T_Constructor_vOut16 )
data T_Constructor_vIn16 = T_Constructor_vIn16 (Int) (Names)
data T_Constructor_vOut16 = T_Constructor_vOut16 (Int) (Constructor) (Names)
{-# NOINLINE sem_Constructor_Constructor #-}
sem_Constructor_Constructor :: T_Range -> T_Name -> T_AnnotatedTypes -> T_Constructor
sem_Constructor_Constructor arg_range_ arg_constructor_ arg_types_ = T_Constructor (return st17) where
{-# NOINLINE st17 #-}
st17 = let
v16 :: T_Constructor_v16
v16 = \ (T_Constructor_vIn16 _lhsIcounter _lhsInamesInScope) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_constructorX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_constructor_))
_typesX11 = Control.Monad.Identity.runIdentity (attach_T_AnnotatedTypes (arg_types_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _constructorIself) = inv_Name_s113 _constructorX113 (T_Name_vIn112 )
(T_AnnotatedTypes_vOut10 _typesIcounter _typesIself _typesIunboundNames) = inv_AnnotatedTypes_s11 _typesX11 (T_AnnotatedTypes_vIn10 _typesOcounter _typesOnamesInScope)
_lhsOunboundNames :: Names
_lhsOunboundNames = rule283 _typesIunboundNames
_self = rule284 _constructorIself _rangeIself _typesIself
_lhsOself :: Constructor
_lhsOself = rule285 _self
_lhsOcounter :: Int
_lhsOcounter = rule286 _typesIcounter
_typesOcounter = rule287 _lhsIcounter
_typesOnamesInScope = rule288 _lhsInamesInScope
__result_ = T_Constructor_vOut16 _lhsOcounter _lhsOself _lhsOunboundNames
in __result_ )
in C_Constructor_s17 v16
{-# INLINE rule283 #-}
rule283 = \ ((_typesIunboundNames) :: Names) ->
_typesIunboundNames
{-# INLINE rule284 #-}
rule284 = \ ((_constructorIself) :: Name) ((_rangeIself) :: Range) ((_typesIself) :: AnnotatedTypes) ->
Constructor_Constructor _rangeIself _constructorIself _typesIself
{-# INLINE rule285 #-}
rule285 = \ _self ->
_self
{-# INLINE rule286 #-}
rule286 = \ ((_typesIcounter) :: Int) ->
_typesIcounter
{-# INLINE rule287 #-}
rule287 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule288 #-}
rule288 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# NOINLINE sem_Constructor_Infix #-}
sem_Constructor_Infix :: T_Range -> T_AnnotatedType -> T_Name -> T_AnnotatedType -> T_Constructor
sem_Constructor_Infix arg_range_ arg_leftType_ arg_constructorOperator_ arg_rightType_ = T_Constructor (return st17) where
{-# NOINLINE st17 #-}
st17 = let
v16 :: T_Constructor_v16
v16 = \ (T_Constructor_vIn16 _lhsIcounter _lhsInamesInScope) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_leftTypeX8 = Control.Monad.Identity.runIdentity (attach_T_AnnotatedType (arg_leftType_))
_constructorOperatorX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_constructorOperator_))
_rightTypeX8 = Control.Monad.Identity.runIdentity (attach_T_AnnotatedType (arg_rightType_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_AnnotatedType_vOut7 _leftTypeIcounter _leftTypeIself _leftTypeIunboundNames) = inv_AnnotatedType_s8 _leftTypeX8 (T_AnnotatedType_vIn7 _leftTypeOcounter _leftTypeOnamesInScope)
(T_Name_vOut112 _constructorOperatorIself) = inv_Name_s113 _constructorOperatorX113 (T_Name_vIn112 )
(T_AnnotatedType_vOut7 _rightTypeIcounter _rightTypeIself _rightTypeIunboundNames) = inv_AnnotatedType_s8 _rightTypeX8 (T_AnnotatedType_vIn7 _rightTypeOcounter _rightTypeOnamesInScope)
_lhsOunboundNames :: Names
_lhsOunboundNames = rule289 _leftTypeIunboundNames _rightTypeIunboundNames
_self = rule290 _constructorOperatorIself _leftTypeIself _rangeIself _rightTypeIself
_lhsOself :: Constructor
_lhsOself = rule291 _self
_lhsOcounter :: Int
_lhsOcounter = rule292 _rightTypeIcounter
_leftTypeOcounter = rule293 _lhsIcounter
_leftTypeOnamesInScope = rule294 _lhsInamesInScope
_rightTypeOcounter = rule295 _leftTypeIcounter
_rightTypeOnamesInScope = rule296 _lhsInamesInScope
__result_ = T_Constructor_vOut16 _lhsOcounter _lhsOself _lhsOunboundNames
in __result_ )
in C_Constructor_s17 v16
{-# INLINE rule289 #-}
rule289 = \ ((_leftTypeIunboundNames) :: Names) ((_rightTypeIunboundNames) :: Names) ->
_leftTypeIunboundNames ++ _rightTypeIunboundNames
{-# INLINE rule290 #-}
rule290 = \ ((_constructorOperatorIself) :: Name) ((_leftTypeIself) :: AnnotatedType) ((_rangeIself) :: Range) ((_rightTypeIself) :: AnnotatedType) ->
Constructor_Infix _rangeIself _leftTypeIself _constructorOperatorIself _rightTypeIself
{-# INLINE rule291 #-}
rule291 = \ _self ->
_self
{-# INLINE rule292 #-}
rule292 = \ ((_rightTypeIcounter) :: Int) ->
_rightTypeIcounter
{-# INLINE rule293 #-}
rule293 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule294 #-}
rule294 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule295 #-}
rule295 = \ ((_leftTypeIcounter) :: Int) ->
_leftTypeIcounter
{-# INLINE rule296 #-}
rule296 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# NOINLINE sem_Constructor_Record #-}
sem_Constructor_Record :: T_Range -> T_Name -> T_FieldDeclarations -> T_Constructor
sem_Constructor_Record arg_range_ arg_constructor_ arg_fieldDeclarations_ = T_Constructor (return st17) where
{-# NOINLINE st17 #-}
st17 = let
v16 :: T_Constructor_v16
v16 = \ (T_Constructor_vIn16 _lhsIcounter _lhsInamesInScope) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_constructorX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_constructor_))
_fieldDeclarationsX50 = Control.Monad.Identity.runIdentity (attach_T_FieldDeclarations (arg_fieldDeclarations_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _constructorIself) = inv_Name_s113 _constructorX113 (T_Name_vIn112 )
(T_FieldDeclarations_vOut49 _fieldDeclarationsIcounter _fieldDeclarationsIself _fieldDeclarationsIunboundNames) = inv_FieldDeclarations_s50 _fieldDeclarationsX50 (T_FieldDeclarations_vIn49 _fieldDeclarationsOcounter _fieldDeclarationsOnamesInScope)
_lhsOunboundNames :: Names
_lhsOunboundNames = rule297 _fieldDeclarationsIunboundNames
_self = rule298 _constructorIself _fieldDeclarationsIself _rangeIself
_lhsOself :: Constructor
_lhsOself = rule299 _self
_lhsOcounter :: Int
_lhsOcounter = rule300 _fieldDeclarationsIcounter
_fieldDeclarationsOcounter = rule301 _lhsIcounter
_fieldDeclarationsOnamesInScope = rule302 _lhsInamesInScope
__result_ = T_Constructor_vOut16 _lhsOcounter _lhsOself _lhsOunboundNames
in __result_ )
in C_Constructor_s17 v16
{-# INLINE rule297 #-}
rule297 = \ ((_fieldDeclarationsIunboundNames) :: Names) ->
_fieldDeclarationsIunboundNames
{-# INLINE rule298 #-}
rule298 = \ ((_constructorIself) :: Name) ((_fieldDeclarationsIself) :: FieldDeclarations) ((_rangeIself) :: Range) ->
Constructor_Record _rangeIself _constructorIself _fieldDeclarationsIself
{-# INLINE rule299 #-}
rule299 = \ _self ->
_self
{-# INLINE rule300 #-}
rule300 = \ ((_fieldDeclarationsIcounter) :: Int) ->
_fieldDeclarationsIcounter
{-# INLINE rule301 #-}
rule301 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule302 #-}
rule302 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
-- Constructors ------------------------------------------------
-- wrapper
data Inh_Constructors = Inh_Constructors { counter_Inh_Constructors :: (Int), namesInScope_Inh_Constructors :: (Names) }
data Syn_Constructors = Syn_Constructors { counter_Syn_Constructors :: (Int), self_Syn_Constructors :: (Constructors), unboundNames_Syn_Constructors :: (Names) }
{-# INLINABLE wrap_Constructors #-}
wrap_Constructors :: T_Constructors -> Inh_Constructors -> (Syn_Constructors )
wrap_Constructors (T_Constructors act) (Inh_Constructors _lhsIcounter _lhsInamesInScope) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Constructors_vIn19 _lhsIcounter _lhsInamesInScope
(T_Constructors_vOut19 _lhsOcounter _lhsOself _lhsOunboundNames) <- return (inv_Constructors_s20 sem arg)
return (Syn_Constructors _lhsOcounter _lhsOself _lhsOunboundNames)
)
-- cata
{-# NOINLINE sem_Constructors #-}
sem_Constructors :: Constructors -> T_Constructors
sem_Constructors list = Prelude.foldr sem_Constructors_Cons sem_Constructors_Nil (Prelude.map sem_Constructor list)
-- semantic domain
newtype T_Constructors = T_Constructors {
attach_T_Constructors :: Identity (T_Constructors_s20 )
}
newtype T_Constructors_s20 = C_Constructors_s20 {
inv_Constructors_s20 :: (T_Constructors_v19 )
}
data T_Constructors_s21 = C_Constructors_s21
type T_Constructors_v19 = (T_Constructors_vIn19 ) -> (T_Constructors_vOut19 )
data T_Constructors_vIn19 = T_Constructors_vIn19 (Int) (Names)
data T_Constructors_vOut19 = T_Constructors_vOut19 (Int) (Constructors) (Names)
{-# NOINLINE sem_Constructors_Cons #-}
sem_Constructors_Cons :: T_Constructor -> T_Constructors -> T_Constructors
sem_Constructors_Cons arg_hd_ arg_tl_ = T_Constructors (return st20) where
{-# NOINLINE st20 #-}
st20 = let
v19 :: T_Constructors_v19
v19 = \ (T_Constructors_vIn19 _lhsIcounter _lhsInamesInScope) -> ( let
_hdX17 = Control.Monad.Identity.runIdentity (attach_T_Constructor (arg_hd_))
_tlX20 = Control.Monad.Identity.runIdentity (attach_T_Constructors (arg_tl_))
(T_Constructor_vOut16 _hdIcounter _hdIself _hdIunboundNames) = inv_Constructor_s17 _hdX17 (T_Constructor_vIn16 _hdOcounter _hdOnamesInScope)
(T_Constructors_vOut19 _tlIcounter _tlIself _tlIunboundNames) = inv_Constructors_s20 _tlX20 (T_Constructors_vIn19 _tlOcounter _tlOnamesInScope)
_lhsOunboundNames :: Names
_lhsOunboundNames = rule303 _hdIunboundNames _tlIunboundNames
_self = rule304 _hdIself _tlIself
_lhsOself :: Constructors
_lhsOself = rule305 _self
_lhsOcounter :: Int
_lhsOcounter = rule306 _tlIcounter
_hdOcounter = rule307 _lhsIcounter
_hdOnamesInScope = rule308 _lhsInamesInScope
_tlOcounter = rule309 _hdIcounter
_tlOnamesInScope = rule310 _lhsInamesInScope
__result_ = T_Constructors_vOut19 _lhsOcounter _lhsOself _lhsOunboundNames
in __result_ )
in C_Constructors_s20 v19
{-# INLINE rule303 #-}
rule303 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
_hdIunboundNames ++ _tlIunboundNames
{-# INLINE rule304 #-}
rule304 = \ ((_hdIself) :: Constructor) ((_tlIself) :: Constructors) ->
(:) _hdIself _tlIself
{-# INLINE rule305 #-}
rule305 = \ _self ->
_self
{-# INLINE rule306 #-}
rule306 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule307 #-}
rule307 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule308 #-}
rule308 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule309 #-}
rule309 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule310 #-}
rule310 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# NOINLINE sem_Constructors_Nil #-}
sem_Constructors_Nil :: T_Constructors
sem_Constructors_Nil = T_Constructors (return st20) where
{-# NOINLINE st20 #-}
st20 = let
v19 :: T_Constructors_v19
v19 = \ (T_Constructors_vIn19 _lhsIcounter _lhsInamesInScope) -> ( let
_lhsOunboundNames :: Names
_lhsOunboundNames = rule311 ()
_self = rule312 ()
_lhsOself :: Constructors
_lhsOself = rule313 _self
_lhsOcounter :: Int
_lhsOcounter = rule314 _lhsIcounter
__result_ = T_Constructors_vOut19 _lhsOcounter _lhsOself _lhsOunboundNames
in __result_ )
in C_Constructors_s20 v19
{-# INLINE rule311 #-}
rule311 = \ (_ :: ()) ->
[]
{-# INLINE rule312 #-}
rule312 = \ (_ :: ()) ->
[]
{-# INLINE rule313 #-}
rule313 = \ _self ->
_self
{-# INLINE rule314 #-}
rule314 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
-- ContextItem -------------------------------------------------
-- wrapper
data Inh_ContextItem = Inh_ContextItem { }
data Syn_ContextItem = Syn_ContextItem { self_Syn_ContextItem :: (ContextItem) }
{-# INLINABLE wrap_ContextItem #-}
wrap_ContextItem :: T_ContextItem -> Inh_ContextItem -> (Syn_ContextItem )
wrap_ContextItem (T_ContextItem act) (Inh_ContextItem ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_ContextItem_vIn22
(T_ContextItem_vOut22 _lhsOself) <- return (inv_ContextItem_s23 sem arg)
return (Syn_ContextItem _lhsOself)
)
-- cata
{-# NOINLINE sem_ContextItem #-}
sem_ContextItem :: ContextItem -> T_ContextItem
sem_ContextItem ( ContextItem_ContextItem range_ name_ types_ ) = sem_ContextItem_ContextItem ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Types types_ )
-- semantic domain
newtype T_ContextItem = T_ContextItem {
attach_T_ContextItem :: Identity (T_ContextItem_s23 )
}
newtype T_ContextItem_s23 = C_ContextItem_s23 {
inv_ContextItem_s23 :: (T_ContextItem_v22 )
}
data T_ContextItem_s24 = C_ContextItem_s24
type T_ContextItem_v22 = (T_ContextItem_vIn22 ) -> (T_ContextItem_vOut22 )
data T_ContextItem_vIn22 = T_ContextItem_vIn22
data T_ContextItem_vOut22 = T_ContextItem_vOut22 (ContextItem)
{-# NOINLINE sem_ContextItem_ContextItem #-}
sem_ContextItem_ContextItem :: T_Range -> T_Name -> T_Types -> T_ContextItem
sem_ContextItem_ContextItem arg_range_ arg_name_ arg_types_ = T_ContextItem (return st23) where
{-# NOINLINE st23 #-}
st23 = let
v22 :: T_ContextItem_v22
v22 = \ (T_ContextItem_vIn22 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_typesX167 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_types_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_Types_vOut166 _typesIself) = inv_Types_s167 _typesX167 (T_Types_vIn166 )
_tyconEnv = rule315 ()
_self = rule316 _nameIself _rangeIself _typesIself
_lhsOself :: ContextItem
_lhsOself = rule317 _self
__result_ = T_ContextItem_vOut22 _lhsOself
in __result_ )
in C_ContextItem_s23 v22
{-# INLINE rule315 #-}
rule315 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "ContextItem.ContextItem"
{-# INLINE rule316 #-}
rule316 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ((_typesIself) :: Types) ->
ContextItem_ContextItem _rangeIself _nameIself _typesIself
{-# INLINE rule317 #-}
rule317 = \ _self ->
_self
-- ContextItems ------------------------------------------------
-- wrapper
data Inh_ContextItems = Inh_ContextItems { }
data Syn_ContextItems = Syn_ContextItems { self_Syn_ContextItems :: (ContextItems) }
{-# INLINABLE wrap_ContextItems #-}
wrap_ContextItems :: T_ContextItems -> Inh_ContextItems -> (Syn_ContextItems )
wrap_ContextItems (T_ContextItems act) (Inh_ContextItems ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_ContextItems_vIn25
(T_ContextItems_vOut25 _lhsOself) <- return (inv_ContextItems_s26 sem arg)
return (Syn_ContextItems _lhsOself)
)
-- cata
{-# NOINLINE sem_ContextItems #-}
sem_ContextItems :: ContextItems -> T_ContextItems
sem_ContextItems list = Prelude.foldr sem_ContextItems_Cons sem_ContextItems_Nil (Prelude.map sem_ContextItem list)
-- semantic domain
newtype T_ContextItems = T_ContextItems {
attach_T_ContextItems :: Identity (T_ContextItems_s26 )
}
newtype T_ContextItems_s26 = C_ContextItems_s26 {
inv_ContextItems_s26 :: (T_ContextItems_v25 )
}
data T_ContextItems_s27 = C_ContextItems_s27
type T_ContextItems_v25 = (T_ContextItems_vIn25 ) -> (T_ContextItems_vOut25 )
data T_ContextItems_vIn25 = T_ContextItems_vIn25
data T_ContextItems_vOut25 = T_ContextItems_vOut25 (ContextItems)
{-# NOINLINE sem_ContextItems_Cons #-}
sem_ContextItems_Cons :: T_ContextItem -> T_ContextItems -> T_ContextItems
sem_ContextItems_Cons arg_hd_ arg_tl_ = T_ContextItems (return st26) where
{-# NOINLINE st26 #-}
st26 = let
v25 :: T_ContextItems_v25
v25 = \ (T_ContextItems_vIn25 ) -> ( let
_hdX23 = Control.Monad.Identity.runIdentity (attach_T_ContextItem (arg_hd_))
_tlX26 = Control.Monad.Identity.runIdentity (attach_T_ContextItems (arg_tl_))
(T_ContextItem_vOut22 _hdIself) = inv_ContextItem_s23 _hdX23 (T_ContextItem_vIn22 )
(T_ContextItems_vOut25 _tlIself) = inv_ContextItems_s26 _tlX26 (T_ContextItems_vIn25 )
_self = rule318 _hdIself _tlIself
_lhsOself :: ContextItems
_lhsOself = rule319 _self
__result_ = T_ContextItems_vOut25 _lhsOself
in __result_ )
in C_ContextItems_s26 v25
{-# INLINE rule318 #-}
rule318 = \ ((_hdIself) :: ContextItem) ((_tlIself) :: ContextItems) ->
(:) _hdIself _tlIself
{-# INLINE rule319 #-}
rule319 = \ _self ->
_self
{-# NOINLINE sem_ContextItems_Nil #-}
sem_ContextItems_Nil :: T_ContextItems
sem_ContextItems_Nil = T_ContextItems (return st26) where
{-# NOINLINE st26 #-}
st26 = let
v25 :: T_ContextItems_v25
v25 = \ (T_ContextItems_vIn25 ) -> ( let
_self = rule320 ()
_lhsOself :: ContextItems
_lhsOself = rule321 _self
__result_ = T_ContextItems_vOut25 _lhsOself
in __result_ )
in C_ContextItems_s26 v25
{-# INLINE rule320 #-}
rule320 = \ (_ :: ()) ->
[]
{-# INLINE rule321 #-}
rule321 = \ _self ->
_self
-- Declaration -------------------------------------------------
-- wrapper
data Inh_Declaration = Inh_Declaration { allPatterns_Inh_Declaration :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Declaration :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Declaration :: (Predicates), betaUnique_Inh_Declaration :: (Int), bindingGroups_Inh_Declaration :: (BindingGroups), classEnvironment_Inh_Declaration :: (ClassEnvironment), collectErrors_Inh_Declaration :: (TypeErrors), collectWarnings_Inh_Declaration :: (Warnings), counter_Inh_Declaration :: (Int), currentChunk_Inh_Declaration :: (Int), dictionaryEnvironment_Inh_Declaration :: (DictionaryEnvironment), importEnvironment_Inh_Declaration :: (ImportEnvironment), inheritedBDG_Inh_Declaration :: (InheritedBDG), matchIO_Inh_Declaration :: (IO ()), monos_Inh_Declaration :: (Monos), namesInScope_Inh_Declaration :: (Names), orderedTypeSynonyms_Inh_Declaration :: (OrderedTypeSynonyms), parentTree_Inh_Declaration :: (InfoTree), patternMatchWarnings_Inh_Declaration :: ([Warning]), substitution_Inh_Declaration :: (FixpointSubstitution), typeSignatures_Inh_Declaration :: (TypeEnvironment), typeschemeMap_Inh_Declaration :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Declaration :: (Int) }
data Syn_Declaration = Syn_Declaration { betaUnique_Syn_Declaration :: (Int), bindingGroups_Syn_Declaration :: (BindingGroups), collectErrors_Syn_Declaration :: (TypeErrors), collectInstances_Syn_Declaration :: ([(Name, Instance)]), collectWarnings_Syn_Declaration :: (Warnings), counter_Syn_Declaration :: (Int), declVarNames_Syn_Declaration :: (Names), dictionaryEnvironment_Syn_Declaration :: (DictionaryEnvironment), infoTrees_Syn_Declaration :: (InfoTrees), matchIO_Syn_Declaration :: (IO ()), patternMatchWarnings_Syn_Declaration :: ([Warning]), restrictedNames_Syn_Declaration :: (Names), self_Syn_Declaration :: (Declaration), simplePatNames_Syn_Declaration :: (Names), typeSignatures_Syn_Declaration :: (TypeEnvironment), unboundNames_Syn_Declaration :: (Names), uniqueChunk_Syn_Declaration :: (Int) }
{-# INLINABLE wrap_Declaration #-}
wrap_Declaration :: T_Declaration -> Inh_Declaration -> (Syn_Declaration )
wrap_Declaration (T_Declaration act) (Inh_Declaration _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk
(T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_Declaration_s29 sem arg)
return (Syn_Declaration _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk)
)
-- cata
{-# NOINLINE sem_Declaration #-}
sem_Declaration :: Declaration -> T_Declaration
sem_Declaration ( Declaration_Hole range_ id_ ) = sem_Declaration_Hole ( sem_Range range_ ) id_
sem_Declaration ( Declaration_Type range_ simpletype_ type_ ) = sem_Declaration_Type ( sem_Range range_ ) ( sem_SimpleType simpletype_ ) ( sem_Type type_ )
sem_Declaration ( Declaration_Data range_ context_ simpletype_ constructors_ derivings_ ) = sem_Declaration_Data ( sem_Range range_ ) ( sem_ContextItems context_ ) ( sem_SimpleType simpletype_ ) ( sem_Constructors constructors_ ) ( sem_Names derivings_ )
sem_Declaration ( Declaration_Newtype range_ context_ simpletype_ constructor_ derivings_ ) = sem_Declaration_Newtype ( sem_Range range_ ) ( sem_ContextItems context_ ) ( sem_SimpleType simpletype_ ) ( sem_Constructor constructor_ ) ( sem_Names derivings_ )
sem_Declaration ( Declaration_Class range_ context_ simpletype_ where_ ) = sem_Declaration_Class ( sem_Range range_ ) ( sem_ContextItems context_ ) ( sem_SimpleType simpletype_ ) ( sem_MaybeDeclarations where_ )
sem_Declaration ( Declaration_Instance range_ context_ name_ types_ where_ ) = sem_Declaration_Instance ( sem_Range range_ ) ( sem_ContextItems context_ ) ( sem_Name name_ ) ( sem_Types types_ ) ( sem_MaybeDeclarations where_ )
sem_Declaration ( Declaration_Default range_ types_ ) = sem_Declaration_Default ( sem_Range range_ ) ( sem_Types types_ )
sem_Declaration ( Declaration_FunctionBindings range_ bindings_ ) = sem_Declaration_FunctionBindings ( sem_Range range_ ) ( sem_FunctionBindings bindings_ )
sem_Declaration ( Declaration_PatternBinding range_ pattern_ righthandside_ ) = sem_Declaration_PatternBinding ( sem_Range range_ ) ( sem_Pattern pattern_ ) ( sem_RightHandSide righthandside_ )
sem_Declaration ( Declaration_TypeSignature range_ names_ type_ ) = sem_Declaration_TypeSignature ( sem_Range range_ ) ( sem_Names names_ ) ( sem_Type type_ )
sem_Declaration ( Declaration_Fixity range_ fixity_ priority_ operators_ ) = sem_Declaration_Fixity ( sem_Range range_ ) ( sem_Fixity fixity_ ) ( sem_MaybeInt priority_ ) ( sem_Names operators_ )
sem_Declaration ( Declaration_Empty range_ ) = sem_Declaration_Empty ( sem_Range range_ )
-- semantic domain
newtype T_Declaration = T_Declaration {
attach_T_Declaration :: Identity (T_Declaration_s29 )
}
newtype T_Declaration_s29 = C_Declaration_s29 {
inv_Declaration_s29 :: (T_Declaration_v28 )
}
data T_Declaration_s30 = C_Declaration_s30
type T_Declaration_v28 = (T_Declaration_vIn28 ) -> (T_Declaration_vOut28 )
data T_Declaration_vIn28 = T_Declaration_vIn28 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Int) (BindingGroups) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (InheritedBDG) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (TypeEnvironment) (M.Map Int (Scheme Predicates)) (Int)
data T_Declaration_vOut28 = T_Declaration_vOut28 (Int) (BindingGroups) (TypeErrors) ([(Name, Instance)]) (Warnings) (Int) (Names) (DictionaryEnvironment) (InfoTrees) (IO ()) ([Warning]) (Names) (Declaration) (Names) (TypeEnvironment) (Names) (Int)
{-# NOINLINE sem_Declaration_Hole #-}
sem_Declaration_Hole :: T_Range -> (Integer) -> T_Declaration
sem_Declaration_Hole arg_range_ arg_id_ = T_Declaration (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Declaration_v28
v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule322 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule323 ()
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule324 ()
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule325 ()
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule326 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule327 ()
_self = rule328 _rangeIself arg_id_
_lhsOself :: Declaration
_lhsOself = rule329 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule330 _lhsIbetaUnique
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule331 _lhsIbindingGroups
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule332 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule333 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule334 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule335 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule336 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule337 _lhsIpatternMatchWarnings
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule338 _lhsItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule339 _lhsIuniqueChunk
__result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declaration_s29 v28
{-# INLINE rule322 #-}
rule322 = \ (_ :: ()) ->
[]
{-# INLINE rule323 #-}
rule323 = \ (_ :: ()) ->
[]
{-# INLINE rule324 #-}
rule324 = \ (_ :: ()) ->
[]
{-# INLINE rule325 #-}
rule325 = \ (_ :: ()) ->
[]
{-# INLINE rule326 #-}
rule326 = \ (_ :: ()) ->
[]
{-# INLINE rule327 #-}
rule327 = \ (_ :: ()) ->
[]
{-# INLINE rule328 #-}
rule328 = \ ((_rangeIself) :: Range) id_ ->
Declaration_Hole _rangeIself id_
{-# INLINE rule329 #-}
rule329 = \ _self ->
_self
{-# INLINE rule330 #-}
rule330 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule331 #-}
rule331 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
_lhsIbindingGroups
{-# INLINE rule332 #-}
rule332 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule333 #-}
rule333 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule334 #-}
rule334 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule335 #-}
rule335 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule336 #-}
rule336 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule337 #-}
rule337 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule338 #-}
rule338 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule339 #-}
rule339 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Declaration_Type #-}
sem_Declaration_Type :: T_Range -> T_SimpleType -> T_Type -> T_Declaration
sem_Declaration_Type arg_range_ arg_simpletype_ arg_type_ = T_Declaration (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Declaration_v28
v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_simpletypeX152 = Control.Monad.Identity.runIdentity (attach_T_SimpleType (arg_simpletype_))
_typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_SimpleType_vOut151 _simpletypeIname _simpletypeIself _simpletypeItypevariables) = inv_SimpleType_s152 _simpletypeX152 (T_SimpleType_vIn151 )
(T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule340 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule341 ()
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule342 ()
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule343 ()
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule344 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule345 ()
_self = rule346 _rangeIself _simpletypeIself _typeIself
_lhsOself :: Declaration
_lhsOself = rule347 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule348 _lhsIbetaUnique
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule349 _lhsIbindingGroups
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule350 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule351 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule352 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule353 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule354 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule355 _lhsIpatternMatchWarnings
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule356 _lhsItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule357 _lhsIuniqueChunk
__result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declaration_s29 v28
{-# INLINE rule340 #-}
rule340 = \ (_ :: ()) ->
[]
{-# INLINE rule341 #-}
rule341 = \ (_ :: ()) ->
[]
{-# INLINE rule342 #-}
rule342 = \ (_ :: ()) ->
[]
{-# INLINE rule343 #-}
rule343 = \ (_ :: ()) ->
[]
{-# INLINE rule344 #-}
rule344 = \ (_ :: ()) ->
[]
{-# INLINE rule345 #-}
rule345 = \ (_ :: ()) ->
[]
{-# INLINE rule346 #-}
rule346 = \ ((_rangeIself) :: Range) ((_simpletypeIself) :: SimpleType) ((_typeIself) :: Type) ->
Declaration_Type _rangeIself _simpletypeIself _typeIself
{-# INLINE rule347 #-}
rule347 = \ _self ->
_self
{-# INLINE rule348 #-}
rule348 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule349 #-}
rule349 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
_lhsIbindingGroups
{-# INLINE rule350 #-}
rule350 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule351 #-}
rule351 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule352 #-}
rule352 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule353 #-}
rule353 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule354 #-}
rule354 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule355 #-}
rule355 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule356 #-}
rule356 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule357 #-}
rule357 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Declaration_Data #-}
sem_Declaration_Data :: T_Range -> T_ContextItems -> T_SimpleType -> T_Constructors -> T_Names -> T_Declaration
sem_Declaration_Data arg_range_ arg_context_ arg_simpletype_ arg_constructors_ arg_derivings_ = T_Declaration (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Declaration_v28
v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_contextX26 = Control.Monad.Identity.runIdentity (attach_T_ContextItems (arg_context_))
_simpletypeX152 = Control.Monad.Identity.runIdentity (attach_T_SimpleType (arg_simpletype_))
_constructorsX20 = Control.Monad.Identity.runIdentity (attach_T_Constructors (arg_constructors_))
_derivingsX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_derivings_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_ContextItems_vOut25 _contextIself) = inv_ContextItems_s26 _contextX26 (T_ContextItems_vIn25 )
(T_SimpleType_vOut151 _simpletypeIname _simpletypeIself _simpletypeItypevariables) = inv_SimpleType_s152 _simpletypeX152 (T_SimpleType_vIn151 )
(T_Constructors_vOut19 _constructorsIcounter _constructorsIself _constructorsIunboundNames) = inv_Constructors_s20 _constructorsX20 (T_Constructors_vIn19 _constructorsOcounter _constructorsOnamesInScope)
(T_Names_vOut115 _derivingsIself) = inv_Names_s116 _derivingsX116 (T_Names_vIn115 )
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule358 _derivingsIself _simpletypeIname _simpletypeItypevariables
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule359 ()
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule360 ()
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule361 ()
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule362 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule363 _constructorsIunboundNames
_self = rule364 _constructorsIself _contextIself _derivingsIself _rangeIself _simpletypeIself
_lhsOself :: Declaration
_lhsOself = rule365 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule366 _lhsIbetaUnique
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule367 _lhsIbindingGroups
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule368 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule369 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule370 _constructorsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule371 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule372 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule373 _lhsIpatternMatchWarnings
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule374 _lhsItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule375 _lhsIuniqueChunk
_constructorsOcounter = rule376 _lhsIcounter
_constructorsOnamesInScope = rule377 _lhsInamesInScope
__result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declaration_s29 v28
{-# INLINE rule358 #-}
rule358 = \ ((_derivingsIself) :: Names) ((_simpletypeIname) :: Name) ((_simpletypeItypevariables) :: Names) ->
[ (cl, makeInstance (show cl) (length _simpletypeItypevariables) (show _simpletypeIname) )
| cl <- _derivingsIself
]
{-# INLINE rule359 #-}
rule359 = \ (_ :: ()) ->
[]
{-# INLINE rule360 #-}
rule360 = \ (_ :: ()) ->
[]
{-# INLINE rule361 #-}
rule361 = \ (_ :: ()) ->
[]
{-# INLINE rule362 #-}
rule362 = \ (_ :: ()) ->
[]
{-# INLINE rule363 #-}
rule363 = \ ((_constructorsIunboundNames) :: Names) ->
_constructorsIunboundNames
{-# INLINE rule364 #-}
rule364 = \ ((_constructorsIself) :: Constructors) ((_contextIself) :: ContextItems) ((_derivingsIself) :: Names) ((_rangeIself) :: Range) ((_simpletypeIself) :: SimpleType) ->
Declaration_Data _rangeIself _contextIself _simpletypeIself _constructorsIself _derivingsIself
{-# INLINE rule365 #-}
rule365 = \ _self ->
_self
{-# INLINE rule366 #-}
rule366 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule367 #-}
rule367 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
_lhsIbindingGroups
{-# INLINE rule368 #-}
rule368 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule369 #-}
rule369 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule370 #-}
rule370 = \ ((_constructorsIcounter) :: Int) ->
_constructorsIcounter
{-# INLINE rule371 #-}
rule371 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule372 #-}
rule372 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule373 #-}
rule373 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule374 #-}
rule374 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule375 #-}
rule375 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule376 #-}
rule376 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule377 #-}
rule377 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# NOINLINE sem_Declaration_Newtype #-}
sem_Declaration_Newtype :: T_Range -> T_ContextItems -> T_SimpleType -> T_Constructor -> T_Names -> T_Declaration
sem_Declaration_Newtype arg_range_ arg_context_ arg_simpletype_ arg_constructor_ arg_derivings_ = T_Declaration (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Declaration_v28
v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_contextX26 = Control.Monad.Identity.runIdentity (attach_T_ContextItems (arg_context_))
_simpletypeX152 = Control.Monad.Identity.runIdentity (attach_T_SimpleType (arg_simpletype_))
_constructorX17 = Control.Monad.Identity.runIdentity (attach_T_Constructor (arg_constructor_))
_derivingsX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_derivings_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_ContextItems_vOut25 _contextIself) = inv_ContextItems_s26 _contextX26 (T_ContextItems_vIn25 )
(T_SimpleType_vOut151 _simpletypeIname _simpletypeIself _simpletypeItypevariables) = inv_SimpleType_s152 _simpletypeX152 (T_SimpleType_vIn151 )
(T_Constructor_vOut16 _constructorIcounter _constructorIself _constructorIunboundNames) = inv_Constructor_s17 _constructorX17 (T_Constructor_vIn16 _constructorOcounter _constructorOnamesInScope)
(T_Names_vOut115 _derivingsIself) = inv_Names_s116 _derivingsX116 (T_Names_vIn115 )
_infoTrees = rule378 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule379 ()
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule380 ()
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule381 ()
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule382 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule383 _constructorIunboundNames
_self = rule384 _constructorIself _contextIself _derivingsIself _rangeIself _simpletypeIself
_lhsOself :: Declaration
_lhsOself = rule385 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule386 _lhsIbetaUnique
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule387 _lhsIbindingGroups
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule388 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule389 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule390 _constructorIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule391 _lhsIdictionaryEnvironment
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule392 _infoTrees
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule393 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule394 _lhsIpatternMatchWarnings
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule395 _lhsItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule396 _lhsIuniqueChunk
_constructorOcounter = rule397 _lhsIcounter
_constructorOnamesInScope = rule398 _lhsInamesInScope
__result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declaration_s29 v28
{-# INLINE rule378 #-}
rule378 = \ (_ :: ()) ->
globalInfoError
{-# INLINE rule379 #-}
rule379 = \ (_ :: ()) ->
[]
{-# INLINE rule380 #-}
rule380 = \ (_ :: ()) ->
[]
{-# INLINE rule381 #-}
rule381 = \ (_ :: ()) ->
[]
{-# INLINE rule382 #-}
rule382 = \ (_ :: ()) ->
[]
{-# INLINE rule383 #-}
rule383 = \ ((_constructorIunboundNames) :: Names) ->
_constructorIunboundNames
{-# INLINE rule384 #-}
rule384 = \ ((_constructorIself) :: Constructor) ((_contextIself) :: ContextItems) ((_derivingsIself) :: Names) ((_rangeIself) :: Range) ((_simpletypeIself) :: SimpleType) ->
Declaration_Newtype _rangeIself _contextIself _simpletypeIself _constructorIself _derivingsIself
{-# INLINE rule385 #-}
rule385 = \ _self ->
_self
{-# INLINE rule386 #-}
rule386 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule387 #-}
rule387 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
_lhsIbindingGroups
{-# INLINE rule388 #-}
rule388 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule389 #-}
rule389 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule390 #-}
rule390 = \ ((_constructorIcounter) :: Int) ->
_constructorIcounter
{-# INLINE rule391 #-}
rule391 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule392 #-}
rule392 = \ _infoTrees ->
_infoTrees
{-# INLINE rule393 #-}
rule393 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule394 #-}
rule394 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule395 #-}
rule395 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule396 #-}
rule396 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule397 #-}
rule397 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule398 #-}
rule398 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# NOINLINE sem_Declaration_Class #-}
sem_Declaration_Class :: T_Range -> T_ContextItems -> T_SimpleType -> T_MaybeDeclarations -> T_Declaration
sem_Declaration_Class arg_range_ arg_context_ arg_simpletype_ arg_where_ = T_Declaration (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Declaration_v28
v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_contextX26 = Control.Monad.Identity.runIdentity (attach_T_ContextItems (arg_context_))
_simpletypeX152 = Control.Monad.Identity.runIdentity (attach_T_SimpleType (arg_simpletype_))
_whereX89 = Control.Monad.Identity.runIdentity (attach_T_MaybeDeclarations (arg_where_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_ContextItems_vOut25 _contextIself) = inv_ContextItems_s26 _contextX26 (T_ContextItems_vIn25 )
(T_SimpleType_vOut151 _simpletypeIname _simpletypeIself _simpletypeItypevariables) = inv_SimpleType_s152 _simpletypeX152 (T_SimpleType_vIn151 )
(T_MaybeDeclarations_vOut88 _whereIassumptions _whereIbetaUnique _whereIcollectErrors _whereIcollectInstances _whereIcollectWarnings _whereIconstraints _whereIcounter _whereIdictionaryEnvironment _whereIinfoTrees _whereIlocalTypes _whereImatchIO _whereInamesInScope _whereIpatternMatchWarnings _whereIself _whereIunboundNames _whereIuniqueChunk) = inv_MaybeDeclarations_s89 _whereX89 (T_MaybeDeclarations_vIn88 _whereOallPatterns _whereOallTypeSchemes _whereOassumptions _whereOavailablePredicates _whereObetaUnique _whereOclassEnvironment _whereOcollectErrors _whereOcollectWarnings _whereOconstraints _whereOcounter _whereOcurrentChunk _whereOdictionaryEnvironment _whereOimportEnvironment _whereOmatchIO _whereOmonos _whereOnamesInScope _whereOorderedTypeSynonyms _whereOparentTree _whereOpatternMatchWarnings _whereOsubstitution _whereOtypeschemeMap _whereOunboundNames _whereOuniqueChunk)
(_assumptions,_constraints,_unboundNames) = rule399 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule400 _whereIcollectInstances
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule401 ()
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule402 ()
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule403 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule404 _unboundNames
_self = rule405 _contextIself _rangeIself _simpletypeIself _whereIself
_lhsOself :: Declaration
_lhsOself = rule406 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule407 _whereIbetaUnique
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule408 _lhsIbindingGroups
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule409 _whereIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule410 _whereIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule411 _whereIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule412 _whereIdictionaryEnvironment
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule413 _whereIinfoTrees
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule414 _whereImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule415 _whereIpatternMatchWarnings
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule416 _lhsItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule417 _whereIuniqueChunk
_whereOallPatterns = rule418 _lhsIallPatterns
_whereOallTypeSchemes = rule419 _lhsIallTypeSchemes
_whereOassumptions = rule420 _assumptions
_whereOavailablePredicates = rule421 _lhsIavailablePredicates
_whereObetaUnique = rule422 _lhsIbetaUnique
_whereOclassEnvironment = rule423 _lhsIclassEnvironment
_whereOcollectErrors = rule424 _lhsIcollectErrors
_whereOcollectWarnings = rule425 _lhsIcollectWarnings
_whereOconstraints = rule426 _constraints
_whereOcounter = rule427 _lhsIcounter
_whereOcurrentChunk = rule428 _lhsIcurrentChunk
_whereOdictionaryEnvironment = rule429 _lhsIdictionaryEnvironment
_whereOimportEnvironment = rule430 _lhsIimportEnvironment
_whereOmatchIO = rule431 _lhsImatchIO
_whereOmonos = rule432 _lhsImonos
_whereOnamesInScope = rule433 _lhsInamesInScope
_whereOorderedTypeSynonyms = rule434 _lhsIorderedTypeSynonyms
_whereOparentTree = rule435 _lhsIparentTree
_whereOpatternMatchWarnings = rule436 _lhsIpatternMatchWarnings
_whereOsubstitution = rule437 _lhsIsubstitution
_whereOtypeschemeMap = rule438 _lhsItypeschemeMap
_whereOunboundNames = rule439 _unboundNames
_whereOuniqueChunk = rule440 _lhsIuniqueChunk
__result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declaration_s29 v28
{-# INLINE rule399 #-}
rule399 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "Declaration.Class"
{-# INLINE rule400 #-}
rule400 = \ ((_whereIcollectInstances) :: [(Name, Instance)]) ->
_whereIcollectInstances
{-# INLINE rule401 #-}
rule401 = \ (_ :: ()) ->
[]
{-# INLINE rule402 #-}
rule402 = \ (_ :: ()) ->
[]
{-# INLINE rule403 #-}
rule403 = \ (_ :: ()) ->
[]
{-# INLINE rule404 #-}
rule404 = \ _unboundNames ->
_unboundNames
{-# INLINE rule405 #-}
rule405 = \ ((_contextIself) :: ContextItems) ((_rangeIself) :: Range) ((_simpletypeIself) :: SimpleType) ((_whereIself) :: MaybeDeclarations) ->
Declaration_Class _rangeIself _contextIself _simpletypeIself _whereIself
{-# INLINE rule406 #-}
rule406 = \ _self ->
_self
{-# INLINE rule407 #-}
rule407 = \ ((_whereIbetaUnique) :: Int) ->
_whereIbetaUnique
{-# INLINE rule408 #-}
rule408 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
_lhsIbindingGroups
{-# INLINE rule409 #-}
rule409 = \ ((_whereIcollectErrors) :: TypeErrors) ->
_whereIcollectErrors
{-# INLINE rule410 #-}
rule410 = \ ((_whereIcollectWarnings) :: Warnings) ->
_whereIcollectWarnings
{-# INLINE rule411 #-}
rule411 = \ ((_whereIcounter) :: Int) ->
_whereIcounter
{-# INLINE rule412 #-}
rule412 = \ ((_whereIdictionaryEnvironment) :: DictionaryEnvironment) ->
_whereIdictionaryEnvironment
{-# INLINE rule413 #-}
rule413 = \ ((_whereIinfoTrees) :: InfoTrees) ->
_whereIinfoTrees
{-# INLINE rule414 #-}
rule414 = \ ((_whereImatchIO) :: IO ()) ->
_whereImatchIO
{-# INLINE rule415 #-}
rule415 = \ ((_whereIpatternMatchWarnings) :: [Warning]) ->
_whereIpatternMatchWarnings
{-# INLINE rule416 #-}
rule416 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule417 #-}
rule417 = \ ((_whereIuniqueChunk) :: Int) ->
_whereIuniqueChunk
{-# INLINE rule418 #-}
rule418 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule419 #-}
rule419 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule420 #-}
rule420 = \ _assumptions ->
_assumptions
{-# INLINE rule421 #-}
rule421 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule422 #-}
rule422 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule423 #-}
rule423 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule424 #-}
rule424 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule425 #-}
rule425 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule426 #-}
rule426 = \ _constraints ->
_constraints
{-# INLINE rule427 #-}
rule427 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule428 #-}
rule428 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule429 #-}
rule429 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule430 #-}
rule430 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule431 #-}
rule431 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule432 #-}
rule432 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule433 #-}
rule433 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule434 #-}
rule434 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule435 #-}
rule435 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule436 #-}
rule436 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule437 #-}
rule437 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule438 #-}
rule438 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule439 #-}
rule439 = \ _unboundNames ->
_unboundNames
{-# INLINE rule440 #-}
rule440 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Declaration_Instance #-}
sem_Declaration_Instance :: T_Range -> T_ContextItems -> T_Name -> T_Types -> T_MaybeDeclarations -> T_Declaration
sem_Declaration_Instance arg_range_ arg_context_ arg_name_ arg_types_ arg_where_ = T_Declaration (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Declaration_v28
v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_contextX26 = Control.Monad.Identity.runIdentity (attach_T_ContextItems (arg_context_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_typesX167 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_types_))
_whereX89 = Control.Monad.Identity.runIdentity (attach_T_MaybeDeclarations (arg_where_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_ContextItems_vOut25 _contextIself) = inv_ContextItems_s26 _contextX26 (T_ContextItems_vIn25 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_Types_vOut166 _typesIself) = inv_Types_s167 _typesX167 (T_Types_vIn166 )
(T_MaybeDeclarations_vOut88 _whereIassumptions _whereIbetaUnique _whereIcollectErrors _whereIcollectInstances _whereIcollectWarnings _whereIconstraints _whereIcounter _whereIdictionaryEnvironment _whereIinfoTrees _whereIlocalTypes _whereImatchIO _whereInamesInScope _whereIpatternMatchWarnings _whereIself _whereIunboundNames _whereIuniqueChunk) = inv_MaybeDeclarations_s89 _whereX89 (T_MaybeDeclarations_vIn88 _whereOallPatterns _whereOallTypeSchemes _whereOassumptions _whereOavailablePredicates _whereObetaUnique _whereOclassEnvironment _whereOcollectErrors _whereOcollectWarnings _whereOconstraints _whereOcounter _whereOcurrentChunk _whereOdictionaryEnvironment _whereOimportEnvironment _whereOmatchIO _whereOmonos _whereOnamesInScope _whereOorderedTypeSynonyms _whereOparentTree _whereOpatternMatchWarnings _whereOsubstitution _whereOtypeschemeMap _whereOunboundNames _whereOuniqueChunk)
(_assumptions,_constraints,_unboundNames) = rule441 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule442 _whereIcollectInstances
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule443 ()
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule444 ()
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule445 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule446 _unboundNames
_self = rule447 _contextIself _nameIself _rangeIself _typesIself _whereIself
_lhsOself :: Declaration
_lhsOself = rule448 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule449 _whereIbetaUnique
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule450 _lhsIbindingGroups
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule451 _whereIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule452 _whereIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule453 _whereIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule454 _whereIdictionaryEnvironment
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule455 _whereIinfoTrees
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule456 _whereImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule457 _whereIpatternMatchWarnings
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule458 _lhsItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule459 _whereIuniqueChunk
_whereOallPatterns = rule460 _lhsIallPatterns
_whereOallTypeSchemes = rule461 _lhsIallTypeSchemes
_whereOassumptions = rule462 _assumptions
_whereOavailablePredicates = rule463 _lhsIavailablePredicates
_whereObetaUnique = rule464 _lhsIbetaUnique
_whereOclassEnvironment = rule465 _lhsIclassEnvironment
_whereOcollectErrors = rule466 _lhsIcollectErrors
_whereOcollectWarnings = rule467 _lhsIcollectWarnings
_whereOconstraints = rule468 _constraints
_whereOcounter = rule469 _lhsIcounter
_whereOcurrentChunk = rule470 _lhsIcurrentChunk
_whereOdictionaryEnvironment = rule471 _lhsIdictionaryEnvironment
_whereOimportEnvironment = rule472 _lhsIimportEnvironment
_whereOmatchIO = rule473 _lhsImatchIO
_whereOmonos = rule474 _lhsImonos
_whereOnamesInScope = rule475 _lhsInamesInScope
_whereOorderedTypeSynonyms = rule476 _lhsIorderedTypeSynonyms
_whereOparentTree = rule477 _lhsIparentTree
_whereOpatternMatchWarnings = rule478 _lhsIpatternMatchWarnings
_whereOsubstitution = rule479 _lhsIsubstitution
_whereOtypeschemeMap = rule480 _lhsItypeschemeMap
_whereOunboundNames = rule481 _unboundNames
_whereOuniqueChunk = rule482 _lhsIuniqueChunk
__result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declaration_s29 v28
{-# INLINE rule441 #-}
rule441 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "Declaration.Instance"
{-# INLINE rule442 #-}
rule442 = \ ((_whereIcollectInstances) :: [(Name, Instance)]) ->
_whereIcollectInstances
{-# INLINE rule443 #-}
rule443 = \ (_ :: ()) ->
[]
{-# INLINE rule444 #-}
rule444 = \ (_ :: ()) ->
[]
{-# INLINE rule445 #-}
rule445 = \ (_ :: ()) ->
[]
{-# INLINE rule446 #-}
rule446 = \ _unboundNames ->
_unboundNames
{-# INLINE rule447 #-}
rule447 = \ ((_contextIself) :: ContextItems) ((_nameIself) :: Name) ((_rangeIself) :: Range) ((_typesIself) :: Types) ((_whereIself) :: MaybeDeclarations) ->
Declaration_Instance _rangeIself _contextIself _nameIself _typesIself _whereIself
{-# INLINE rule448 #-}
rule448 = \ _self ->
_self
{-# INLINE rule449 #-}
rule449 = \ ((_whereIbetaUnique) :: Int) ->
_whereIbetaUnique
{-# INLINE rule450 #-}
rule450 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
_lhsIbindingGroups
{-# INLINE rule451 #-}
rule451 = \ ((_whereIcollectErrors) :: TypeErrors) ->
_whereIcollectErrors
{-# INLINE rule452 #-}
rule452 = \ ((_whereIcollectWarnings) :: Warnings) ->
_whereIcollectWarnings
{-# INLINE rule453 #-}
rule453 = \ ((_whereIcounter) :: Int) ->
_whereIcounter
{-# INLINE rule454 #-}
rule454 = \ ((_whereIdictionaryEnvironment) :: DictionaryEnvironment) ->
_whereIdictionaryEnvironment
{-# INLINE rule455 #-}
rule455 = \ ((_whereIinfoTrees) :: InfoTrees) ->
_whereIinfoTrees
{-# INLINE rule456 #-}
rule456 = \ ((_whereImatchIO) :: IO ()) ->
_whereImatchIO
{-# INLINE rule457 #-}
rule457 = \ ((_whereIpatternMatchWarnings) :: [Warning]) ->
_whereIpatternMatchWarnings
{-# INLINE rule458 #-}
rule458 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule459 #-}
rule459 = \ ((_whereIuniqueChunk) :: Int) ->
_whereIuniqueChunk
{-# INLINE rule460 #-}
rule460 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule461 #-}
rule461 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule462 #-}
rule462 = \ _assumptions ->
_assumptions
{-# INLINE rule463 #-}
rule463 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule464 #-}
rule464 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule465 #-}
rule465 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule466 #-}
rule466 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule467 #-}
rule467 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule468 #-}
rule468 = \ _constraints ->
_constraints
{-# INLINE rule469 #-}
rule469 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule470 #-}
rule470 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule471 #-}
rule471 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule472 #-}
rule472 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule473 #-}
rule473 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule474 #-}
rule474 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule475 #-}
rule475 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule476 #-}
rule476 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule477 #-}
rule477 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule478 #-}
rule478 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule479 #-}
rule479 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule480 #-}
rule480 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule481 #-}
rule481 = \ _unboundNames ->
_unboundNames
{-# INLINE rule482 #-}
rule482 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Declaration_Default #-}
sem_Declaration_Default :: T_Range -> T_Types -> T_Declaration
sem_Declaration_Default arg_range_ arg_types_ = T_Declaration (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Declaration_v28
v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_typesX167 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_types_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Types_vOut166 _typesIself) = inv_Types_s167 _typesX167 (T_Types_vIn166 )
_infoTrees = rule483 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule484 ()
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule485 ()
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule486 ()
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule487 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule488 ()
_self = rule489 _rangeIself _typesIself
_lhsOself :: Declaration
_lhsOself = rule490 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule491 _lhsIbetaUnique
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule492 _lhsIbindingGroups
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule493 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule494 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule495 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule496 _lhsIdictionaryEnvironment
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule497 _infoTrees
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule498 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule499 _lhsIpatternMatchWarnings
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule500 _lhsItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule501 _lhsIuniqueChunk
__result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declaration_s29 v28
{-# INLINE rule483 #-}
rule483 = \ (_ :: ()) ->
globalInfoError
{-# INLINE rule484 #-}
rule484 = \ (_ :: ()) ->
[]
{-# INLINE rule485 #-}
rule485 = \ (_ :: ()) ->
[]
{-# INLINE rule486 #-}
rule486 = \ (_ :: ()) ->
[]
{-# INLINE rule487 #-}
rule487 = \ (_ :: ()) ->
[]
{-# INLINE rule488 #-}
rule488 = \ (_ :: ()) ->
[]
{-# INLINE rule489 #-}
rule489 = \ ((_rangeIself) :: Range) ((_typesIself) :: Types) ->
Declaration_Default _rangeIself _typesIself
{-# INLINE rule490 #-}
rule490 = \ _self ->
_self
{-# INLINE rule491 #-}
rule491 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule492 #-}
rule492 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
_lhsIbindingGroups
{-# INLINE rule493 #-}
rule493 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule494 #-}
rule494 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule495 #-}
rule495 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule496 #-}
rule496 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule497 #-}
rule497 = \ _infoTrees ->
_infoTrees
{-# INLINE rule498 #-}
rule498 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule499 #-}
rule499 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule500 #-}
rule500 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule501 #-}
rule501 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Declaration_FunctionBindings #-}
sem_Declaration_FunctionBindings :: T_Range -> T_FunctionBindings -> T_Declaration
sem_Declaration_FunctionBindings arg_range_ arg_bindings_ = T_Declaration (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Declaration_v28
v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_bindingsX59 = Control.Monad.Identity.runIdentity (attach_T_FunctionBindings (arg_bindings_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_FunctionBindings_vOut58 _bindingsIargcount _bindingsIassumptions _bindingsIbetaUnique _bindingsIcollectErrors _bindingsIcollectInstances _bindingsIcollectWarnings _bindingsIconstraintslist _bindingsIcounter _bindingsIdictionaryEnvironment _bindingsIelementss _bindingsIinfoTrees _bindingsImatchIO _bindingsIname _bindingsInumberOfPatterns _bindingsIpatternMatchWarnings _bindingsIself _bindingsIunboundNames _bindingsIuniqueChunk _bindingsIunrwars) = inv_FunctionBindings_s59 _bindingsX59 (T_FunctionBindings_vIn58 _bindingsOallPatterns _bindingsOallTypeSchemes _bindingsOavailablePredicates _bindingsObetaRight _bindingsObetaUnique _bindingsObetasLeft _bindingsOclassEnvironment _bindingsOcollectErrors _bindingsOcollectWarnings _bindingsOcounter _bindingsOcurrentChunk _bindingsOdictionaryEnvironment _bindingsOimportEnvironment _bindingsOmatchIO _bindingsOmonos _bindingsOnamesInScope _bindingsOorderedTypeSynonyms _bindingsOparentTree _bindingsOpatternMatchWarnings _bindingsOsubstitution _bindingsOtypeschemeMap _bindingsOuniqueChunk)
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule502 _lhsIbindingGroups _mybdggrp
_bindingsObetaUnique = rule503 _bindingsInumberOfPatterns _lhsIbetaUnique
_bindingsOmonos = rule504 _bindingsIname _lhsIinheritedBDG _lhsImonos
_beta = rule505 _lhsIbetaUnique
_betaRight = rule506 _lhsIbetaUnique
_betasLeft = rule507 _bindingsInumberOfPatterns _lhsIbetaUnique
_newcon = rule508 _beta _betaRight _betasLeft _cinfo
_mybdggrp = rule509 _beta _bindingsIassumptions _bindingsIconstraintslist _bindingsIname _lhsIbetaUnique _newcon
_declPredicates = rule510 _beta _bindingsIname _lhsIallTypeSchemes _lhsIorderedTypeSynonyms _lhsIsubstitution
_bindingsOavailablePredicates = rule511 _declPredicates _lhsIavailablePredicates
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule512 _bindingsIdictionaryEnvironment _bindingsIname _declPredicates
_bindingsOcurrentChunk = rule513 _bindingsIname _lhsIinheritedBDG
_cinfo = rule514 _bindingsInumberOfPatterns _parentTree
_localInfo = rule515 _lhsImonos _self
_parentTree = rule516 _bindingsIinfoTrees _lhsIparentTree _localInfo
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule517 _parentTree
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule518 _bindingsIname
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule519 _beta _bindingsIargcount _bindingsIelementss _bindingsIname _bindingsIpatternMatchWarnings _bindingsIunrwars _lhsIimportEnvironment _lhsIsubstitution _rangeIself
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule520 _bindingsIcollectInstances
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule521 ()
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule522 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule523 _bindingsIunboundNames
_self = rule524 _bindingsIself _rangeIself
_lhsOself :: Declaration
_lhsOself = rule525 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule526 _bindingsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule527 _bindingsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule528 _bindingsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule529 _bindingsIcounter
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule530 _bindingsImatchIO
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule531 _lhsItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule532 _bindingsIuniqueChunk
_bindingsOallPatterns = rule533 _lhsIallPatterns
_bindingsOallTypeSchemes = rule534 _lhsIallTypeSchemes
_bindingsObetaRight = rule535 _betaRight
_bindingsObetasLeft = rule536 _betasLeft
_bindingsOclassEnvironment = rule537 _lhsIclassEnvironment
_bindingsOcollectErrors = rule538 _lhsIcollectErrors
_bindingsOcollectWarnings = rule539 _lhsIcollectWarnings
_bindingsOcounter = rule540 _lhsIcounter
_bindingsOdictionaryEnvironment = rule541 _lhsIdictionaryEnvironment
_bindingsOimportEnvironment = rule542 _lhsIimportEnvironment
_bindingsOmatchIO = rule543 _lhsImatchIO
_bindingsOnamesInScope = rule544 _lhsInamesInScope
_bindingsOorderedTypeSynonyms = rule545 _lhsIorderedTypeSynonyms
_bindingsOparentTree = rule546 _parentTree
_bindingsOpatternMatchWarnings = rule547 _lhsIpatternMatchWarnings
_bindingsOsubstitution = rule548 _lhsIsubstitution
_bindingsOtypeschemeMap = rule549 _lhsItypeschemeMap
_bindingsOuniqueChunk = rule550 _lhsIuniqueChunk
__result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declaration_s29 v28
{-# INLINE rule502 #-}
rule502 = \ ((_lhsIbindingGroups) :: BindingGroups) _mybdggrp ->
_mybdggrp : _lhsIbindingGroups
{-# INLINE rule503 #-}
rule503 = \ ((_bindingsInumberOfPatterns) :: Int) ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 2 + _bindingsInumberOfPatterns
{-# INLINE rule504 #-}
rule504 = \ ((_bindingsIname) :: Name) ((_lhsIinheritedBDG) :: InheritedBDG) ((_lhsImonos) :: Monos) ->
findMono _bindingsIname _lhsIinheritedBDG ++ _lhsImonos
{-# INLINE rule505 #-}
rule505 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule506 #-}
rule506 = \ ((_lhsIbetaUnique) :: Int) ->
TVar (_lhsIbetaUnique + 1)
{-# INLINE rule507 #-}
rule507 = \ ((_bindingsInumberOfPatterns) :: Int) ((_lhsIbetaUnique) :: Int) ->
take _bindingsInumberOfPatterns (map TVar [_lhsIbetaUnique + 2..])
{-# INLINE rule508 #-}
rule508 = \ _beta _betaRight _betasLeft _cinfo ->
(_beta .==. foldr (.->.) _betaRight _betasLeft) _cinfo
{-# INLINE rule509 #-}
rule509 = \ _beta ((_bindingsIassumptions) :: Assumptions) ((_bindingsIconstraintslist) :: ConstraintSets) ((_bindingsIname) :: Name) ((_lhsIbetaUnique) :: Int) _newcon ->
( M.singleton _bindingsIname _beta
, _bindingsIassumptions
, [ Node [ Phase (-1) [_newcon]
, Receive _lhsIbetaUnique
, Node _bindingsIconstraintslist
]
]
)
{-# INLINE rule510 #-}
rule510 = \ _beta ((_bindingsIname) :: Name) ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ((_lhsIsubstitution) :: FixpointSubstitution) ->
let scheme = M.findWithDefault err (NameWithRange _bindingsIname) _lhsIallTypeSchemes
predicates = matchTypeWithScheme _lhsIorderedTypeSynonyms
(_lhsIsubstitution |-> _beta)
(_lhsIsubstitution |-> scheme)
err = internalError "TypeInferenceOverloading.ag" "n/a" "could not find type for function binding"
in expandPredicates _lhsIorderedTypeSynonyms predicates
{-# INLINE rule511 #-}
rule511 = \ _declPredicates ((_lhsIavailablePredicates) :: Predicates) ->
_declPredicates ++ _lhsIavailablePredicates
{-# INLINE rule512 #-}
rule512 = \ ((_bindingsIdictionaryEnvironment) :: DictionaryEnvironment) ((_bindingsIname) :: Name) _declPredicates ->
addForDeclaration _bindingsIname _declPredicates _bindingsIdictionaryEnvironment
{-# INLINE rule513 #-}
rule513 = \ ((_bindingsIname) :: Name) ((_lhsIinheritedBDG) :: InheritedBDG) ->
findCurrentChunk _bindingsIname _lhsIinheritedBDG
{-# INLINE rule514 #-}
rule514 = \ ((_bindingsInumberOfPatterns) :: Int) _parentTree ->
resultConstraint "function bindings (INTERNAL ERROR)" _parentTree
[ FolkloreConstraint, highlyTrusted, FuntionBindingEdge _bindingsInumberOfPatterns ]
{-# INLINE rule515 #-}
rule515 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Decl _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule516 #-}
rule516 = \ ((_bindingsIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo _bindingsIinfoTrees
{-# INLINE rule517 #-}
rule517 = \ _parentTree ->
[_parentTree]
{-# INLINE rule518 #-}
rule518 = \ ((_bindingsIname) :: Name) ->
[_bindingsIname]
{-# INLINE rule519 #-}
rule519 = \ _beta ((_bindingsIargcount) :: Int) ((_bindingsIelementss) :: [([PatternElement], Bool)]) ((_bindingsIname) :: Name) ((_bindingsIpatternMatchWarnings) :: [Warning]) ((_bindingsIunrwars) :: [Warning]) ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_rangeIself) :: Range) ->
patternMatchWarnings _lhsIimportEnvironment
_lhsIsubstitution
_beta
(take _bindingsIargcount . fst . functionSpine)
_bindingsIelementss
_rangeIself
(Just _bindingsIname)
True
_bindingsIunrwars
"function bindings"
"="
++ _bindingsIpatternMatchWarnings
{-# INLINE rule520 #-}
rule520 = \ ((_bindingsIcollectInstances) :: [(Name, Instance)]) ->
_bindingsIcollectInstances
{-# INLINE rule521 #-}
rule521 = \ (_ :: ()) ->
[]
{-# INLINE rule522 #-}
rule522 = \ (_ :: ()) ->
[]
{-# INLINE rule523 #-}
rule523 = \ ((_bindingsIunboundNames) :: Names) ->
_bindingsIunboundNames
{-# INLINE rule524 #-}
rule524 = \ ((_bindingsIself) :: FunctionBindings) ((_rangeIself) :: Range) ->
Declaration_FunctionBindings _rangeIself _bindingsIself
{-# INLINE rule525 #-}
rule525 = \ _self ->
_self
{-# INLINE rule526 #-}
rule526 = \ ((_bindingsIbetaUnique) :: Int) ->
_bindingsIbetaUnique
{-# INLINE rule527 #-}
rule527 = \ ((_bindingsIcollectErrors) :: TypeErrors) ->
_bindingsIcollectErrors
{-# INLINE rule528 #-}
rule528 = \ ((_bindingsIcollectWarnings) :: Warnings) ->
_bindingsIcollectWarnings
{-# INLINE rule529 #-}
rule529 = \ ((_bindingsIcounter) :: Int) ->
_bindingsIcounter
{-# INLINE rule530 #-}
rule530 = \ ((_bindingsImatchIO) :: IO ()) ->
_bindingsImatchIO
{-# INLINE rule531 #-}
rule531 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule532 #-}
rule532 = \ ((_bindingsIuniqueChunk) :: Int) ->
_bindingsIuniqueChunk
{-# INLINE rule533 #-}
rule533 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule534 #-}
rule534 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule535 #-}
rule535 = \ _betaRight ->
_betaRight
{-# INLINE rule536 #-}
rule536 = \ _betasLeft ->
_betasLeft
{-# INLINE rule537 #-}
rule537 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule538 #-}
rule538 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule539 #-}
rule539 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule540 #-}
rule540 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule541 #-}
rule541 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule542 #-}
rule542 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule543 #-}
rule543 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule544 #-}
rule544 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule545 #-}
rule545 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule546 #-}
rule546 = \ _parentTree ->
_parentTree
{-# INLINE rule547 #-}
rule547 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule548 #-}
rule548 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule549 #-}
rule549 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule550 #-}
rule550 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Declaration_PatternBinding #-}
sem_Declaration_PatternBinding :: T_Range -> T_Pattern -> T_RightHandSide -> T_Declaration
sem_Declaration_PatternBinding arg_range_ arg_pattern_ arg_righthandside_ = T_Declaration (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Declaration_v28
v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
_righthandsideX149 = Control.Monad.Identity.runIdentity (attach_T_RightHandSide (arg_righthandside_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
(T_RightHandSide_vOut148 _righthandsideIassumptions _righthandsideIbetaUnique _righthandsideIcollectErrors _righthandsideIcollectInstances _righthandsideIcollectWarnings _righthandsideIconstraints _righthandsideIcounter _righthandsideIdictionaryEnvironment _righthandsideIfallthrough _righthandsideIinfoTree _righthandsideImatchIO _righthandsideIpatternMatchWarnings _righthandsideIself _righthandsideIunboundNames _righthandsideIuniqueChunk) = inv_RightHandSide_s149 _righthandsideX149 (T_RightHandSide_vIn148 _righthandsideOallPatterns _righthandsideOallTypeSchemes _righthandsideOavailablePredicates _righthandsideObetaRight _righthandsideObetaUnique _righthandsideOclassEnvironment _righthandsideOcollectErrors _righthandsideOcollectWarnings _righthandsideOcounter _righthandsideOcurrentChunk _righthandsideOdictionaryEnvironment _righthandsideOimportEnvironment _righthandsideOmatchIO _righthandsideOmonos _righthandsideOnamesInScope _righthandsideOorderedTypeSynonyms _righthandsideOparentTree _righthandsideOpatternMatchWarnings _righthandsideOsubstitution _righthandsideOtypeschemeMap _righthandsideOuniqueChunk)
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule551 _lhsIbindingGroups _mybdggrp
_patternObetaUnique = rule552 _lhsIbetaUnique
_righthandsideOmonos = rule553 _lhsIinheritedBDG _lhsImonos _patternIenvironment
_betaRight = rule554 _lhsIbetaUnique
_newcon = rule555 _betaRight _cinfo _patternIbeta
_mybdggrp = rule556 _newcon _patternIconstraints _patternIenvironment _righthandsideIassumptions _righthandsideIconstraints
_declPredicates = rule557 _betaRight _lhsIallTypeSchemes _lhsIorderedTypeSynonyms _lhsIsubstitution _patternIself
_righthandsideOavailablePredicates = rule558 _declPredicates _lhsIavailablePredicates
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule559 _declPredicates _righthandsideIdictionaryEnvironment
_lhsOrestrictedNames :: Names
_lhsOsimplePatNames :: Names
(_lhsOrestrictedNames,_lhsOsimplePatNames) = rule560 _patternIpatVarNames _patternIself
_righthandsideOcurrentChunk = rule561 _lhsIinheritedBDG _patternIenvironment
_cinfo = rule562 _parentTree
_localInfo = rule563 _lhsImonos _self
_parentTree = rule564 _lhsIparentTree _localInfo _patternIinfoTree _righthandsideIinfoTree
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule565 _parentTree
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule566 _patternIpatVarNames
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule567 _lhsIimportEnvironment _lhsIsubstitution _patternIbeta _patternIelements _rangeIself _righthandsideIfallthrough _righthandsideIpatternMatchWarnings
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule568 _righthandsideIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule569 _patternIunboundNames _righthandsideIunboundNames
_self = rule570 _patternIself _rangeIself _righthandsideIself
_lhsOself :: Declaration
_lhsOself = rule571 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule572 _righthandsideIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule573 _righthandsideIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule574 _righthandsideIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule575 _righthandsideIcounter
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule576 _righthandsideImatchIO
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule577 _lhsItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule578 _righthandsideIuniqueChunk
_patternOcounter = rule579 _lhsIcounter
_patternOimportEnvironment = rule580 _lhsIimportEnvironment
_patternOmonos = rule581 _lhsImonos
_patternOnamesInScope = rule582 _lhsInamesInScope
_patternOparentTree = rule583 _parentTree
_patternOpatternMatchWarnings = rule584 _lhsIpatternMatchWarnings
_righthandsideOallPatterns = rule585 _lhsIallPatterns
_righthandsideOallTypeSchemes = rule586 _lhsIallTypeSchemes
_righthandsideObetaRight = rule587 _betaRight
_righthandsideObetaUnique = rule588 _patternIbetaUnique
_righthandsideOclassEnvironment = rule589 _lhsIclassEnvironment
_righthandsideOcollectErrors = rule590 _lhsIcollectErrors
_righthandsideOcollectWarnings = rule591 _lhsIcollectWarnings
_righthandsideOcounter = rule592 _patternIcounter
_righthandsideOdictionaryEnvironment = rule593 _lhsIdictionaryEnvironment
_righthandsideOimportEnvironment = rule594 _lhsIimportEnvironment
_righthandsideOmatchIO = rule595 _lhsImatchIO
_righthandsideOnamesInScope = rule596 _lhsInamesInScope
_righthandsideOorderedTypeSynonyms = rule597 _lhsIorderedTypeSynonyms
_righthandsideOparentTree = rule598 _parentTree
_righthandsideOpatternMatchWarnings = rule599 _patternIpatternMatchWarnings
_righthandsideOsubstitution = rule600 _lhsIsubstitution
_righthandsideOtypeschemeMap = rule601 _lhsItypeschemeMap
_righthandsideOuniqueChunk = rule602 _lhsIuniqueChunk
__result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declaration_s29 v28
{-# INLINE rule551 #-}
rule551 = \ ((_lhsIbindingGroups) :: BindingGroups) _mybdggrp ->
_mybdggrp : _lhsIbindingGroups
{-# INLINE rule552 #-}
rule552 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule553 #-}
rule553 = \ ((_lhsIinheritedBDG) :: InheritedBDG) ((_lhsImonos) :: Monos) ((_patternIenvironment) :: PatternAssumptions) ->
findMono (head (M.keys _patternIenvironment)) _lhsIinheritedBDG ++ _lhsImonos
{-# INLINE rule554 #-}
rule554 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule555 #-}
rule555 = \ _betaRight _cinfo ((_patternIbeta) :: Tp) ->
[ (_betaRight .==. _patternIbeta) _cinfo ]
{-# INLINE rule556 #-}
rule556 = \ _newcon ((_patternIconstraints) :: ConstraintSet) ((_patternIenvironment) :: PatternAssumptions) ((_righthandsideIassumptions) :: Assumptions) ((_righthandsideIconstraints) :: ConstraintSet) ->
( _patternIenvironment
, _righthandsideIassumptions
, [ _newcon .>.
Node [ _patternIconstraints
, _righthandsideIconstraints
]
]
)
{-# INLINE rule557 #-}
rule557 = \ _betaRight ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ((_lhsIsubstitution) :: FixpointSubstitution) ((_patternIself) :: Pattern) ->
case _patternIself of
Pattern_Variable _ name ->
let scheme = M.findWithDefault err (NameWithRange name) _lhsIallTypeSchemes
predicates = matchTypeWithScheme _lhsIorderedTypeSynonyms
(_lhsIsubstitution |-> _betaRight)
(_lhsIsubstitution |-> scheme)
err = internalError "TypeInferenceOverloading.ag" "n/a" ("could not find type for pattern binding "++show name)
in Just (name, expandPredicates _lhsIorderedTypeSynonyms predicates)
_ -> Nothing
{-# INLINE rule558 #-}
rule558 = \ _declPredicates ((_lhsIavailablePredicates) :: Predicates) ->
case _declPredicates of
Just (_, ps) -> ps ++ _lhsIavailablePredicates
Nothing -> _lhsIavailablePredicates
{-# INLINE rule559 #-}
rule559 = \ _declPredicates ((_righthandsideIdictionaryEnvironment) :: DictionaryEnvironment) ->
case _declPredicates of
Just (n, ps) -> addForDeclaration n ps _righthandsideIdictionaryEnvironment
Nothing -> _righthandsideIdictionaryEnvironment
{-# INLINE rule560 #-}
rule560 = \ ((_patternIpatVarNames) :: Names) ((_patternIself) :: Pattern) ->
if isSimplePattern _patternIself
then ([], _patternIpatVarNames)
else (_patternIpatVarNames, [])
{-# INLINE rule561 #-}
rule561 = \ ((_lhsIinheritedBDG) :: InheritedBDG) ((_patternIenvironment) :: PatternAssumptions) ->
findCurrentChunk (head (M.keys _patternIenvironment)) _lhsIinheritedBDG
{-# INLINE rule562 #-}
rule562 = \ _parentTree ->
orphanConstraint 1 "right hand side" _parentTree
[]
{-# INLINE rule563 #-}
rule563 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Decl _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule564 #-}
rule564 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternIinfoTree) :: InfoTree) ((_righthandsideIinfoTree) :: InfoTree) ->
node _lhsIparentTree _localInfo [_patternIinfoTree, _righthandsideIinfoTree]
{-# INLINE rule565 #-}
rule565 = \ _parentTree ->
[_parentTree]
{-# INLINE rule566 #-}
rule566 = \ ((_patternIpatVarNames) :: Names) ->
_patternIpatVarNames
{-# INLINE rule567 #-}
rule567 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_patternIbeta) :: Tp) ((_patternIelements) :: [PatternElement] ) ((_rangeIself) :: Range) ((_righthandsideIfallthrough) :: Bool) ((_righthandsideIpatternMatchWarnings) :: [Warning]) ->
patternMatchWarnings _lhsIimportEnvironment
_lhsIsubstitution
_patternIbeta
(:[])
[(_patternIelements, _righthandsideIfallthrough)]
_rangeIself
Nothing
False
[]
"pattern binding"
"="
++ _righthandsideIpatternMatchWarnings
{-# INLINE rule568 #-}
rule568 = \ ((_righthandsideIcollectInstances) :: [(Name, Instance)]) ->
_righthandsideIcollectInstances
{-# INLINE rule569 #-}
rule569 = \ ((_patternIunboundNames) :: Names) ((_righthandsideIunboundNames) :: Names) ->
_patternIunboundNames ++ _righthandsideIunboundNames
{-# INLINE rule570 #-}
rule570 = \ ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ((_righthandsideIself) :: RightHandSide) ->
Declaration_PatternBinding _rangeIself _patternIself _righthandsideIself
{-# INLINE rule571 #-}
rule571 = \ _self ->
_self
{-# INLINE rule572 #-}
rule572 = \ ((_righthandsideIbetaUnique) :: Int) ->
_righthandsideIbetaUnique
{-# INLINE rule573 #-}
rule573 = \ ((_righthandsideIcollectErrors) :: TypeErrors) ->
_righthandsideIcollectErrors
{-# INLINE rule574 #-}
rule574 = \ ((_righthandsideIcollectWarnings) :: Warnings) ->
_righthandsideIcollectWarnings
{-# INLINE rule575 #-}
rule575 = \ ((_righthandsideIcounter) :: Int) ->
_righthandsideIcounter
{-# INLINE rule576 #-}
rule576 = \ ((_righthandsideImatchIO) :: IO ()) ->
_righthandsideImatchIO
{-# INLINE rule577 #-}
rule577 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule578 #-}
rule578 = \ ((_righthandsideIuniqueChunk) :: Int) ->
_righthandsideIuniqueChunk
{-# INLINE rule579 #-}
rule579 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule580 #-}
rule580 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule581 #-}
rule581 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule582 #-}
rule582 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule583 #-}
rule583 = \ _parentTree ->
_parentTree
{-# INLINE rule584 #-}
rule584 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule585 #-}
rule585 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule586 #-}
rule586 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule587 #-}
rule587 = \ _betaRight ->
_betaRight
{-# INLINE rule588 #-}
rule588 = \ ((_patternIbetaUnique) :: Int) ->
_patternIbetaUnique
{-# INLINE rule589 #-}
rule589 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule590 #-}
rule590 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule591 #-}
rule591 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule592 #-}
rule592 = \ ((_patternIcounter) :: Int) ->
_patternIcounter
{-# INLINE rule593 #-}
rule593 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule594 #-}
rule594 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule595 #-}
rule595 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule596 #-}
rule596 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule597 #-}
rule597 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule598 #-}
rule598 = \ _parentTree ->
_parentTree
{-# INLINE rule599 #-}
rule599 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
_patternIpatternMatchWarnings
{-# INLINE rule600 #-}
rule600 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule601 #-}
rule601 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule602 #-}
rule602 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Declaration_TypeSignature #-}
sem_Declaration_TypeSignature :: T_Range -> T_Names -> T_Type -> T_Declaration
sem_Declaration_TypeSignature arg_range_ arg_names_ arg_type_ = T_Declaration (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Declaration_v28
v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_namesX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_names_))
_typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Names_vOut115 _namesIself) = inv_Names_s116 _namesX116 (T_Names_vIn115 )
(T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule603 _lhsItypeSignatures _namesIself _typeScheme
_typeScheme = rule604 _typeIself
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule605 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule606 ()
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule607 ()
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule608 ()
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule609 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule610 ()
_self = rule611 _namesIself _rangeIself _typeIself
_lhsOself :: Declaration
_lhsOself = rule612 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule613 _lhsIbetaUnique
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule614 _lhsIbindingGroups
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule615 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule616 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule617 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule618 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule619 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule620 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule621 _lhsIuniqueChunk
__result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declaration_s29 v28
{-# INLINE rule603 #-}
rule603 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ((_namesIself) :: Names) _typeScheme ->
_lhsItypeSignatures `M.union` (M.fromList [ (name, _typeScheme) | name <- _namesIself ])
{-# INLINE rule604 #-}
rule604 = \ ((_typeIself) :: Type) ->
makeTpSchemeFromType _typeIself
{-# INLINE rule605 #-}
rule605 = \ (_ :: ()) ->
[]
{-# INLINE rule606 #-}
rule606 = \ (_ :: ()) ->
[]
{-# INLINE rule607 #-}
rule607 = \ (_ :: ()) ->
[]
{-# INLINE rule608 #-}
rule608 = \ (_ :: ()) ->
[]
{-# INLINE rule609 #-}
rule609 = \ (_ :: ()) ->
[]
{-# INLINE rule610 #-}
rule610 = \ (_ :: ()) ->
[]
{-# INLINE rule611 #-}
rule611 = \ ((_namesIself) :: Names) ((_rangeIself) :: Range) ((_typeIself) :: Type) ->
Declaration_TypeSignature _rangeIself _namesIself _typeIself
{-# INLINE rule612 #-}
rule612 = \ _self ->
_self
{-# INLINE rule613 #-}
rule613 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule614 #-}
rule614 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
_lhsIbindingGroups
{-# INLINE rule615 #-}
rule615 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule616 #-}
rule616 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule617 #-}
rule617 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule618 #-}
rule618 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule619 #-}
rule619 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule620 #-}
rule620 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule621 #-}
rule621 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Declaration_Fixity #-}
sem_Declaration_Fixity :: T_Range -> T_Fixity -> T_MaybeInt -> T_Names -> T_Declaration
sem_Declaration_Fixity arg_range_ arg_fixity_ arg_priority_ arg_operators_ = T_Declaration (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Declaration_v28
v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_fixityX53 = Control.Monad.Identity.runIdentity (attach_T_Fixity (arg_fixity_))
_priorityX101 = Control.Monad.Identity.runIdentity (attach_T_MaybeInt (arg_priority_))
_operatorsX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_operators_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Fixity_vOut52 _fixityIself) = inv_Fixity_s53 _fixityX53 (T_Fixity_vIn52 )
(T_MaybeInt_vOut100 _priorityIself) = inv_MaybeInt_s101 _priorityX101 (T_MaybeInt_vIn100 )
(T_Names_vOut115 _operatorsIself) = inv_Names_s116 _operatorsX116 (T_Names_vIn115 )
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule622 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule623 ()
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule624 ()
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule625 ()
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule626 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule627 ()
_self = rule628 _fixityIself _operatorsIself _priorityIself _rangeIself
_lhsOself :: Declaration
_lhsOself = rule629 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule630 _lhsIbetaUnique
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule631 _lhsIbindingGroups
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule632 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule633 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule634 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule635 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule636 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule637 _lhsIpatternMatchWarnings
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule638 _lhsItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule639 _lhsIuniqueChunk
__result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declaration_s29 v28
{-# INLINE rule622 #-}
rule622 = \ (_ :: ()) ->
[]
{-# INLINE rule623 #-}
rule623 = \ (_ :: ()) ->
[]
{-# INLINE rule624 #-}
rule624 = \ (_ :: ()) ->
[]
{-# INLINE rule625 #-}
rule625 = \ (_ :: ()) ->
[]
{-# INLINE rule626 #-}
rule626 = \ (_ :: ()) ->
[]
{-# INLINE rule627 #-}
rule627 = \ (_ :: ()) ->
[]
{-# INLINE rule628 #-}
rule628 = \ ((_fixityIself) :: Fixity) ((_operatorsIself) :: Names) ((_priorityIself) :: MaybeInt) ((_rangeIself) :: Range) ->
Declaration_Fixity _rangeIself _fixityIself _priorityIself _operatorsIself
{-# INLINE rule629 #-}
rule629 = \ _self ->
_self
{-# INLINE rule630 #-}
rule630 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule631 #-}
rule631 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
_lhsIbindingGroups
{-# INLINE rule632 #-}
rule632 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule633 #-}
rule633 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule634 #-}
rule634 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule635 #-}
rule635 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule636 #-}
rule636 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule637 #-}
rule637 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule638 #-}
rule638 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule639 #-}
rule639 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Declaration_Empty #-}
sem_Declaration_Empty :: T_Range -> T_Declaration
sem_Declaration_Empty arg_range_ = T_Declaration (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Declaration_v28
v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule640 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule641 ()
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule642 ()
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule643 ()
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule644 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule645 ()
_self = rule646 _rangeIself
_lhsOself :: Declaration
_lhsOself = rule647 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule648 _lhsIbetaUnique
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule649 _lhsIbindingGroups
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule650 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule651 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule652 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule653 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule654 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule655 _lhsIpatternMatchWarnings
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule656 _lhsItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule657 _lhsIuniqueChunk
__result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declaration_s29 v28
{-# INLINE rule640 #-}
rule640 = \ (_ :: ()) ->
[]
{-# INLINE rule641 #-}
rule641 = \ (_ :: ()) ->
[]
{-# INLINE rule642 #-}
rule642 = \ (_ :: ()) ->
[]
{-# INLINE rule643 #-}
rule643 = \ (_ :: ()) ->
[]
{-# INLINE rule644 #-}
rule644 = \ (_ :: ()) ->
[]
{-# INLINE rule645 #-}
rule645 = \ (_ :: ()) ->
[]
{-# INLINE rule646 #-}
rule646 = \ ((_rangeIself) :: Range) ->
Declaration_Empty _rangeIself
{-# INLINE rule647 #-}
rule647 = \ _self ->
_self
{-# INLINE rule648 #-}
rule648 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule649 #-}
rule649 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
_lhsIbindingGroups
{-# INLINE rule650 #-}
rule650 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule651 #-}
rule651 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule652 #-}
rule652 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule653 #-}
rule653 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule654 #-}
rule654 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule655 #-}
rule655 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule656 #-}
rule656 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule657 #-}
rule657 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
-- Declarations ------------------------------------------------
-- wrapper
data Inh_Declarations = Inh_Declarations { allPatterns_Inh_Declarations :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Declarations :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Declarations :: (Predicates), betaUnique_Inh_Declarations :: (Int), bindingGroups_Inh_Declarations :: (BindingGroups), classEnvironment_Inh_Declarations :: (ClassEnvironment), collectErrors_Inh_Declarations :: (TypeErrors), collectWarnings_Inh_Declarations :: (Warnings), counter_Inh_Declarations :: (Int), currentChunk_Inh_Declarations :: (Int), dictionaryEnvironment_Inh_Declarations :: (DictionaryEnvironment), importEnvironment_Inh_Declarations :: (ImportEnvironment), inheritedBDG_Inh_Declarations :: (InheritedBDG), matchIO_Inh_Declarations :: (IO ()), monos_Inh_Declarations :: (Monos), namesInScope_Inh_Declarations :: (Names), orderedTypeSynonyms_Inh_Declarations :: (OrderedTypeSynonyms), parentTree_Inh_Declarations :: (InfoTree), patternMatchWarnings_Inh_Declarations :: ([Warning]), substitution_Inh_Declarations :: (FixpointSubstitution), typeSignatures_Inh_Declarations :: (TypeEnvironment), typeschemeMap_Inh_Declarations :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Declarations :: (Int) }
data Syn_Declarations = Syn_Declarations { betaUnique_Syn_Declarations :: (Int), bindingGroups_Syn_Declarations :: (BindingGroups), collectErrors_Syn_Declarations :: (TypeErrors), collectInstances_Syn_Declarations :: ([(Name, Instance)]), collectWarnings_Syn_Declarations :: (Warnings), counter_Syn_Declarations :: (Int), declVarNames_Syn_Declarations :: (Names), dictionaryEnvironment_Syn_Declarations :: (DictionaryEnvironment), infoTrees_Syn_Declarations :: (InfoTrees), matchIO_Syn_Declarations :: (IO ()), patternMatchWarnings_Syn_Declarations :: ([Warning]), restrictedNames_Syn_Declarations :: (Names), self_Syn_Declarations :: (Declarations), simplePatNames_Syn_Declarations :: (Names), typeSignatures_Syn_Declarations :: (TypeEnvironment), unboundNames_Syn_Declarations :: (Names), uniqueChunk_Syn_Declarations :: (Int) }
{-# INLINABLE wrap_Declarations #-}
wrap_Declarations :: T_Declarations -> Inh_Declarations -> (Syn_Declarations )
wrap_Declarations (T_Declarations act) (Inh_Declarations _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Declarations_vIn31 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk
(T_Declarations_vOut31 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_Declarations_s32 sem arg)
return (Syn_Declarations _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk)
)
-- cata
{-# NOINLINE sem_Declarations #-}
sem_Declarations :: Declarations -> T_Declarations
sem_Declarations list = Prelude.foldr sem_Declarations_Cons sem_Declarations_Nil (Prelude.map sem_Declaration list)
-- semantic domain
newtype T_Declarations = T_Declarations {
attach_T_Declarations :: Identity (T_Declarations_s32 )
}
newtype T_Declarations_s32 = C_Declarations_s32 {
inv_Declarations_s32 :: (T_Declarations_v31 )
}
data T_Declarations_s33 = C_Declarations_s33
type T_Declarations_v31 = (T_Declarations_vIn31 ) -> (T_Declarations_vOut31 )
data T_Declarations_vIn31 = T_Declarations_vIn31 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Int) (BindingGroups) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (InheritedBDG) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (TypeEnvironment) (M.Map Int (Scheme Predicates)) (Int)
data T_Declarations_vOut31 = T_Declarations_vOut31 (Int) (BindingGroups) (TypeErrors) ([(Name, Instance)]) (Warnings) (Int) (Names) (DictionaryEnvironment) (InfoTrees) (IO ()) ([Warning]) (Names) (Declarations) (Names) (TypeEnvironment) (Names) (Int)
{-# NOINLINE sem_Declarations_Cons #-}
sem_Declarations_Cons :: T_Declaration -> T_Declarations -> T_Declarations
sem_Declarations_Cons arg_hd_ arg_tl_ = T_Declarations (return st32) where
{-# NOINLINE st32 #-}
st32 = let
v31 :: T_Declarations_v31
v31 = \ (T_Declarations_vIn31 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_hdX29 = Control.Monad.Identity.runIdentity (attach_T_Declaration (arg_hd_))
_tlX32 = Control.Monad.Identity.runIdentity (attach_T_Declarations (arg_tl_))
(T_Declaration_vOut28 _hdIbetaUnique _hdIbindingGroups _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIcounter _hdIdeclVarNames _hdIdictionaryEnvironment _hdIinfoTrees _hdImatchIO _hdIpatternMatchWarnings _hdIrestrictedNames _hdIself _hdIsimplePatNames _hdItypeSignatures _hdIunboundNames _hdIuniqueChunk) = inv_Declaration_s29 _hdX29 (T_Declaration_vIn28 _hdOallPatterns _hdOallTypeSchemes _hdOavailablePredicates _hdObetaUnique _hdObindingGroups _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOinheritedBDG _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeSignatures _hdOtypeschemeMap _hdOuniqueChunk)
(T_Declarations_vOut31 _tlIbetaUnique _tlIbindingGroups _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIcounter _tlIdeclVarNames _tlIdictionaryEnvironment _tlIinfoTrees _tlImatchIO _tlIpatternMatchWarnings _tlIrestrictedNames _tlIself _tlIsimplePatNames _tlItypeSignatures _tlIunboundNames _tlIuniqueChunk) = inv_Declarations_s32 _tlX32 (T_Declarations_vIn31 _tlOallPatterns _tlOallTypeSchemes _tlOavailablePredicates _tlObetaUnique _tlObindingGroups _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOinheritedBDG _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeSignatures _tlOtypeschemeMap _tlOuniqueChunk)
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule658 _hdIinfoTrees _tlIinfoTrees
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule659 _hdIcollectInstances _tlIcollectInstances
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule660 _hdIdeclVarNames _tlIdeclVarNames
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule661 _hdIrestrictedNames _tlIrestrictedNames
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule662 _hdIsimplePatNames _tlIsimplePatNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule663 _hdIunboundNames _tlIunboundNames
_self = rule664 _hdIself _tlIself
_lhsOself :: Declarations
_lhsOself = rule665 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule666 _tlIbetaUnique
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule667 _tlIbindingGroups
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule668 _tlIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule669 _tlIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule670 _tlIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule671 _tlIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule672 _tlImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule673 _tlIpatternMatchWarnings
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule674 _tlItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule675 _tlIuniqueChunk
_hdOallPatterns = rule676 _lhsIallPatterns
_hdOallTypeSchemes = rule677 _lhsIallTypeSchemes
_hdOavailablePredicates = rule678 _lhsIavailablePredicates
_hdObetaUnique = rule679 _lhsIbetaUnique
_hdObindingGroups = rule680 _lhsIbindingGroups
_hdOclassEnvironment = rule681 _lhsIclassEnvironment
_hdOcollectErrors = rule682 _lhsIcollectErrors
_hdOcollectWarnings = rule683 _lhsIcollectWarnings
_hdOcounter = rule684 _lhsIcounter
_hdOcurrentChunk = rule685 _lhsIcurrentChunk
_hdOdictionaryEnvironment = rule686 _lhsIdictionaryEnvironment
_hdOimportEnvironment = rule687 _lhsIimportEnvironment
_hdOinheritedBDG = rule688 _lhsIinheritedBDG
_hdOmatchIO = rule689 _lhsImatchIO
_hdOmonos = rule690 _lhsImonos
_hdOnamesInScope = rule691 _lhsInamesInScope
_hdOorderedTypeSynonyms = rule692 _lhsIorderedTypeSynonyms
_hdOparentTree = rule693 _lhsIparentTree
_hdOpatternMatchWarnings = rule694 _lhsIpatternMatchWarnings
_hdOsubstitution = rule695 _lhsIsubstitution
_hdOtypeSignatures = rule696 _lhsItypeSignatures
_hdOtypeschemeMap = rule697 _lhsItypeschemeMap
_hdOuniqueChunk = rule698 _lhsIuniqueChunk
_tlOallPatterns = rule699 _lhsIallPatterns
_tlOallTypeSchemes = rule700 _lhsIallTypeSchemes
_tlOavailablePredicates = rule701 _lhsIavailablePredicates
_tlObetaUnique = rule702 _hdIbetaUnique
_tlObindingGroups = rule703 _hdIbindingGroups
_tlOclassEnvironment = rule704 _lhsIclassEnvironment
_tlOcollectErrors = rule705 _hdIcollectErrors
_tlOcollectWarnings = rule706 _hdIcollectWarnings
_tlOcounter = rule707 _hdIcounter
_tlOcurrentChunk = rule708 _lhsIcurrentChunk
_tlOdictionaryEnvironment = rule709 _hdIdictionaryEnvironment
_tlOimportEnvironment = rule710 _lhsIimportEnvironment
_tlOinheritedBDG = rule711 _lhsIinheritedBDG
_tlOmatchIO = rule712 _hdImatchIO
_tlOmonos = rule713 _lhsImonos
_tlOnamesInScope = rule714 _lhsInamesInScope
_tlOorderedTypeSynonyms = rule715 _lhsIorderedTypeSynonyms
_tlOparentTree = rule716 _lhsIparentTree
_tlOpatternMatchWarnings = rule717 _hdIpatternMatchWarnings
_tlOsubstitution = rule718 _lhsIsubstitution
_tlOtypeSignatures = rule719 _hdItypeSignatures
_tlOtypeschemeMap = rule720 _lhsItypeschemeMap
_tlOuniqueChunk = rule721 _hdIuniqueChunk
__result_ = T_Declarations_vOut31 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declarations_s32 v31
{-# INLINE rule658 #-}
rule658 = \ ((_hdIinfoTrees) :: InfoTrees) ((_tlIinfoTrees) :: InfoTrees) ->
_hdIinfoTrees ++ _tlIinfoTrees
{-# INLINE rule659 #-}
rule659 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
_hdIcollectInstances ++ _tlIcollectInstances
{-# INLINE rule660 #-}
rule660 = \ ((_hdIdeclVarNames) :: Names) ((_tlIdeclVarNames) :: Names) ->
_hdIdeclVarNames ++ _tlIdeclVarNames
{-# INLINE rule661 #-}
rule661 = \ ((_hdIrestrictedNames) :: Names) ((_tlIrestrictedNames) :: Names) ->
_hdIrestrictedNames ++ _tlIrestrictedNames
{-# INLINE rule662 #-}
rule662 = \ ((_hdIsimplePatNames) :: Names) ((_tlIsimplePatNames) :: Names) ->
_hdIsimplePatNames ++ _tlIsimplePatNames
{-# INLINE rule663 #-}
rule663 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
_hdIunboundNames ++ _tlIunboundNames
{-# INLINE rule664 #-}
rule664 = \ ((_hdIself) :: Declaration) ((_tlIself) :: Declarations) ->
(:) _hdIself _tlIself
{-# INLINE rule665 #-}
rule665 = \ _self ->
_self
{-# INLINE rule666 #-}
rule666 = \ ((_tlIbetaUnique) :: Int) ->
_tlIbetaUnique
{-# INLINE rule667 #-}
rule667 = \ ((_tlIbindingGroups) :: BindingGroups) ->
_tlIbindingGroups
{-# INLINE rule668 #-}
rule668 = \ ((_tlIcollectErrors) :: TypeErrors) ->
_tlIcollectErrors
{-# INLINE rule669 #-}
rule669 = \ ((_tlIcollectWarnings) :: Warnings) ->
_tlIcollectWarnings
{-# INLINE rule670 #-}
rule670 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule671 #-}
rule671 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
_tlIdictionaryEnvironment
{-# INLINE rule672 #-}
rule672 = \ ((_tlImatchIO) :: IO ()) ->
_tlImatchIO
{-# INLINE rule673 #-}
rule673 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
_tlIpatternMatchWarnings
{-# INLINE rule674 #-}
rule674 = \ ((_tlItypeSignatures) :: TypeEnvironment) ->
_tlItypeSignatures
{-# INLINE rule675 #-}
rule675 = \ ((_tlIuniqueChunk) :: Int) ->
_tlIuniqueChunk
{-# INLINE rule676 #-}
rule676 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule677 #-}
rule677 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule678 #-}
rule678 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule679 #-}
rule679 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule680 #-}
rule680 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
_lhsIbindingGroups
{-# INLINE rule681 #-}
rule681 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule682 #-}
rule682 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule683 #-}
rule683 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule684 #-}
rule684 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule685 #-}
rule685 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule686 #-}
rule686 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule687 #-}
rule687 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule688 #-}
rule688 = \ ((_lhsIinheritedBDG) :: InheritedBDG) ->
_lhsIinheritedBDG
{-# INLINE rule689 #-}
rule689 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule690 #-}
rule690 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule691 #-}
rule691 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule692 #-}
rule692 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule693 #-}
rule693 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule694 #-}
rule694 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule695 #-}
rule695 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule696 #-}
rule696 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule697 #-}
rule697 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule698 #-}
rule698 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule699 #-}
rule699 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule700 #-}
rule700 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule701 #-}
rule701 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule702 #-}
rule702 = \ ((_hdIbetaUnique) :: Int) ->
_hdIbetaUnique
{-# INLINE rule703 #-}
rule703 = \ ((_hdIbindingGroups) :: BindingGroups) ->
_hdIbindingGroups
{-# INLINE rule704 #-}
rule704 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule705 #-}
rule705 = \ ((_hdIcollectErrors) :: TypeErrors) ->
_hdIcollectErrors
{-# INLINE rule706 #-}
rule706 = \ ((_hdIcollectWarnings) :: Warnings) ->
_hdIcollectWarnings
{-# INLINE rule707 #-}
rule707 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule708 #-}
rule708 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule709 #-}
rule709 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
_hdIdictionaryEnvironment
{-# INLINE rule710 #-}
rule710 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule711 #-}
rule711 = \ ((_lhsIinheritedBDG) :: InheritedBDG) ->
_lhsIinheritedBDG
{-# INLINE rule712 #-}
rule712 = \ ((_hdImatchIO) :: IO ()) ->
_hdImatchIO
{-# INLINE rule713 #-}
rule713 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule714 #-}
rule714 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule715 #-}
rule715 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule716 #-}
rule716 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule717 #-}
rule717 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
_hdIpatternMatchWarnings
{-# INLINE rule718 #-}
rule718 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule719 #-}
rule719 = \ ((_hdItypeSignatures) :: TypeEnvironment) ->
_hdItypeSignatures
{-# INLINE rule720 #-}
rule720 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule721 #-}
rule721 = \ ((_hdIuniqueChunk) :: Int) ->
_hdIuniqueChunk
{-# NOINLINE sem_Declarations_Nil #-}
sem_Declarations_Nil :: T_Declarations
sem_Declarations_Nil = T_Declarations (return st32) where
{-# NOINLINE st32 #-}
st32 = let
v31 :: T_Declarations_v31
v31 = \ (T_Declarations_vIn31 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule722 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule723 ()
_lhsOdeclVarNames :: Names
_lhsOdeclVarNames = rule724 ()
_lhsOrestrictedNames :: Names
_lhsOrestrictedNames = rule725 ()
_lhsOsimplePatNames :: Names
_lhsOsimplePatNames = rule726 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule727 ()
_self = rule728 ()
_lhsOself :: Declarations
_lhsOself = rule729 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule730 _lhsIbetaUnique
_lhsObindingGroups :: BindingGroups
_lhsObindingGroups = rule731 _lhsIbindingGroups
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule732 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule733 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule734 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule735 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule736 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule737 _lhsIpatternMatchWarnings
_lhsOtypeSignatures :: TypeEnvironment
_lhsOtypeSignatures = rule738 _lhsItypeSignatures
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule739 _lhsIuniqueChunk
__result_ = T_Declarations_vOut31 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_Declarations_s32 v31
{-# INLINE rule722 #-}
rule722 = \ (_ :: ()) ->
[]
{-# INLINE rule723 #-}
rule723 = \ (_ :: ()) ->
[]
{-# INLINE rule724 #-}
rule724 = \ (_ :: ()) ->
[]
{-# INLINE rule725 #-}
rule725 = \ (_ :: ()) ->
[]
{-# INLINE rule726 #-}
rule726 = \ (_ :: ()) ->
[]
{-# INLINE rule727 #-}
rule727 = \ (_ :: ()) ->
[]
{-# INLINE rule728 #-}
rule728 = \ (_ :: ()) ->
[]
{-# INLINE rule729 #-}
rule729 = \ _self ->
_self
{-# INLINE rule730 #-}
rule730 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule731 #-}
rule731 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
_lhsIbindingGroups
{-# INLINE rule732 #-}
rule732 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule733 #-}
rule733 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule734 #-}
rule734 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule735 #-}
rule735 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule736 #-}
rule736 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule737 #-}
rule737 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule738 #-}
rule738 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
_lhsItypeSignatures
{-# INLINE rule739 #-}
rule739 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
-- Export ------------------------------------------------------
-- wrapper
data Inh_Export = Inh_Export { }
data Syn_Export = Syn_Export { self_Syn_Export :: (Export) }
{-# INLINABLE wrap_Export #-}
wrap_Export :: T_Export -> Inh_Export -> (Syn_Export )
wrap_Export (T_Export act) (Inh_Export ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Export_vIn34
(T_Export_vOut34 _lhsOself) <- return (inv_Export_s35 sem arg)
return (Syn_Export _lhsOself)
)
-- cata
{-# NOINLINE sem_Export #-}
sem_Export :: Export -> T_Export
sem_Export ( Export_Variable range_ name_ ) = sem_Export_Variable ( sem_Range range_ ) ( sem_Name name_ )
sem_Export ( Export_TypeOrClass range_ name_ names_ ) = sem_Export_TypeOrClass ( sem_Range range_ ) ( sem_Name name_ ) ( sem_MaybeNames names_ )
sem_Export ( Export_TypeOrClassComplete range_ name_ ) = sem_Export_TypeOrClassComplete ( sem_Range range_ ) ( sem_Name name_ )
sem_Export ( Export_Module range_ name_ ) = sem_Export_Module ( sem_Range range_ ) ( sem_Name name_ )
-- semantic domain
newtype T_Export = T_Export {
attach_T_Export :: Identity (T_Export_s35 )
}
newtype T_Export_s35 = C_Export_s35 {
inv_Export_s35 :: (T_Export_v34 )
}
data T_Export_s36 = C_Export_s36
type T_Export_v34 = (T_Export_vIn34 ) -> (T_Export_vOut34 )
data T_Export_vIn34 = T_Export_vIn34
data T_Export_vOut34 = T_Export_vOut34 (Export)
{-# NOINLINE sem_Export_Variable #-}
sem_Export_Variable :: T_Range -> T_Name -> T_Export
sem_Export_Variable arg_range_ arg_name_ = T_Export (return st35) where
{-# NOINLINE st35 #-}
st35 = let
v34 :: T_Export_v34
v34 = \ (T_Export_vIn34 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
_self = rule740 _nameIself _rangeIself
_lhsOself :: Export
_lhsOself = rule741 _self
__result_ = T_Export_vOut34 _lhsOself
in __result_ )
in C_Export_s35 v34
{-# INLINE rule740 #-}
rule740 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
Export_Variable _rangeIself _nameIself
{-# INLINE rule741 #-}
rule741 = \ _self ->
_self
{-# NOINLINE sem_Export_TypeOrClass #-}
sem_Export_TypeOrClass :: T_Range -> T_Name -> T_MaybeNames -> T_Export
sem_Export_TypeOrClass arg_range_ arg_name_ arg_names_ = T_Export (return st35) where
{-# NOINLINE st35 #-}
st35 = let
v34 :: T_Export_v34
v34 = \ (T_Export_vIn34 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_namesX107 = Control.Monad.Identity.runIdentity (attach_T_MaybeNames (arg_names_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_MaybeNames_vOut106 _namesIself) = inv_MaybeNames_s107 _namesX107 (T_MaybeNames_vIn106 )
_self = rule742 _nameIself _namesIself _rangeIself
_lhsOself :: Export
_lhsOself = rule743 _self
__result_ = T_Export_vOut34 _lhsOself
in __result_ )
in C_Export_s35 v34
{-# INLINE rule742 #-}
rule742 = \ ((_nameIself) :: Name) ((_namesIself) :: MaybeNames) ((_rangeIself) :: Range) ->
Export_TypeOrClass _rangeIself _nameIself _namesIself
{-# INLINE rule743 #-}
rule743 = \ _self ->
_self
{-# NOINLINE sem_Export_TypeOrClassComplete #-}
sem_Export_TypeOrClassComplete :: T_Range -> T_Name -> T_Export
sem_Export_TypeOrClassComplete arg_range_ arg_name_ = T_Export (return st35) where
{-# NOINLINE st35 #-}
st35 = let
v34 :: T_Export_v34
v34 = \ (T_Export_vIn34 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
_self = rule744 _nameIself _rangeIself
_lhsOself :: Export
_lhsOself = rule745 _self
__result_ = T_Export_vOut34 _lhsOself
in __result_ )
in C_Export_s35 v34
{-# INLINE rule744 #-}
rule744 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
Export_TypeOrClassComplete _rangeIself _nameIself
{-# INLINE rule745 #-}
rule745 = \ _self ->
_self
{-# NOINLINE sem_Export_Module #-}
sem_Export_Module :: T_Range -> T_Name -> T_Export
sem_Export_Module arg_range_ arg_name_ = T_Export (return st35) where
{-# NOINLINE st35 #-}
st35 = let
v34 :: T_Export_v34
v34 = \ (T_Export_vIn34 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
_self = rule746 _nameIself _rangeIself
_lhsOself :: Export
_lhsOself = rule747 _self
__result_ = T_Export_vOut34 _lhsOself
in __result_ )
in C_Export_s35 v34
{-# INLINE rule746 #-}
rule746 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
Export_Module _rangeIself _nameIself
{-# INLINE rule747 #-}
rule747 = \ _self ->
_self
-- Exports -----------------------------------------------------
-- wrapper
data Inh_Exports = Inh_Exports { }
data Syn_Exports = Syn_Exports { self_Syn_Exports :: (Exports) }
{-# INLINABLE wrap_Exports #-}
wrap_Exports :: T_Exports -> Inh_Exports -> (Syn_Exports )
wrap_Exports (T_Exports act) (Inh_Exports ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Exports_vIn37
(T_Exports_vOut37 _lhsOself) <- return (inv_Exports_s38 sem arg)
return (Syn_Exports _lhsOself)
)
-- cata
{-# NOINLINE sem_Exports #-}
sem_Exports :: Exports -> T_Exports
sem_Exports list = Prelude.foldr sem_Exports_Cons sem_Exports_Nil (Prelude.map sem_Export list)
-- semantic domain
newtype T_Exports = T_Exports {
attach_T_Exports :: Identity (T_Exports_s38 )
}
newtype T_Exports_s38 = C_Exports_s38 {
inv_Exports_s38 :: (T_Exports_v37 )
}
data T_Exports_s39 = C_Exports_s39
type T_Exports_v37 = (T_Exports_vIn37 ) -> (T_Exports_vOut37 )
data T_Exports_vIn37 = T_Exports_vIn37
data T_Exports_vOut37 = T_Exports_vOut37 (Exports)
{-# NOINLINE sem_Exports_Cons #-}
sem_Exports_Cons :: T_Export -> T_Exports -> T_Exports
sem_Exports_Cons arg_hd_ arg_tl_ = T_Exports (return st38) where
{-# NOINLINE st38 #-}
st38 = let
v37 :: T_Exports_v37
v37 = \ (T_Exports_vIn37 ) -> ( let
_hdX35 = Control.Monad.Identity.runIdentity (attach_T_Export (arg_hd_))
_tlX38 = Control.Monad.Identity.runIdentity (attach_T_Exports (arg_tl_))
(T_Export_vOut34 _hdIself) = inv_Export_s35 _hdX35 (T_Export_vIn34 )
(T_Exports_vOut37 _tlIself) = inv_Exports_s38 _tlX38 (T_Exports_vIn37 )
_self = rule748 _hdIself _tlIself
_lhsOself :: Exports
_lhsOself = rule749 _self
__result_ = T_Exports_vOut37 _lhsOself
in __result_ )
in C_Exports_s38 v37
{-# INLINE rule748 #-}
rule748 = \ ((_hdIself) :: Export) ((_tlIself) :: Exports) ->
(:) _hdIself _tlIself
{-# INLINE rule749 #-}
rule749 = \ _self ->
_self
{-# NOINLINE sem_Exports_Nil #-}
sem_Exports_Nil :: T_Exports
sem_Exports_Nil = T_Exports (return st38) where
{-# NOINLINE st38 #-}
st38 = let
v37 :: T_Exports_v37
v37 = \ (T_Exports_vIn37 ) -> ( let
_self = rule750 ()
_lhsOself :: Exports
_lhsOself = rule751 _self
__result_ = T_Exports_vOut37 _lhsOself
in __result_ )
in C_Exports_s38 v37
{-# INLINE rule750 #-}
rule750 = \ (_ :: ()) ->
[]
{-# INLINE rule751 #-}
rule751 = \ _self ->
_self
-- Expression --------------------------------------------------
-- wrapper
data Inh_Expression = Inh_Expression { allPatterns_Inh_Expression :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Expression :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Expression :: (Predicates), betaUnique_Inh_Expression :: (Int), classEnvironment_Inh_Expression :: (ClassEnvironment), collectErrors_Inh_Expression :: (TypeErrors), collectWarnings_Inh_Expression :: (Warnings), counter_Inh_Expression :: (Int), currentChunk_Inh_Expression :: (Int), dictionaryEnvironment_Inh_Expression :: (DictionaryEnvironment), importEnvironment_Inh_Expression :: (ImportEnvironment), matchIO_Inh_Expression :: (IO ()), monos_Inh_Expression :: (Monos), namesInScope_Inh_Expression :: (Names), orderedTypeSynonyms_Inh_Expression :: (OrderedTypeSynonyms), parentTree_Inh_Expression :: (InfoTree), patternMatchWarnings_Inh_Expression :: ([Warning]), substitution_Inh_Expression :: (FixpointSubstitution), tryPatterns_Inh_Expression :: ([(Expression , [String])]), typeschemeMap_Inh_Expression :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Expression :: (Int), uniqueSecondRound_Inh_Expression :: (Int) }
data Syn_Expression = Syn_Expression { assumptions_Syn_Expression :: (Assumptions), beta_Syn_Expression :: (Tp), betaUnique_Syn_Expression :: (Int), collectErrors_Syn_Expression :: (TypeErrors), collectInstances_Syn_Expression :: ([(Name, Instance)]), collectWarnings_Syn_Expression :: (Warnings), constraints_Syn_Expression :: (ConstraintSet), counter_Syn_Expression :: (Int), dictionaryEnvironment_Syn_Expression :: (DictionaryEnvironment), infoTree_Syn_Expression :: (InfoTree), matchIO_Syn_Expression :: (IO ()), matches_Syn_Expression :: ([Maybe MetaVariableTable]), patternMatchWarnings_Syn_Expression :: ([Warning]), self_Syn_Expression :: (Expression), unboundNames_Syn_Expression :: (Names), uniqueChunk_Syn_Expression :: (Int), uniqueSecondRound_Syn_Expression :: (Int) }
{-# INLINABLE wrap_Expression #-}
wrap_Expression :: T_Expression -> Inh_Expression -> (Syn_Expression )
wrap_Expression (T_Expression act) (Inh_Expression _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound
(T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_Expression_s41 sem arg)
return (Syn_Expression _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
)
-- cata
{-# NOINLINE sem_Expression #-}
sem_Expression :: Expression -> T_Expression
sem_Expression ( Expression_Hole range_ id_ ) = sem_Expression_Hole ( sem_Range range_ ) id_
sem_Expression ( Expression_Feedback range_ feedback_ expression_ ) = sem_Expression_Feedback ( sem_Range range_ ) feedback_ ( sem_Expression expression_ )
sem_Expression ( Expression_MustUse range_ expression_ ) = sem_Expression_MustUse ( sem_Range range_ ) ( sem_Expression expression_ )
sem_Expression ( Expression_Literal range_ literal_ ) = sem_Expression_Literal ( sem_Range range_ ) ( sem_Literal literal_ )
sem_Expression ( Expression_Variable range_ name_ ) = sem_Expression_Variable ( sem_Range range_ ) ( sem_Name name_ )
sem_Expression ( Expression_Constructor range_ name_ ) = sem_Expression_Constructor ( sem_Range range_ ) ( sem_Name name_ )
sem_Expression ( Expression_Parenthesized range_ expression_ ) = sem_Expression_Parenthesized ( sem_Range range_ ) ( sem_Expression expression_ )
sem_Expression ( Expression_NormalApplication range_ function_ arguments_ ) = sem_Expression_NormalApplication ( sem_Range range_ ) ( sem_Expression function_ ) ( sem_Expressions arguments_ )
sem_Expression ( Expression_InfixApplication range_ leftExpression_ operator_ rightExpression_ ) = sem_Expression_InfixApplication ( sem_Range range_ ) ( sem_MaybeExpression leftExpression_ ) ( sem_Expression operator_ ) ( sem_MaybeExpression rightExpression_ )
sem_Expression ( Expression_If range_ guardExpression_ thenExpression_ elseExpression_ ) = sem_Expression_If ( sem_Range range_ ) ( sem_Expression guardExpression_ ) ( sem_Expression thenExpression_ ) ( sem_Expression elseExpression_ )
sem_Expression ( Expression_Lambda range_ patterns_ expression_ ) = sem_Expression_Lambda ( sem_Range range_ ) ( sem_Patterns patterns_ ) ( sem_Expression expression_ )
sem_Expression ( Expression_Case range_ expression_ alternatives_ ) = sem_Expression_Case ( sem_Range range_ ) ( sem_Expression expression_ ) ( sem_Alternatives alternatives_ )
sem_Expression ( Expression_Let range_ declarations_ expression_ ) = sem_Expression_Let ( sem_Range range_ ) ( sem_Declarations declarations_ ) ( sem_Expression expression_ )
sem_Expression ( Expression_Do range_ statements_ ) = sem_Expression_Do ( sem_Range range_ ) ( sem_Statements statements_ )
sem_Expression ( Expression_List range_ expressions_ ) = sem_Expression_List ( sem_Range range_ ) ( sem_Expressions expressions_ )
sem_Expression ( Expression_Tuple range_ expressions_ ) = sem_Expression_Tuple ( sem_Range range_ ) ( sem_Expressions expressions_ )
sem_Expression ( Expression_Comprehension range_ expression_ qualifiers_ ) = sem_Expression_Comprehension ( sem_Range range_ ) ( sem_Expression expression_ ) ( sem_Qualifiers qualifiers_ )
sem_Expression ( Expression_Typed range_ expression_ type_ ) = sem_Expression_Typed ( sem_Range range_ ) ( sem_Expression expression_ ) ( sem_Type type_ )
sem_Expression ( Expression_RecordConstruction range_ name_ recordExpressionBindings_ ) = sem_Expression_RecordConstruction ( sem_Range range_ ) ( sem_Name name_ ) ( sem_RecordExpressionBindings recordExpressionBindings_ )
sem_Expression ( Expression_RecordUpdate range_ expression_ recordExpressionBindings_ ) = sem_Expression_RecordUpdate ( sem_Range range_ ) ( sem_Expression expression_ ) ( sem_RecordExpressionBindings recordExpressionBindings_ )
sem_Expression ( Expression_Enum range_ from_ then_ to_ ) = sem_Expression_Enum ( sem_Range range_ ) ( sem_Expression from_ ) ( sem_MaybeExpression then_ ) ( sem_MaybeExpression to_ )
sem_Expression ( Expression_Negate range_ expression_ ) = sem_Expression_Negate ( sem_Range range_ ) ( sem_Expression expression_ )
sem_Expression ( Expression_NegateFloat range_ expression_ ) = sem_Expression_NegateFloat ( sem_Range range_ ) ( sem_Expression expression_ )
-- semantic domain
newtype T_Expression = T_Expression {
attach_T_Expression :: Identity (T_Expression_s41 )
}
newtype T_Expression_s41 = C_Expression_s41 {
inv_Expression_s41 :: (T_Expression_v40 )
}
data T_Expression_s42 = C_Expression_s42
type T_Expression_v40 = (T_Expression_vIn40 ) -> (T_Expression_vOut40 )
data T_Expression_vIn40 = T_Expression_vIn40 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) ([(Expression , [String])]) (M.Map Int (Scheme Predicates)) (Int) (Int)
data T_Expression_vOut40 = T_Expression_vOut40 (Assumptions) (Tp) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (InfoTree) (IO ()) ([Maybe MetaVariableTable]) ([Warning]) (Expression) (Names) (Int) (Int)
{-# NOINLINE sem_Expression_Hole #-}
sem_Expression_Hole :: T_Range -> (Integer) -> T_Expression
sem_Expression_Hole arg_range_ arg_id_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_lhsObetaUnique :: Int
_lhsObetaUnique = rule752 _lhsIbetaUnique
_assumptions = rule753 ()
_constraints = rule754 ()
_beta = rule755 _lhsIbetaUnique
_localInfo = rule756 _beta _lhsImonos _self
_parentTree = rule757 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule758 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOconstraints :: ConstraintSet
_lhsOassumptions :: Assumptions
_lhsOuniqueSecondRound :: Int
((),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule759 _assumptions _constraints _lhsIallPatterns _lhsItryPatterns _lhsIuniqueSecondRound _localInfo
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule760 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule761 ()
_self = rule762 _rangeIself arg_id_
_lhsOself :: Expression
_lhsOself = rule763 _self
_lhsObeta :: Tp
_lhsObeta = rule764 _beta
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule765 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule766 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule767 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule768 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule769 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule770 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule771 _lhsIuniqueChunk
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule752 #-}
rule752 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule753 #-}
rule753 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule754 #-}
rule754 = \ (_ :: ()) ->
emptyTree
{-# INLINE rule755 #-}
rule755 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule756 #-}
rule756 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule757 #-}
rule757 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule758 #-}
rule758 = \ _parentTree ->
_parentTree
{-# INLINE rule759 #-}
rule759 = \ _assumptions _constraints ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression , [String])]) ((_lhsIuniqueSecondRound) :: Int) _localInfo ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in match0 infoTuple _lhsIuniqueSecondRound
(const Nothing)
_lhsItryPatterns _lhsIallPatterns
[]
{-# INLINE rule760 #-}
rule760 = \ (_ :: ()) ->
[]
{-# INLINE rule761 #-}
rule761 = \ (_ :: ()) ->
[]
{-# INLINE rule762 #-}
rule762 = \ ((_rangeIself) :: Range) id_ ->
Expression_Hole _rangeIself id_
{-# INLINE rule763 #-}
rule763 = \ _self ->
_self
{-# INLINE rule764 #-}
rule764 = \ _beta ->
_beta
{-# INLINE rule765 #-}
rule765 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule766 #-}
rule766 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule767 #-}
rule767 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule768 #-}
rule768 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule769 #-}
rule769 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule770 #-}
rule770 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule771 #-}
rule771 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Expression_Feedback #-}
sem_Expression_Feedback :: T_Range -> (String) -> T_Expression -> T_Expression
sem_Expression_Feedback arg_range_ arg_feedback_ arg_expression_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule772 _expressionIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule773 _expressionIunboundNames
_self = rule774 _expressionIself _rangeIself arg_feedback_
_lhsOself :: Expression
_lhsOself = rule775 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule776 _expressionIassumptions
_lhsObeta :: Tp
_lhsObeta = rule777 _expressionIbeta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule778 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule779 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule780 _expressionIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule781 _expressionIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule782 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule783 _expressionIdictionaryEnvironment
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule784 _expressionIinfoTree
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule785 _expressionImatchIO
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOmatches = rule786 _expressionImatches
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule787 _expressionIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule788 _expressionIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule789 _expressionIuniqueSecondRound
_expressionOallPatterns = rule790 _lhsIallPatterns
_expressionOallTypeSchemes = rule791 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule792 _lhsIavailablePredicates
_expressionObetaUnique = rule793 _lhsIbetaUnique
_expressionOclassEnvironment = rule794 _lhsIclassEnvironment
_expressionOcollectErrors = rule795 _lhsIcollectErrors
_expressionOcollectWarnings = rule796 _lhsIcollectWarnings
_expressionOcounter = rule797 _lhsIcounter
_expressionOcurrentChunk = rule798 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule799 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule800 _lhsIimportEnvironment
_expressionOmatchIO = rule801 _lhsImatchIO
_expressionOmonos = rule802 _lhsImonos
_expressionOnamesInScope = rule803 _lhsInamesInScope
_expressionOorderedTypeSynonyms = rule804 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule805 _lhsIparentTree
_expressionOpatternMatchWarnings = rule806 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule807 _lhsIsubstitution
_expressionOtryPatterns = rule808 _lhsItryPatterns
_expressionOtypeschemeMap = rule809 _lhsItypeschemeMap
_expressionOuniqueChunk = rule810 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule811 _lhsIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule772 #-}
rule772 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances
{-# INLINE rule773 #-}
rule773 = \ ((_expressionIunboundNames) :: Names) ->
_expressionIunboundNames
{-# INLINE rule774 #-}
rule774 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) feedback_ ->
Expression_Feedback _rangeIself feedback_ _expressionIself
{-# INLINE rule775 #-}
rule775 = \ _self ->
_self
{-# INLINE rule776 #-}
rule776 = \ ((_expressionIassumptions) :: Assumptions) ->
_expressionIassumptions
{-# INLINE rule777 #-}
rule777 = \ ((_expressionIbeta) :: Tp) ->
_expressionIbeta
{-# INLINE rule778 #-}
rule778 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule779 #-}
rule779 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule780 #-}
rule780 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule781 #-}
rule781 = \ ((_expressionIconstraints) :: ConstraintSet) ->
_expressionIconstraints
{-# INLINE rule782 #-}
rule782 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule783 #-}
rule783 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule784 #-}
rule784 = \ ((_expressionIinfoTree) :: InfoTree) ->
_expressionIinfoTree
{-# INLINE rule785 #-}
rule785 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule786 #-}
rule786 = \ ((_expressionImatches) :: [Maybe MetaVariableTable]) ->
_expressionImatches
{-# INLINE rule787 #-}
rule787 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule788 #-}
rule788 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule789 #-}
rule789 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule790 #-}
rule790 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule791 #-}
rule791 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule792 #-}
rule792 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule793 #-}
rule793 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule794 #-}
rule794 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule795 #-}
rule795 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule796 #-}
rule796 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule797 #-}
rule797 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule798 #-}
rule798 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule799 #-}
rule799 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule800 #-}
rule800 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule801 #-}
rule801 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule802 #-}
rule802 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule803 #-}
rule803 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule804 #-}
rule804 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule805 #-}
rule805 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule806 #-}
rule806 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule807 #-}
rule807 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule808 #-}
rule808 = \ ((_lhsItryPatterns) :: [(Expression , [String])]) ->
_lhsItryPatterns
{-# INLINE rule809 #-}
rule809 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule810 #-}
rule810 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule811 #-}
rule811 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_MustUse #-}
sem_Expression_MustUse :: T_Range -> T_Expression -> T_Expression
sem_Expression_MustUse arg_range_ arg_expression_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule812 _expressionIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule813 _expressionIunboundNames
_self = rule814 _expressionIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule815 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule816 _expressionIassumptions
_lhsObeta :: Tp
_lhsObeta = rule817 _expressionIbeta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule818 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule819 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule820 _expressionIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule821 _expressionIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule822 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule823 _expressionIdictionaryEnvironment
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule824 _expressionIinfoTree
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule825 _expressionImatchIO
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOmatches = rule826 _expressionImatches
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule827 _expressionIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule828 _expressionIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule829 _expressionIuniqueSecondRound
_expressionOallPatterns = rule830 _lhsIallPatterns
_expressionOallTypeSchemes = rule831 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule832 _lhsIavailablePredicates
_expressionObetaUnique = rule833 _lhsIbetaUnique
_expressionOclassEnvironment = rule834 _lhsIclassEnvironment
_expressionOcollectErrors = rule835 _lhsIcollectErrors
_expressionOcollectWarnings = rule836 _lhsIcollectWarnings
_expressionOcounter = rule837 _lhsIcounter
_expressionOcurrentChunk = rule838 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule839 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule840 _lhsIimportEnvironment
_expressionOmatchIO = rule841 _lhsImatchIO
_expressionOmonos = rule842 _lhsImonos
_expressionOnamesInScope = rule843 _lhsInamesInScope
_expressionOorderedTypeSynonyms = rule844 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule845 _lhsIparentTree
_expressionOpatternMatchWarnings = rule846 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule847 _lhsIsubstitution
_expressionOtryPatterns = rule848 _lhsItryPatterns
_expressionOtypeschemeMap = rule849 _lhsItypeschemeMap
_expressionOuniqueChunk = rule850 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule851 _lhsIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule812 #-}
rule812 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances
{-# INLINE rule813 #-}
rule813 = \ ((_expressionIunboundNames) :: Names) ->
_expressionIunboundNames
{-# INLINE rule814 #-}
rule814 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
Expression_MustUse _rangeIself _expressionIself
{-# INLINE rule815 #-}
rule815 = \ _self ->
_self
{-# INLINE rule816 #-}
rule816 = \ ((_expressionIassumptions) :: Assumptions) ->
_expressionIassumptions
{-# INLINE rule817 #-}
rule817 = \ ((_expressionIbeta) :: Tp) ->
_expressionIbeta
{-# INLINE rule818 #-}
rule818 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule819 #-}
rule819 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule820 #-}
rule820 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule821 #-}
rule821 = \ ((_expressionIconstraints) :: ConstraintSet) ->
_expressionIconstraints
{-# INLINE rule822 #-}
rule822 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule823 #-}
rule823 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule824 #-}
rule824 = \ ((_expressionIinfoTree) :: InfoTree) ->
_expressionIinfoTree
{-# INLINE rule825 #-}
rule825 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule826 #-}
rule826 = \ ((_expressionImatches) :: [Maybe MetaVariableTable]) ->
_expressionImatches
{-# INLINE rule827 #-}
rule827 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule828 #-}
rule828 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule829 #-}
rule829 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule830 #-}
rule830 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule831 #-}
rule831 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule832 #-}
rule832 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule833 #-}
rule833 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule834 #-}
rule834 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule835 #-}
rule835 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule836 #-}
rule836 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule837 #-}
rule837 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule838 #-}
rule838 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule839 #-}
rule839 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule840 #-}
rule840 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule841 #-}
rule841 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule842 #-}
rule842 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule843 #-}
rule843 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule844 #-}
rule844 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule845 #-}
rule845 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule846 #-}
rule846 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule847 #-}
rule847 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule848 #-}
rule848 = \ ((_lhsItryPatterns) :: [(Expression , [String])]) ->
_lhsItryPatterns
{-# INLINE rule849 #-}
rule849 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule850 #-}
rule850 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule851 #-}
rule851 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_Literal #-}
sem_Expression_Literal :: T_Range -> T_Literal -> T_Expression
sem_Expression_Literal arg_range_ arg_literal_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_literalX86 = Control.Monad.Identity.runIdentity (attach_T_Literal (arg_literal_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Literal_vOut85 _literalIelements _literalIliteralType _literalIself) = inv_Literal_s86 _literalX86 (T_Literal_vIn85 )
_lhsObetaUnique :: Int
_lhsObetaUnique = rule852 _lhsIbetaUnique
_assumptions = rule853 ()
_constraints = rule854 _beta _cinfo _literalIliteralType
_beta = rule855 _lhsIbetaUnique
_cinfo = rule856 _parentTree
_localInfo = rule857 _beta _lhsImonos _self
_parentTree = rule858 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule859 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOconstraints :: ConstraintSet
_lhsOassumptions :: Assumptions
_lhsOuniqueSecondRound :: Int
((),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule860 _assumptions _constraints _lhsIallPatterns _lhsItryPatterns _lhsIuniqueSecondRound _literalIself _localInfo
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule861 _ioMatch _lhsImatchIO
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule862 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule863 ()
_self = rule864 _literalIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule865 _self
_lhsObeta :: Tp
_lhsObeta = rule866 _beta
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule867 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule868 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule869 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule870 _lhsIdictionaryEnvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule871 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule872 _lhsIuniqueChunk
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule852 #-}
rule852 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule853 #-}
rule853 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule854 #-}
rule854 = \ _beta _cinfo ((_literalIliteralType) :: Tp) ->
unitTree ((_literalIliteralType .==. _beta) _cinfo)
{-# INLINE rule855 #-}
rule855 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule856 #-}
rule856 = \ _parentTree ->
resultConstraint "literal" _parentTree
[ FolkloreConstraint, HasTrustFactor 10.0 ]
{-# INLINE rule857 #-}
rule857 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule858 #-}
rule858 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule859 #-}
rule859 = \ _parentTree ->
_parentTree
{-# INLINE rule860 #-}
rule860 = \ _assumptions _constraints ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression , [String])]) ((_lhsIuniqueSecondRound) :: Int) ((_literalIself) :: Literal) _localInfo ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in match0 infoTuple _lhsIuniqueSecondRound
(match_Expression_Literal _literalIself)
_lhsItryPatterns _lhsIallPatterns
[]
{-# INLINE rule861 #-}
rule861 = \ _ioMatch ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO >> _ioMatch
{-# INLINE rule862 #-}
rule862 = \ (_ :: ()) ->
[]
{-# INLINE rule863 #-}
rule863 = \ (_ :: ()) ->
[]
{-# INLINE rule864 #-}
rule864 = \ ((_literalIself) :: Literal) ((_rangeIself) :: Range) ->
Expression_Literal _rangeIself _literalIself
{-# INLINE rule865 #-}
rule865 = \ _self ->
_self
{-# INLINE rule866 #-}
rule866 = \ _beta ->
_beta
{-# INLINE rule867 #-}
rule867 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule868 #-}
rule868 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule869 #-}
rule869 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule870 #-}
rule870 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule871 #-}
rule871 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule872 #-}
rule872 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Expression_Variable #-}
sem_Expression_Variable :: T_Range -> T_Name -> T_Expression
sem_Expression_Variable arg_range_ arg_name_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
_lhsObetaUnique :: Int
_lhsObetaUnique = rule873 _lhsIbetaUnique
_assumptions = rule874 _beta _nameIself
_constraints = rule875 _lhsIbetaUnique
_beta = rule876 _lhsIbetaUnique
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule877 _newDEnv
_nameInScope = rule878 _lhsInamesInScope _nameIself
_maybeInferredType = rule879 _lhsIallTypeSchemes _nameInScope
_requiredDictionaries = rule880 _lhsIimportEnvironment _lhsIsubstitution _maybeInferredType _usedAsType
_newDEnv = rule881 _lhsIavailablePredicates _lhsIclassEnvironment _lhsIdictionaryEnvironment _lhsIsubstitution _nameIself _requiredDictionaries
_usedAsType = rule882 _beta _lhsIsubstitution
_localInfo = rule883 _beta _lhsImonos _self
_parentTree = rule884 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule885 _parentTree
_lhsOunboundNames :: Names
_lhsOunboundNames = rule886 _nameIself
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOconstraints :: ConstraintSet
_lhsOassumptions :: Assumptions
_lhsOuniqueSecondRound :: Int
((),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule887 _assumptions _constraints _lhsIallPatterns _lhsItryPatterns _lhsIuniqueSecondRound _localInfo _nameIself
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule888 _ioMatch _lhsImatchIO
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule889 ()
_self = rule890 _nameIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule891 _self
_lhsObeta :: Tp
_lhsObeta = rule892 _beta
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule893 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule894 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule895 _lhsIcounter
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule896 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule897 _lhsIuniqueChunk
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule873 #-}
rule873 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule874 #-}
rule874 = \ _beta ((_nameIself) :: Name) ->
_nameIself `single` _beta
{-# INLINE rule875 #-}
rule875 = \ ((_lhsIbetaUnique) :: Int) ->
Node [ Receive _lhsIbetaUnique ]
{-# INLINE rule876 #-}
rule876 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule877 #-}
rule877 = \ _newDEnv ->
_newDEnv
{-# INLINE rule878 #-}
rule878 = \ ((_lhsInamesInScope) :: Names) ((_nameIself) :: Name) ->
case filter (_nameIself==) _lhsInamesInScope of
[name] -> NameWithRange name
_ -> internalError "TypeInferenceOverloading.ag" "n/a" "name not in scope"
{-# INLINE rule879 #-}
rule879 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) _nameInScope ->
M.lookup _nameInScope _lhsIallTypeSchemes
{-# INLINE rule880 #-}
rule880 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) _maybeInferredType _usedAsType ->
case _maybeInferredType of
Nothing -> []
Just scheme -> getRequiredDictionaries
(getOrderedTypeSynonyms _lhsIimportEnvironment)
(_lhsIsubstitution |-> _usedAsType)
(_lhsIsubstitution |-> scheme)
{-# INLINE rule881 #-}
rule881 = \ ((_lhsIavailablePredicates) :: Predicates) ((_lhsIclassEnvironment) :: ClassEnvironment) ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_nameIself) :: Name) _requiredDictionaries ->
resolveOverloading (_lhsIclassEnvironment)
_nameIself
(_lhsIsubstitution |-> _lhsIavailablePredicates)
(_lhsIsubstitution |-> _requiredDictionaries)
_lhsIdictionaryEnvironment
{-# INLINE rule882 #-}
rule882 = \ _beta ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution |-> _beta
{-# INLINE rule883 #-}
rule883 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule884 #-}
rule884 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule885 #-}
rule885 = \ _parentTree ->
_parentTree
{-# INLINE rule886 #-}
rule886 = \ ((_nameIself) :: Name) ->
[ _nameIself ]
{-# INLINE rule887 #-}
rule887 = \ _assumptions _constraints ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression , [String])]) ((_lhsIuniqueSecondRound) :: Int) _localInfo ((_nameIself) :: Name) ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in match0 infoTuple _lhsIuniqueSecondRound
(match_Expression_Variable _nameIself)
_lhsItryPatterns _lhsIallPatterns
[]
{-# INLINE rule888 #-}
rule888 = \ _ioMatch ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO >> _ioMatch
{-# INLINE rule889 #-}
rule889 = \ (_ :: ()) ->
[]
{-# INLINE rule890 #-}
rule890 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
Expression_Variable _rangeIself _nameIself
{-# INLINE rule891 #-}
rule891 = \ _self ->
_self
{-# INLINE rule892 #-}
rule892 = \ _beta ->
_beta
{-# INLINE rule893 #-}
rule893 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule894 #-}
rule894 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule895 #-}
rule895 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule896 #-}
rule896 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule897 #-}
rule897 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Expression_Constructor #-}
sem_Expression_Constructor :: T_Range -> T_Name -> T_Expression
sem_Expression_Constructor arg_range_ arg_name_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
_lhsObetaUnique :: Int
_lhsObetaUnique = rule898 _lhsIbetaUnique
_assumptions = rule899 ()
_constraints = rule900 _newcon
_beta = rule901 _lhsIbetaUnique
_newcon = rule902 _beta _cinfo _lhsIimportEnvironment _nameIself
_cinfo = rule903 _nameIself _parentTree
_localInfo = rule904 _beta _lhsImonos _self
_parentTree = rule905 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule906 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOconstraints :: ConstraintSet
_lhsOassumptions :: Assumptions
_lhsOuniqueSecondRound :: Int
((),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule907 _assumptions _constraints _lhsIallPatterns _lhsItryPatterns _lhsIuniqueSecondRound _localInfo _nameIself
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule908 _ioMatch _lhsImatchIO
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule909 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule910 ()
_self = rule911 _nameIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule912 _self
_lhsObeta :: Tp
_lhsObeta = rule913 _beta
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule914 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule915 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule916 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule917 _lhsIdictionaryEnvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule918 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule919 _lhsIuniqueChunk
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule898 #-}
rule898 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule899 #-}
rule899 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule900 #-}
rule900 = \ _newcon ->
listTree _newcon
{-# INLINE rule901 #-}
rule901 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule902 #-}
rule902 = \ _beta _cinfo ((_lhsIimportEnvironment) :: ImportEnvironment) ((_nameIself) :: Name) ->
case M.lookup _nameIself (valueConstructors _lhsIimportEnvironment) of
Nothing -> []
Just ctp -> [ (_beta .::. ctp) _cinfo ]
{-# INLINE rule903 #-}
rule903 = \ ((_nameIself) :: Name) _parentTree ->
resultConstraint "constructor" _parentTree
[ FolkloreConstraint, HasTrustFactor 10.0, IsImported _nameIself ]
{-# INLINE rule904 #-}
rule904 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule905 #-}
rule905 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule906 #-}
rule906 = \ _parentTree ->
_parentTree
{-# INLINE rule907 #-}
rule907 = \ _assumptions _constraints ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression , [String])]) ((_lhsIuniqueSecondRound) :: Int) _localInfo ((_nameIself) :: Name) ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in match0 infoTuple _lhsIuniqueSecondRound
(match_Expression_Constructor _nameIself)
_lhsItryPatterns _lhsIallPatterns
[]
{-# INLINE rule908 #-}
rule908 = \ _ioMatch ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO >> _ioMatch
{-# INLINE rule909 #-}
rule909 = \ (_ :: ()) ->
[]
{-# INLINE rule910 #-}
rule910 = \ (_ :: ()) ->
[]
{-# INLINE rule911 #-}
rule911 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
Expression_Constructor _rangeIself _nameIself
{-# INLINE rule912 #-}
rule912 = \ _self ->
_self
{-# INLINE rule913 #-}
rule913 = \ _beta ->
_beta
{-# INLINE rule914 #-}
rule914 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule915 #-}
rule915 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule916 #-}
rule916 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule917 #-}
rule917 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule918 #-}
rule918 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule919 #-}
rule919 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Expression_Parenthesized #-}
sem_Expression_Parenthesized :: T_Range -> T_Expression -> T_Expression
sem_Expression_Parenthesized arg_range_ arg_expression_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule920 _expressionIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule921 _expressionIunboundNames
_self = rule922 _expressionIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule923 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule924 _expressionIassumptions
_lhsObeta :: Tp
_lhsObeta = rule925 _expressionIbeta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule926 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule927 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule928 _expressionIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule929 _expressionIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule930 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule931 _expressionIdictionaryEnvironment
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule932 _expressionIinfoTree
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule933 _expressionImatchIO
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOmatches = rule934 _expressionImatches
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule935 _expressionIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule936 _expressionIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule937 _expressionIuniqueSecondRound
_expressionOallPatterns = rule938 _lhsIallPatterns
_expressionOallTypeSchemes = rule939 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule940 _lhsIavailablePredicates
_expressionObetaUnique = rule941 _lhsIbetaUnique
_expressionOclassEnvironment = rule942 _lhsIclassEnvironment
_expressionOcollectErrors = rule943 _lhsIcollectErrors
_expressionOcollectWarnings = rule944 _lhsIcollectWarnings
_expressionOcounter = rule945 _lhsIcounter
_expressionOcurrentChunk = rule946 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule947 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule948 _lhsIimportEnvironment
_expressionOmatchIO = rule949 _lhsImatchIO
_expressionOmonos = rule950 _lhsImonos
_expressionOnamesInScope = rule951 _lhsInamesInScope
_expressionOorderedTypeSynonyms = rule952 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule953 _lhsIparentTree
_expressionOpatternMatchWarnings = rule954 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule955 _lhsIsubstitution
_expressionOtryPatterns = rule956 _lhsItryPatterns
_expressionOtypeschemeMap = rule957 _lhsItypeschemeMap
_expressionOuniqueChunk = rule958 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule959 _lhsIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule920 #-}
rule920 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances
{-# INLINE rule921 #-}
rule921 = \ ((_expressionIunboundNames) :: Names) ->
_expressionIunboundNames
{-# INLINE rule922 #-}
rule922 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
Expression_Parenthesized _rangeIself _expressionIself
{-# INLINE rule923 #-}
rule923 = \ _self ->
_self
{-# INLINE rule924 #-}
rule924 = \ ((_expressionIassumptions) :: Assumptions) ->
_expressionIassumptions
{-# INLINE rule925 #-}
rule925 = \ ((_expressionIbeta) :: Tp) ->
_expressionIbeta
{-# INLINE rule926 #-}
rule926 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule927 #-}
rule927 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule928 #-}
rule928 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule929 #-}
rule929 = \ ((_expressionIconstraints) :: ConstraintSet) ->
_expressionIconstraints
{-# INLINE rule930 #-}
rule930 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule931 #-}
rule931 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule932 #-}
rule932 = \ ((_expressionIinfoTree) :: InfoTree) ->
_expressionIinfoTree
{-# INLINE rule933 #-}
rule933 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule934 #-}
rule934 = \ ((_expressionImatches) :: [Maybe MetaVariableTable]) ->
_expressionImatches
{-# INLINE rule935 #-}
rule935 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule936 #-}
rule936 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule937 #-}
rule937 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule938 #-}
rule938 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule939 #-}
rule939 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule940 #-}
rule940 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule941 #-}
rule941 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule942 #-}
rule942 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule943 #-}
rule943 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule944 #-}
rule944 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule945 #-}
rule945 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule946 #-}
rule946 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule947 #-}
rule947 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule948 #-}
rule948 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule949 #-}
rule949 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule950 #-}
rule950 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule951 #-}
rule951 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule952 #-}
rule952 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule953 #-}
rule953 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule954 #-}
rule954 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule955 #-}
rule955 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule956 #-}
rule956 = \ ((_lhsItryPatterns) :: [(Expression , [String])]) ->
_lhsItryPatterns
{-# INLINE rule957 #-}
rule957 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule958 #-}
rule958 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule959 #-}
rule959 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_NormalApplication #-}
sem_Expression_NormalApplication :: T_Range -> T_Expression -> T_Expressions -> T_Expression
sem_Expression_NormalApplication arg_range_ arg_function_ arg_arguments_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_functionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_function_))
_argumentsX44 = Control.Monad.Identity.runIdentity (attach_T_Expressions (arg_arguments_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _functionIassumptions _functionIbeta _functionIbetaUnique _functionIcollectErrors _functionIcollectInstances _functionIcollectWarnings _functionIconstraints _functionIcounter _functionIdictionaryEnvironment _functionIinfoTree _functionImatchIO _functionImatches _functionIpatternMatchWarnings _functionIself _functionIunboundNames _functionIuniqueChunk _functionIuniqueSecondRound) = inv_Expression_s41 _functionX41 (T_Expression_vIn40 _functionOallPatterns _functionOallTypeSchemes _functionOavailablePredicates _functionObetaUnique _functionOclassEnvironment _functionOcollectErrors _functionOcollectWarnings _functionOcounter _functionOcurrentChunk _functionOdictionaryEnvironment _functionOimportEnvironment _functionOmatchIO _functionOmonos _functionOnamesInScope _functionOorderedTypeSynonyms _functionOparentTree _functionOpatternMatchWarnings _functionOsubstitution _functionOtryPatterns _functionOtypeschemeMap _functionOuniqueChunk _functionOuniqueSecondRound)
(T_Expressions_vOut43 _argumentsIassumptions _argumentsIbetaUnique _argumentsIbetas _argumentsIcollectErrors _argumentsIcollectInstances _argumentsIcollectWarnings _argumentsIconstraintslist _argumentsIcounter _argumentsIdictionaryEnvironment _argumentsIinfoTrees _argumentsImatchIO _argumentsImatches _argumentsIpatternMatchWarnings _argumentsIself _argumentsIunboundNames _argumentsIuniqueChunk _argumentsIuniqueSecondRound) = inv_Expressions_s44 _argumentsX44 (T_Expressions_vIn43 _argumentsOallPatterns _argumentsOallTypeSchemes _argumentsOavailablePredicates _argumentsObetaUnique _argumentsOclassEnvironment _argumentsOcollectErrors _argumentsOcollectWarnings _argumentsOcounter _argumentsOcurrentChunk _argumentsOdictionaryEnvironment _argumentsOimportEnvironment _argumentsOmatchIO _argumentsOmonos _argumentsOnamesInScope _argumentsOorderedTypeSynonyms _argumentsOparentTree _argumentsOpatternMatchWarnings _argumentsOsubstitution _argumentsOtryPatterns _argumentsOtypeschemeMap _argumentsOuniqueChunk _argumentsOuniqueSecondRound)
_functionObetaUnique = rule960 _lhsIbetaUnique
_assumptions = rule961 _argumentsIassumptions _functionIassumptions
_constraints = rule962 _argumentsIconstraintslist _functionIconstraints _newcon
_beta = rule963 _lhsIbetaUnique
_newcon = rule964 _argumentsIbetas _beta _cinfo _functionIbeta
_cinfo = rule965 _argumentsIinfoTrees _parentTree
_localInfo = rule966 _beta _lhsImonos _self
_parentTree = rule967 _argumentsIinfoTrees _functionIinfoTree _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule968 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOconstraints :: ConstraintSet
_lhsOassumptions :: Assumptions
_lhsOuniqueSecondRound :: Int
((_functionOtryPatterns,_argumentsOtryPatterns),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule969 _argumentsImatches _argumentsIuniqueSecondRound _assumptions _constraints _functionImatches _lhsIallPatterns _lhsItryPatterns _localInfo
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule970 _argumentsImatchIO _ioMatch
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule971 _argumentsIcollectInstances _functionIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule972 _argumentsIunboundNames _functionIunboundNames
_self = rule973 _argumentsIself _functionIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule974 _self
_lhsObeta :: Tp
_lhsObeta = rule975 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule976 _argumentsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule977 _argumentsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule978 _argumentsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule979 _argumentsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule980 _argumentsIdictionaryEnvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule981 _argumentsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule982 _argumentsIuniqueChunk
_functionOallPatterns = rule983 _lhsIallPatterns
_functionOallTypeSchemes = rule984 _lhsIallTypeSchemes
_functionOavailablePredicates = rule985 _lhsIavailablePredicates
_functionOclassEnvironment = rule986 _lhsIclassEnvironment
_functionOcollectErrors = rule987 _lhsIcollectErrors
_functionOcollectWarnings = rule988 _lhsIcollectWarnings
_functionOcounter = rule989 _lhsIcounter
_functionOcurrentChunk = rule990 _lhsIcurrentChunk
_functionOdictionaryEnvironment = rule991 _lhsIdictionaryEnvironment
_functionOimportEnvironment = rule992 _lhsIimportEnvironment
_functionOmatchIO = rule993 _lhsImatchIO
_functionOmonos = rule994 _lhsImonos
_functionOnamesInScope = rule995 _lhsInamesInScope
_functionOorderedTypeSynonyms = rule996 _lhsIorderedTypeSynonyms
_functionOparentTree = rule997 _parentTree
_functionOpatternMatchWarnings = rule998 _lhsIpatternMatchWarnings
_functionOsubstitution = rule999 _lhsIsubstitution
_functionOtypeschemeMap = rule1000 _lhsItypeschemeMap
_functionOuniqueChunk = rule1001 _lhsIuniqueChunk
_functionOuniqueSecondRound = rule1002 _lhsIuniqueSecondRound
_argumentsOallPatterns = rule1003 _lhsIallPatterns
_argumentsOallTypeSchemes = rule1004 _lhsIallTypeSchemes
_argumentsOavailablePredicates = rule1005 _lhsIavailablePredicates
_argumentsObetaUnique = rule1006 _functionIbetaUnique
_argumentsOclassEnvironment = rule1007 _lhsIclassEnvironment
_argumentsOcollectErrors = rule1008 _functionIcollectErrors
_argumentsOcollectWarnings = rule1009 _functionIcollectWarnings
_argumentsOcounter = rule1010 _functionIcounter
_argumentsOcurrentChunk = rule1011 _lhsIcurrentChunk
_argumentsOdictionaryEnvironment = rule1012 _functionIdictionaryEnvironment
_argumentsOimportEnvironment = rule1013 _lhsIimportEnvironment
_argumentsOmatchIO = rule1014 _functionImatchIO
_argumentsOmonos = rule1015 _lhsImonos
_argumentsOnamesInScope = rule1016 _lhsInamesInScope
_argumentsOorderedTypeSynonyms = rule1017 _lhsIorderedTypeSynonyms
_argumentsOparentTree = rule1018 _parentTree
_argumentsOpatternMatchWarnings = rule1019 _functionIpatternMatchWarnings
_argumentsOsubstitution = rule1020 _lhsIsubstitution
_argumentsOtypeschemeMap = rule1021 _lhsItypeschemeMap
_argumentsOuniqueChunk = rule1022 _functionIuniqueChunk
_argumentsOuniqueSecondRound = rule1023 _functionIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule960 #-}
rule960 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule961 #-}
rule961 = \ ((_argumentsIassumptions) :: Assumptions) ((_functionIassumptions) :: Assumptions) ->
_functionIassumptions `combine` _argumentsIassumptions
{-# INLINE rule962 #-}
rule962 = \ ((_argumentsIconstraintslist) :: ConstraintSets) ((_functionIconstraints) :: ConstraintSet) _newcon ->
_newcon .>.
Node [ _functionIconstraints
, Node _argumentsIconstraintslist
]
{-# INLINE rule963 #-}
rule963 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule964 #-}
rule964 = \ ((_argumentsIbetas) :: Tps) _beta _cinfo ((_functionIbeta) :: Tp) ->
[ (_functionIbeta .==. foldr (.->.) _beta _argumentsIbetas) _cinfo ]
{-# INLINE rule965 #-}
rule965 = \ ((_argumentsIinfoTrees) :: InfoTrees) _parentTree ->
childConstraint 0 "application" _parentTree
[ ApplicationEdge False (map attribute _argumentsIinfoTrees) ]
{-# INLINE rule966 #-}
rule966 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule967 #-}
rule967 = \ ((_argumentsIinfoTrees) :: InfoTrees) ((_functionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo (_functionIinfoTree : _argumentsIinfoTrees)
{-# INLINE rule968 #-}
rule968 = \ _parentTree ->
_parentTree
{-# INLINE rule969 #-}
rule969 = \ ((_argumentsImatches) :: [Maybe MetaVariableTable]) ((_argumentsIuniqueSecondRound) :: Int) _assumptions _constraints ((_functionImatches) :: [Maybe MetaVariableTable]) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in match2 infoTuple _argumentsIuniqueSecondRound
match_Expression_NormalApplication
_lhsItryPatterns _lhsIallPatterns
[_functionImatches, _argumentsImatches]
{-# INLINE rule970 #-}
rule970 = \ ((_argumentsImatchIO) :: IO ()) _ioMatch ->
_argumentsImatchIO >> _ioMatch
{-# INLINE rule971 #-}
rule971 = \ ((_argumentsIcollectInstances) :: [(Name, Instance)]) ((_functionIcollectInstances) :: [(Name, Instance)]) ->
_functionIcollectInstances ++ _argumentsIcollectInstances
{-# INLINE rule972 #-}
rule972 = \ ((_argumentsIunboundNames) :: Names) ((_functionIunboundNames) :: Names) ->
_functionIunboundNames ++ _argumentsIunboundNames
{-# INLINE rule973 #-}
rule973 = \ ((_argumentsIself) :: Expressions) ((_functionIself) :: Expression) ((_rangeIself) :: Range) ->
Expression_NormalApplication _rangeIself _functionIself _argumentsIself
{-# INLINE rule974 #-}
rule974 = \ _self ->
_self
{-# INLINE rule975 #-}
rule975 = \ _beta ->
_beta
{-# INLINE rule976 #-}
rule976 = \ ((_argumentsIbetaUnique) :: Int) ->
_argumentsIbetaUnique
{-# INLINE rule977 #-}
rule977 = \ ((_argumentsIcollectErrors) :: TypeErrors) ->
_argumentsIcollectErrors
{-# INLINE rule978 #-}
rule978 = \ ((_argumentsIcollectWarnings) :: Warnings) ->
_argumentsIcollectWarnings
{-# INLINE rule979 #-}
rule979 = \ ((_argumentsIcounter) :: Int) ->
_argumentsIcounter
{-# INLINE rule980 #-}
rule980 = \ ((_argumentsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_argumentsIdictionaryEnvironment
{-# INLINE rule981 #-}
rule981 = \ ((_argumentsIpatternMatchWarnings) :: [Warning]) ->
_argumentsIpatternMatchWarnings
{-# INLINE rule982 #-}
rule982 = \ ((_argumentsIuniqueChunk) :: Int) ->
_argumentsIuniqueChunk
{-# INLINE rule983 #-}
rule983 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule984 #-}
rule984 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule985 #-}
rule985 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule986 #-}
rule986 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule987 #-}
rule987 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule988 #-}
rule988 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule989 #-}
rule989 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule990 #-}
rule990 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule991 #-}
rule991 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule992 #-}
rule992 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule993 #-}
rule993 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule994 #-}
rule994 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule995 #-}
rule995 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule996 #-}
rule996 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule997 #-}
rule997 = \ _parentTree ->
_parentTree
{-# INLINE rule998 #-}
rule998 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule999 #-}
rule999 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1000 #-}
rule1000 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1001 #-}
rule1001 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1002 #-}
rule1002 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule1003 #-}
rule1003 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1004 #-}
rule1004 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1005 #-}
rule1005 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1006 #-}
rule1006 = \ ((_functionIbetaUnique) :: Int) ->
_functionIbetaUnique
{-# INLINE rule1007 #-}
rule1007 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1008 #-}
rule1008 = \ ((_functionIcollectErrors) :: TypeErrors) ->
_functionIcollectErrors
{-# INLINE rule1009 #-}
rule1009 = \ ((_functionIcollectWarnings) :: Warnings) ->
_functionIcollectWarnings
{-# INLINE rule1010 #-}
rule1010 = \ ((_functionIcounter) :: Int) ->
_functionIcounter
{-# INLINE rule1011 #-}
rule1011 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1012 #-}
rule1012 = \ ((_functionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_functionIdictionaryEnvironment
{-# INLINE rule1013 #-}
rule1013 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1014 #-}
rule1014 = \ ((_functionImatchIO) :: IO ()) ->
_functionImatchIO
{-# INLINE rule1015 #-}
rule1015 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1016 #-}
rule1016 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1017 #-}
rule1017 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1018 #-}
rule1018 = \ _parentTree ->
_parentTree
{-# INLINE rule1019 #-}
rule1019 = \ ((_functionIpatternMatchWarnings) :: [Warning]) ->
_functionIpatternMatchWarnings
{-# INLINE rule1020 #-}
rule1020 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1021 #-}
rule1021 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1022 #-}
rule1022 = \ ((_functionIuniqueChunk) :: Int) ->
_functionIuniqueChunk
{-# INLINE rule1023 #-}
rule1023 = \ ((_functionIuniqueSecondRound) :: Int) ->
_functionIuniqueSecondRound
{-# NOINLINE sem_Expression_InfixApplication #-}
sem_Expression_InfixApplication :: T_Range -> T_MaybeExpression -> T_Expression -> T_MaybeExpression -> T_Expression
sem_Expression_InfixApplication arg_range_ arg_leftExpression_ arg_operator_ arg_rightExpression_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_leftExpressionX95 = Control.Monad.Identity.runIdentity (attach_T_MaybeExpression (arg_leftExpression_))
_operatorX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_operator_))
_rightExpressionX95 = Control.Monad.Identity.runIdentity (attach_T_MaybeExpression (arg_rightExpression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_MaybeExpression_vOut94 _leftExpressionIassumptions _leftExpressionIbeta _leftExpressionIbetaUnique _leftExpressionIcollectErrors _leftExpressionIcollectInstances _leftExpressionIcollectWarnings _leftExpressionIconstraints _leftExpressionIcounter _leftExpressionIdictionaryEnvironment _leftExpressionIinfoTrees _leftExpressionImatchIO _leftExpressionImatches _leftExpressionIpatternMatchWarnings _leftExpressionIsection _leftExpressionIself _leftExpressionIunboundNames _leftExpressionIuniqueChunk _leftExpressionIuniqueSecondRound) = inv_MaybeExpression_s95 _leftExpressionX95 (T_MaybeExpression_vIn94 _leftExpressionOallPatterns _leftExpressionOallTypeSchemes _leftExpressionOavailablePredicates _leftExpressionObetaUnique _leftExpressionOclassEnvironment _leftExpressionOcollectErrors _leftExpressionOcollectWarnings _leftExpressionOcounter _leftExpressionOcurrentChunk _leftExpressionOdictionaryEnvironment _leftExpressionOimportEnvironment _leftExpressionOmatchIO _leftExpressionOmonos _leftExpressionOnamesInScope _leftExpressionOorderedTypeSynonyms _leftExpressionOparentTree _leftExpressionOpatternMatchWarnings _leftExpressionOsubstitution _leftExpressionOtryPatterns _leftExpressionOtypeschemeMap _leftExpressionOuniqueChunk _leftExpressionOuniqueSecondRound)
(T_Expression_vOut40 _operatorIassumptions _operatorIbeta _operatorIbetaUnique _operatorIcollectErrors _operatorIcollectInstances _operatorIcollectWarnings _operatorIconstraints _operatorIcounter _operatorIdictionaryEnvironment _operatorIinfoTree _operatorImatchIO _operatorImatches _operatorIpatternMatchWarnings _operatorIself _operatorIunboundNames _operatorIuniqueChunk _operatorIuniqueSecondRound) = inv_Expression_s41 _operatorX41 (T_Expression_vIn40 _operatorOallPatterns _operatorOallTypeSchemes _operatorOavailablePredicates _operatorObetaUnique _operatorOclassEnvironment _operatorOcollectErrors _operatorOcollectWarnings _operatorOcounter _operatorOcurrentChunk _operatorOdictionaryEnvironment _operatorOimportEnvironment _operatorOmatchIO _operatorOmonos _operatorOnamesInScope _operatorOorderedTypeSynonyms _operatorOparentTree _operatorOpatternMatchWarnings _operatorOsubstitution _operatorOtryPatterns _operatorOtypeschemeMap _operatorOuniqueChunk _operatorOuniqueSecondRound)
(T_MaybeExpression_vOut94 _rightExpressionIassumptions _rightExpressionIbeta _rightExpressionIbetaUnique _rightExpressionIcollectErrors _rightExpressionIcollectInstances _rightExpressionIcollectWarnings _rightExpressionIconstraints _rightExpressionIcounter _rightExpressionIdictionaryEnvironment _rightExpressionIinfoTrees _rightExpressionImatchIO _rightExpressionImatches _rightExpressionIpatternMatchWarnings _rightExpressionIsection _rightExpressionIself _rightExpressionIunboundNames _rightExpressionIuniqueChunk _rightExpressionIuniqueSecondRound) = inv_MaybeExpression_s95 _rightExpressionX95 (T_MaybeExpression_vIn94 _rightExpressionOallPatterns _rightExpressionOallTypeSchemes _rightExpressionOavailablePredicates _rightExpressionObetaUnique _rightExpressionOclassEnvironment _rightExpressionOcollectErrors _rightExpressionOcollectWarnings _rightExpressionOcounter _rightExpressionOcurrentChunk _rightExpressionOdictionaryEnvironment _rightExpressionOimportEnvironment _rightExpressionOmatchIO _rightExpressionOmonos _rightExpressionOnamesInScope _rightExpressionOorderedTypeSynonyms _rightExpressionOparentTree _rightExpressionOpatternMatchWarnings _rightExpressionOsubstitution _rightExpressionOtryPatterns _rightExpressionOtypeschemeMap _rightExpressionOuniqueChunk _rightExpressionOuniqueSecondRound)
_leftExpressionObetaUnique = rule1024 _lhsIbetaUnique
_assumptions = rule1025 _leftExpressionIassumptions _operatorIassumptions _rightExpressionIassumptions
_constraints = rule1026 _conTotal _leftExpressionIconstraints _operatorIconstraints _rightExpressionIconstraints
_beta = rule1027 _lhsIbetaUnique
_betaResOp = rule1028 _lhsIbetaUnique
_conOperator = rule1029 _betaResOp _cinfoOperator _leftExpressionIbeta _operatorIbeta _rightExpressionIbeta
_conTotal = rule1030 _beta _betaResOp _cinfoComplete _cinfoEmpty _cinfoLeftSection _cinfoRightSection _conOperator _leftExpressionIbeta _leftExpressionIsection _operatorIbeta _rightExpressionIbeta _rightExpressionIsection
_operatorNr = rule1031 _leftExpressionIinfoTrees
_cinfoOperator = rule1032 _leftExpressionIinfoTrees _leftExpressionIsection _operatorNr _parentTree _rightExpressionIinfoTrees _rightExpressionIsection
_cinfoComplete = rule1033 _localInfo _parentTree
_cinfoLeftSection = rule1034 _localInfo _parentTree
_cinfoRightSection = rule1035 _localInfo _parentTree
_cinfoEmpty = rule1036 _localInfo _parentTree
_localInfo = rule1037 _beta _lhsImonos _self
_parentTree = rule1038 _leftExpressionIinfoTrees _lhsIparentTree _localInfo _operatorIinfoTree _rightExpressionIinfoTrees
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1039 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOconstraints :: ConstraintSet
_lhsOassumptions :: Assumptions
_lhsOuniqueSecondRound :: Int
((_leftExpressionOtryPatterns,_operatorOtryPatterns,_rightExpressionOtryPatterns),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1040 _assumptions _constraints _leftExpressionImatches _lhsIallPatterns _lhsItryPatterns _localInfo _operatorImatches _rightExpressionImatches _rightExpressionIuniqueSecondRound
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1041 _ioMatch _rightExpressionImatchIO
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1042 _leftExpressionIcollectInstances _operatorIcollectInstances _rightExpressionIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1043 _leftExpressionIunboundNames _operatorIunboundNames _rightExpressionIunboundNames
_self = rule1044 _leftExpressionIself _operatorIself _rangeIself _rightExpressionIself
_lhsOself :: Expression
_lhsOself = rule1045 _self
_lhsObeta :: Tp
_lhsObeta = rule1046 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1047 _rightExpressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1048 _rightExpressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1049 _rightExpressionIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule1050 _rightExpressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1051 _rightExpressionIdictionaryEnvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1052 _rightExpressionIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1053 _rightExpressionIuniqueChunk
_leftExpressionOallPatterns = rule1054 _lhsIallPatterns
_leftExpressionOallTypeSchemes = rule1055 _lhsIallTypeSchemes
_leftExpressionOavailablePredicates = rule1056 _lhsIavailablePredicates
_leftExpressionOclassEnvironment = rule1057 _lhsIclassEnvironment
_leftExpressionOcollectErrors = rule1058 _lhsIcollectErrors
_leftExpressionOcollectWarnings = rule1059 _lhsIcollectWarnings
_leftExpressionOcounter = rule1060 _lhsIcounter
_leftExpressionOcurrentChunk = rule1061 _lhsIcurrentChunk
_leftExpressionOdictionaryEnvironment = rule1062 _lhsIdictionaryEnvironment
_leftExpressionOimportEnvironment = rule1063 _lhsIimportEnvironment
_leftExpressionOmatchIO = rule1064 _lhsImatchIO
_leftExpressionOmonos = rule1065 _lhsImonos
_leftExpressionOnamesInScope = rule1066 _lhsInamesInScope
_leftExpressionOorderedTypeSynonyms = rule1067 _lhsIorderedTypeSynonyms
_leftExpressionOparentTree = rule1068 _parentTree
_leftExpressionOpatternMatchWarnings = rule1069 _lhsIpatternMatchWarnings
_leftExpressionOsubstitution = rule1070 _lhsIsubstitution
_leftExpressionOtypeschemeMap = rule1071 _lhsItypeschemeMap
_leftExpressionOuniqueChunk = rule1072 _lhsIuniqueChunk
_leftExpressionOuniqueSecondRound = rule1073 _lhsIuniqueSecondRound
_operatorOallPatterns = rule1074 _lhsIallPatterns
_operatorOallTypeSchemes = rule1075 _lhsIallTypeSchemes
_operatorOavailablePredicates = rule1076 _lhsIavailablePredicates
_operatorObetaUnique = rule1077 _leftExpressionIbetaUnique
_operatorOclassEnvironment = rule1078 _lhsIclassEnvironment
_operatorOcollectErrors = rule1079 _leftExpressionIcollectErrors
_operatorOcollectWarnings = rule1080 _leftExpressionIcollectWarnings
_operatorOcounter = rule1081 _leftExpressionIcounter
_operatorOcurrentChunk = rule1082 _lhsIcurrentChunk
_operatorOdictionaryEnvironment = rule1083 _leftExpressionIdictionaryEnvironment
_operatorOimportEnvironment = rule1084 _lhsIimportEnvironment
_operatorOmatchIO = rule1085 _leftExpressionImatchIO
_operatorOmonos = rule1086 _lhsImonos
_operatorOnamesInScope = rule1087 _lhsInamesInScope
_operatorOorderedTypeSynonyms = rule1088 _lhsIorderedTypeSynonyms
_operatorOparentTree = rule1089 _parentTree
_operatorOpatternMatchWarnings = rule1090 _leftExpressionIpatternMatchWarnings
_operatorOsubstitution = rule1091 _lhsIsubstitution
_operatorOtypeschemeMap = rule1092 _lhsItypeschemeMap
_operatorOuniqueChunk = rule1093 _leftExpressionIuniqueChunk
_operatorOuniqueSecondRound = rule1094 _leftExpressionIuniqueSecondRound
_rightExpressionOallPatterns = rule1095 _lhsIallPatterns
_rightExpressionOallTypeSchemes = rule1096 _lhsIallTypeSchemes
_rightExpressionOavailablePredicates = rule1097 _lhsIavailablePredicates
_rightExpressionObetaUnique = rule1098 _operatorIbetaUnique
_rightExpressionOclassEnvironment = rule1099 _lhsIclassEnvironment
_rightExpressionOcollectErrors = rule1100 _operatorIcollectErrors
_rightExpressionOcollectWarnings = rule1101 _operatorIcollectWarnings
_rightExpressionOcounter = rule1102 _operatorIcounter
_rightExpressionOcurrentChunk = rule1103 _lhsIcurrentChunk
_rightExpressionOdictionaryEnvironment = rule1104 _operatorIdictionaryEnvironment
_rightExpressionOimportEnvironment = rule1105 _lhsIimportEnvironment
_rightExpressionOmatchIO = rule1106 _operatorImatchIO
_rightExpressionOmonos = rule1107 _lhsImonos
_rightExpressionOnamesInScope = rule1108 _lhsInamesInScope
_rightExpressionOorderedTypeSynonyms = rule1109 _lhsIorderedTypeSynonyms
_rightExpressionOparentTree = rule1110 _parentTree
_rightExpressionOpatternMatchWarnings = rule1111 _operatorIpatternMatchWarnings
_rightExpressionOsubstitution = rule1112 _lhsIsubstitution
_rightExpressionOtypeschemeMap = rule1113 _lhsItypeschemeMap
_rightExpressionOuniqueChunk = rule1114 _operatorIuniqueChunk
_rightExpressionOuniqueSecondRound = rule1115 _operatorIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1024 #-}
rule1024 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 2
{-# INLINE rule1025 #-}
rule1025 = \ ((_leftExpressionIassumptions) :: Assumptions) ((_operatorIassumptions) :: Assumptions) ((_rightExpressionIassumptions) :: Assumptions) ->
_leftExpressionIassumptions `combine` _operatorIassumptions `combine` _rightExpressionIassumptions
{-# INLINE rule1026 #-}
rule1026 = \ _conTotal ((_leftExpressionIconstraints) :: ConstraintSet) ((_operatorIconstraints) :: ConstraintSet) ((_rightExpressionIconstraints) :: ConstraintSet) ->
_conTotal .>.
Node [ _operatorIconstraints
, _leftExpressionIconstraints
, _rightExpressionIconstraints
]
{-# INLINE rule1027 #-}
rule1027 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1028 #-}
rule1028 = \ ((_lhsIbetaUnique) :: Int) ->
TVar (_lhsIbetaUnique + 1)
{-# INLINE rule1029 #-}
rule1029 = \ _betaResOp _cinfoOperator ((_leftExpressionIbeta) :: Tp) ((_operatorIbeta) :: Tp) ((_rightExpressionIbeta) :: Tp) ->
(_operatorIbeta .==. _leftExpressionIbeta .->. _rightExpressionIbeta .->. _betaResOp) _cinfoOperator
{-# INLINE rule1030 #-}
rule1030 = \ _beta _betaResOp _cinfoComplete _cinfoEmpty _cinfoLeftSection _cinfoRightSection _conOperator ((_leftExpressionIbeta) :: Tp) ((_leftExpressionIsection) :: Bool) ((_operatorIbeta) :: Tp) ((_rightExpressionIbeta) :: Tp) ((_rightExpressionIsection) :: Bool) ->
case (_leftExpressionIsection,_rightExpressionIsection) of
(False,False) -> [ _conOperator, (_betaResOp .==. _beta) _cinfoComplete ]
(True ,True ) -> [ (_operatorIbeta .==. _beta) _cinfoEmpty ]
(False,True ) -> [ _conOperator, (_rightExpressionIbeta .->. _betaResOp .==. _beta) _cinfoRightSection ]
(True ,False) -> [ _conOperator, (_leftExpressionIbeta .->. _betaResOp .==. _beta) _cinfoLeftSection ]
{-# INLINE rule1031 #-}
rule1031 = \ ((_leftExpressionIinfoTrees) :: InfoTrees) ->
length _leftExpressionIinfoTrees
{-# INLINE rule1032 #-}
rule1032 = \ ((_leftExpressionIinfoTrees) :: InfoTrees) ((_leftExpressionIsection) :: Bool) _operatorNr _parentTree ((_rightExpressionIinfoTrees) :: InfoTrees) ((_rightExpressionIsection) :: Bool) ->
childConstraint _operatorNr "infix application" _parentTree $
if _leftExpressionIsection || _rightExpressionIsection
then [ HasTrustFactor 10.0 ]
else [ ApplicationEdge True (map attribute (_leftExpressionIinfoTrees ++ _rightExpressionIinfoTrees)) ]
{-# INLINE rule1033 #-}
rule1033 = \ _localInfo _parentTree ->
specialConstraint "infix application (INTERNAL ERROR)" _parentTree
(self _localInfo, Nothing)
[ FolkloreConstraint, highlyTrusted ]
{-# INLINE rule1034 #-}
rule1034 = \ _localInfo _parentTree ->
specialConstraint "left section" _parentTree
(self _localInfo, Nothing)
[ ]
{-# INLINE rule1035 #-}
rule1035 = \ _localInfo _parentTree ->
specialConstraint "right section" _parentTree
(self _localInfo, Nothing)
[ ]
{-# INLINE rule1036 #-}
rule1036 = \ _localInfo _parentTree ->
specialConstraint "infix application" _parentTree
(self _localInfo, Nothing)
[ FolkloreConstraint, HasTrustFactor 10.0 ]
{-# INLINE rule1037 #-}
rule1037 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1038 #-}
rule1038 = \ ((_leftExpressionIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) _localInfo ((_operatorIinfoTree) :: InfoTree) ((_rightExpressionIinfoTrees) :: InfoTrees) ->
node _lhsIparentTree _localInfo
(_leftExpressionIinfoTrees ++ [_operatorIinfoTree] ++ _rightExpressionIinfoTrees)
{-# INLINE rule1039 #-}
rule1039 = \ _parentTree ->
_parentTree
{-# INLINE rule1040 #-}
rule1040 = \ _assumptions _constraints ((_leftExpressionImatches) :: [Maybe MetaVariableTable]) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ((_operatorImatches) :: [Maybe MetaVariableTable]) ((_rightExpressionImatches) :: [Maybe MetaVariableTable]) ((_rightExpressionIuniqueSecondRound) :: Int) ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in match3 infoTuple _rightExpressionIuniqueSecondRound
match_Expression_InfixApplication
_lhsItryPatterns _lhsIallPatterns
[_leftExpressionImatches, _operatorImatches,_rightExpressionImatches]
{-# INLINE rule1041 #-}
rule1041 = \ _ioMatch ((_rightExpressionImatchIO) :: IO ()) ->
_rightExpressionImatchIO >> _ioMatch
{-# INLINE rule1042 #-}
rule1042 = \ ((_leftExpressionIcollectInstances) :: [(Name, Instance)]) ((_operatorIcollectInstances) :: [(Name, Instance)]) ((_rightExpressionIcollectInstances) :: [(Name, Instance)]) ->
_leftExpressionIcollectInstances ++ _operatorIcollectInstances ++ _rightExpressionIcollectInstances
{-# INLINE rule1043 #-}
rule1043 = \ ((_leftExpressionIunboundNames) :: Names) ((_operatorIunboundNames) :: Names) ((_rightExpressionIunboundNames) :: Names) ->
_leftExpressionIunboundNames ++ _operatorIunboundNames ++ _rightExpressionIunboundNames
{-# INLINE rule1044 #-}
rule1044 = \ ((_leftExpressionIself) :: MaybeExpression) ((_operatorIself) :: Expression) ((_rangeIself) :: Range) ((_rightExpressionIself) :: MaybeExpression) ->
Expression_InfixApplication _rangeIself _leftExpressionIself _operatorIself _rightExpressionIself
{-# INLINE rule1045 #-}
rule1045 = \ _self ->
_self
{-# INLINE rule1046 #-}
rule1046 = \ _beta ->
_beta
{-# INLINE rule1047 #-}
rule1047 = \ ((_rightExpressionIbetaUnique) :: Int) ->
_rightExpressionIbetaUnique
{-# INLINE rule1048 #-}
rule1048 = \ ((_rightExpressionIcollectErrors) :: TypeErrors) ->
_rightExpressionIcollectErrors
{-# INLINE rule1049 #-}
rule1049 = \ ((_rightExpressionIcollectWarnings) :: Warnings) ->
_rightExpressionIcollectWarnings
{-# INLINE rule1050 #-}
rule1050 = \ ((_rightExpressionIcounter) :: Int) ->
_rightExpressionIcounter
{-# INLINE rule1051 #-}
rule1051 = \ ((_rightExpressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_rightExpressionIdictionaryEnvironment
{-# INLINE rule1052 #-}
rule1052 = \ ((_rightExpressionIpatternMatchWarnings) :: [Warning]) ->
_rightExpressionIpatternMatchWarnings
{-# INLINE rule1053 #-}
rule1053 = \ ((_rightExpressionIuniqueChunk) :: Int) ->
_rightExpressionIuniqueChunk
{-# INLINE rule1054 #-}
rule1054 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1055 #-}
rule1055 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1056 #-}
rule1056 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1057 #-}
rule1057 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1058 #-}
rule1058 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1059 #-}
rule1059 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1060 #-}
rule1060 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1061 #-}
rule1061 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1062 #-}
rule1062 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1063 #-}
rule1063 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1064 #-}
rule1064 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1065 #-}
rule1065 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1066 #-}
rule1066 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1067 #-}
rule1067 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1068 #-}
rule1068 = \ _parentTree ->
_parentTree
{-# INLINE rule1069 #-}
rule1069 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1070 #-}
rule1070 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1071 #-}
rule1071 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1072 #-}
rule1072 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1073 #-}
rule1073 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule1074 #-}
rule1074 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1075 #-}
rule1075 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1076 #-}
rule1076 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1077 #-}
rule1077 = \ ((_leftExpressionIbetaUnique) :: Int) ->
_leftExpressionIbetaUnique
{-# INLINE rule1078 #-}
rule1078 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1079 #-}
rule1079 = \ ((_leftExpressionIcollectErrors) :: TypeErrors) ->
_leftExpressionIcollectErrors
{-# INLINE rule1080 #-}
rule1080 = \ ((_leftExpressionIcollectWarnings) :: Warnings) ->
_leftExpressionIcollectWarnings
{-# INLINE rule1081 #-}
rule1081 = \ ((_leftExpressionIcounter) :: Int) ->
_leftExpressionIcounter
{-# INLINE rule1082 #-}
rule1082 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1083 #-}
rule1083 = \ ((_leftExpressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_leftExpressionIdictionaryEnvironment
{-# INLINE rule1084 #-}
rule1084 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1085 #-}
rule1085 = \ ((_leftExpressionImatchIO) :: IO ()) ->
_leftExpressionImatchIO
{-# INLINE rule1086 #-}
rule1086 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1087 #-}
rule1087 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1088 #-}
rule1088 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1089 #-}
rule1089 = \ _parentTree ->
_parentTree
{-# INLINE rule1090 #-}
rule1090 = \ ((_leftExpressionIpatternMatchWarnings) :: [Warning]) ->
_leftExpressionIpatternMatchWarnings
{-# INLINE rule1091 #-}
rule1091 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1092 #-}
rule1092 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1093 #-}
rule1093 = \ ((_leftExpressionIuniqueChunk) :: Int) ->
_leftExpressionIuniqueChunk
{-# INLINE rule1094 #-}
rule1094 = \ ((_leftExpressionIuniqueSecondRound) :: Int) ->
_leftExpressionIuniqueSecondRound
{-# INLINE rule1095 #-}
rule1095 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1096 #-}
rule1096 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1097 #-}
rule1097 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1098 #-}
rule1098 = \ ((_operatorIbetaUnique) :: Int) ->
_operatorIbetaUnique
{-# INLINE rule1099 #-}
rule1099 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1100 #-}
rule1100 = \ ((_operatorIcollectErrors) :: TypeErrors) ->
_operatorIcollectErrors
{-# INLINE rule1101 #-}
rule1101 = \ ((_operatorIcollectWarnings) :: Warnings) ->
_operatorIcollectWarnings
{-# INLINE rule1102 #-}
rule1102 = \ ((_operatorIcounter) :: Int) ->
_operatorIcounter
{-# INLINE rule1103 #-}
rule1103 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1104 #-}
rule1104 = \ ((_operatorIdictionaryEnvironment) :: DictionaryEnvironment) ->
_operatorIdictionaryEnvironment
{-# INLINE rule1105 #-}
rule1105 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1106 #-}
rule1106 = \ ((_operatorImatchIO) :: IO ()) ->
_operatorImatchIO
{-# INLINE rule1107 #-}
rule1107 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1108 #-}
rule1108 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1109 #-}
rule1109 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1110 #-}
rule1110 = \ _parentTree ->
_parentTree
{-# INLINE rule1111 #-}
rule1111 = \ ((_operatorIpatternMatchWarnings) :: [Warning]) ->
_operatorIpatternMatchWarnings
{-# INLINE rule1112 #-}
rule1112 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1113 #-}
rule1113 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1114 #-}
rule1114 = \ ((_operatorIuniqueChunk) :: Int) ->
_operatorIuniqueChunk
{-# INLINE rule1115 #-}
rule1115 = \ ((_operatorIuniqueSecondRound) :: Int) ->
_operatorIuniqueSecondRound
{-# NOINLINE sem_Expression_If #-}
sem_Expression_If :: T_Range -> T_Expression -> T_Expression -> T_Expression -> T_Expression
sem_Expression_If arg_range_ arg_guardExpression_ arg_thenExpression_ arg_elseExpression_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_guardExpressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_guardExpression_))
_thenExpressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_thenExpression_))
_elseExpressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_elseExpression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _guardExpressionIassumptions _guardExpressionIbeta _guardExpressionIbetaUnique _guardExpressionIcollectErrors _guardExpressionIcollectInstances _guardExpressionIcollectWarnings _guardExpressionIconstraints _guardExpressionIcounter _guardExpressionIdictionaryEnvironment _guardExpressionIinfoTree _guardExpressionImatchIO _guardExpressionImatches _guardExpressionIpatternMatchWarnings _guardExpressionIself _guardExpressionIunboundNames _guardExpressionIuniqueChunk _guardExpressionIuniqueSecondRound) = inv_Expression_s41 _guardExpressionX41 (T_Expression_vIn40 _guardExpressionOallPatterns _guardExpressionOallTypeSchemes _guardExpressionOavailablePredicates _guardExpressionObetaUnique _guardExpressionOclassEnvironment _guardExpressionOcollectErrors _guardExpressionOcollectWarnings _guardExpressionOcounter _guardExpressionOcurrentChunk _guardExpressionOdictionaryEnvironment _guardExpressionOimportEnvironment _guardExpressionOmatchIO _guardExpressionOmonos _guardExpressionOnamesInScope _guardExpressionOorderedTypeSynonyms _guardExpressionOparentTree _guardExpressionOpatternMatchWarnings _guardExpressionOsubstitution _guardExpressionOtryPatterns _guardExpressionOtypeschemeMap _guardExpressionOuniqueChunk _guardExpressionOuniqueSecondRound)
(T_Expression_vOut40 _thenExpressionIassumptions _thenExpressionIbeta _thenExpressionIbetaUnique _thenExpressionIcollectErrors _thenExpressionIcollectInstances _thenExpressionIcollectWarnings _thenExpressionIconstraints _thenExpressionIcounter _thenExpressionIdictionaryEnvironment _thenExpressionIinfoTree _thenExpressionImatchIO _thenExpressionImatches _thenExpressionIpatternMatchWarnings _thenExpressionIself _thenExpressionIunboundNames _thenExpressionIuniqueChunk _thenExpressionIuniqueSecondRound) = inv_Expression_s41 _thenExpressionX41 (T_Expression_vIn40 _thenExpressionOallPatterns _thenExpressionOallTypeSchemes _thenExpressionOavailablePredicates _thenExpressionObetaUnique _thenExpressionOclassEnvironment _thenExpressionOcollectErrors _thenExpressionOcollectWarnings _thenExpressionOcounter _thenExpressionOcurrentChunk _thenExpressionOdictionaryEnvironment _thenExpressionOimportEnvironment _thenExpressionOmatchIO _thenExpressionOmonos _thenExpressionOnamesInScope _thenExpressionOorderedTypeSynonyms _thenExpressionOparentTree _thenExpressionOpatternMatchWarnings _thenExpressionOsubstitution _thenExpressionOtryPatterns _thenExpressionOtypeschemeMap _thenExpressionOuniqueChunk _thenExpressionOuniqueSecondRound)
(T_Expression_vOut40 _elseExpressionIassumptions _elseExpressionIbeta _elseExpressionIbetaUnique _elseExpressionIcollectErrors _elseExpressionIcollectInstances _elseExpressionIcollectWarnings _elseExpressionIconstraints _elseExpressionIcounter _elseExpressionIdictionaryEnvironment _elseExpressionIinfoTree _elseExpressionImatchIO _elseExpressionImatches _elseExpressionIpatternMatchWarnings _elseExpressionIself _elseExpressionIunboundNames _elseExpressionIuniqueChunk _elseExpressionIuniqueSecondRound) = inv_Expression_s41 _elseExpressionX41 (T_Expression_vIn40 _elseExpressionOallPatterns _elseExpressionOallTypeSchemes _elseExpressionOavailablePredicates _elseExpressionObetaUnique _elseExpressionOclassEnvironment _elseExpressionOcollectErrors _elseExpressionOcollectWarnings _elseExpressionOcounter _elseExpressionOcurrentChunk _elseExpressionOdictionaryEnvironment _elseExpressionOimportEnvironment _elseExpressionOmatchIO _elseExpressionOmonos _elseExpressionOnamesInScope _elseExpressionOorderedTypeSynonyms _elseExpressionOparentTree _elseExpressionOpatternMatchWarnings _elseExpressionOsubstitution _elseExpressionOtryPatterns _elseExpressionOtypeschemeMap _elseExpressionOuniqueChunk _elseExpressionOuniqueSecondRound)
_guardExpressionObetaUnique = rule1116 _lhsIbetaUnique
_assumptions = rule1117 _elseExpressionIassumptions _guardExpressionIassumptions _thenExpressionIassumptions
_constraints = rule1118 _conElse _conGuard _conThen _elseExpressionIconstraints _guardExpressionIconstraints _thenExpressionIconstraints
_beta = rule1119 _lhsIbetaUnique
_conGuard = rule1120 _cinfoGuard _guardExpressionIbeta
_conThen = rule1121 _beta _cinfoThen _thenExpressionIbeta
_conElse = rule1122 _beta _cinfoElse _elseExpressionIbeta
_cinfoGuard = rule1123 _parentTree
_cinfoThen = rule1124 _beta _localInfo _parentTree
_cinfoElse = rule1125 _beta _localInfo _parentTree
_localInfo = rule1126 _beta _lhsImonos _self
_parentTree = rule1127 _elseExpressionIinfoTree _guardExpressionIinfoTree _lhsIparentTree _localInfo _thenExpressionIinfoTree
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1128 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOconstraints :: ConstraintSet
_lhsOassumptions :: Assumptions
_lhsOuniqueSecondRound :: Int
((_guardExpressionOtryPatterns,_thenExpressionOtryPatterns,_elseExpressionOtryPatterns),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1129 _assumptions _constraints _elseExpressionImatches _elseExpressionIuniqueSecondRound _guardExpressionImatches _lhsIallPatterns _lhsItryPatterns _localInfo _thenExpressionImatches
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1130 _elseExpressionImatchIO _ioMatch
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1131 _elseExpressionIcollectInstances _guardExpressionIcollectInstances _thenExpressionIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1132 _elseExpressionIunboundNames _guardExpressionIunboundNames _thenExpressionIunboundNames
_self = rule1133 _elseExpressionIself _guardExpressionIself _rangeIself _thenExpressionIself
_lhsOself :: Expression
_lhsOself = rule1134 _self
_lhsObeta :: Tp
_lhsObeta = rule1135 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1136 _elseExpressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1137 _elseExpressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1138 _elseExpressionIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule1139 _elseExpressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1140 _elseExpressionIdictionaryEnvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1141 _elseExpressionIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1142 _elseExpressionIuniqueChunk
_guardExpressionOallPatterns = rule1143 _lhsIallPatterns
_guardExpressionOallTypeSchemes = rule1144 _lhsIallTypeSchemes
_guardExpressionOavailablePredicates = rule1145 _lhsIavailablePredicates
_guardExpressionOclassEnvironment = rule1146 _lhsIclassEnvironment
_guardExpressionOcollectErrors = rule1147 _lhsIcollectErrors
_guardExpressionOcollectWarnings = rule1148 _lhsIcollectWarnings
_guardExpressionOcounter = rule1149 _lhsIcounter
_guardExpressionOcurrentChunk = rule1150 _lhsIcurrentChunk
_guardExpressionOdictionaryEnvironment = rule1151 _lhsIdictionaryEnvironment
_guardExpressionOimportEnvironment = rule1152 _lhsIimportEnvironment
_guardExpressionOmatchIO = rule1153 _lhsImatchIO
_guardExpressionOmonos = rule1154 _lhsImonos
_guardExpressionOnamesInScope = rule1155 _lhsInamesInScope
_guardExpressionOorderedTypeSynonyms = rule1156 _lhsIorderedTypeSynonyms
_guardExpressionOparentTree = rule1157 _parentTree
_guardExpressionOpatternMatchWarnings = rule1158 _lhsIpatternMatchWarnings
_guardExpressionOsubstitution = rule1159 _lhsIsubstitution
_guardExpressionOtypeschemeMap = rule1160 _lhsItypeschemeMap
_guardExpressionOuniqueChunk = rule1161 _lhsIuniqueChunk
_guardExpressionOuniqueSecondRound = rule1162 _lhsIuniqueSecondRound
_thenExpressionOallPatterns = rule1163 _lhsIallPatterns
_thenExpressionOallTypeSchemes = rule1164 _lhsIallTypeSchemes
_thenExpressionOavailablePredicates = rule1165 _lhsIavailablePredicates
_thenExpressionObetaUnique = rule1166 _guardExpressionIbetaUnique
_thenExpressionOclassEnvironment = rule1167 _lhsIclassEnvironment
_thenExpressionOcollectErrors = rule1168 _guardExpressionIcollectErrors
_thenExpressionOcollectWarnings = rule1169 _guardExpressionIcollectWarnings
_thenExpressionOcounter = rule1170 _guardExpressionIcounter
_thenExpressionOcurrentChunk = rule1171 _lhsIcurrentChunk
_thenExpressionOdictionaryEnvironment = rule1172 _guardExpressionIdictionaryEnvironment
_thenExpressionOimportEnvironment = rule1173 _lhsIimportEnvironment
_thenExpressionOmatchIO = rule1174 _guardExpressionImatchIO
_thenExpressionOmonos = rule1175 _lhsImonos
_thenExpressionOnamesInScope = rule1176 _lhsInamesInScope
_thenExpressionOorderedTypeSynonyms = rule1177 _lhsIorderedTypeSynonyms
_thenExpressionOparentTree = rule1178 _parentTree
_thenExpressionOpatternMatchWarnings = rule1179 _guardExpressionIpatternMatchWarnings
_thenExpressionOsubstitution = rule1180 _lhsIsubstitution
_thenExpressionOtypeschemeMap = rule1181 _lhsItypeschemeMap
_thenExpressionOuniqueChunk = rule1182 _guardExpressionIuniqueChunk
_thenExpressionOuniqueSecondRound = rule1183 _guardExpressionIuniqueSecondRound
_elseExpressionOallPatterns = rule1184 _lhsIallPatterns
_elseExpressionOallTypeSchemes = rule1185 _lhsIallTypeSchemes
_elseExpressionOavailablePredicates = rule1186 _lhsIavailablePredicates
_elseExpressionObetaUnique = rule1187 _thenExpressionIbetaUnique
_elseExpressionOclassEnvironment = rule1188 _lhsIclassEnvironment
_elseExpressionOcollectErrors = rule1189 _thenExpressionIcollectErrors
_elseExpressionOcollectWarnings = rule1190 _thenExpressionIcollectWarnings
_elseExpressionOcounter = rule1191 _thenExpressionIcounter
_elseExpressionOcurrentChunk = rule1192 _lhsIcurrentChunk
_elseExpressionOdictionaryEnvironment = rule1193 _thenExpressionIdictionaryEnvironment
_elseExpressionOimportEnvironment = rule1194 _lhsIimportEnvironment
_elseExpressionOmatchIO = rule1195 _thenExpressionImatchIO
_elseExpressionOmonos = rule1196 _lhsImonos
_elseExpressionOnamesInScope = rule1197 _lhsInamesInScope
_elseExpressionOorderedTypeSynonyms = rule1198 _lhsIorderedTypeSynonyms
_elseExpressionOparentTree = rule1199 _parentTree
_elseExpressionOpatternMatchWarnings = rule1200 _thenExpressionIpatternMatchWarnings
_elseExpressionOsubstitution = rule1201 _lhsIsubstitution
_elseExpressionOtypeschemeMap = rule1202 _lhsItypeschemeMap
_elseExpressionOuniqueChunk = rule1203 _thenExpressionIuniqueChunk
_elseExpressionOuniqueSecondRound = rule1204 _thenExpressionIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1116 #-}
rule1116 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule1117 #-}
rule1117 = \ ((_elseExpressionIassumptions) :: Assumptions) ((_guardExpressionIassumptions) :: Assumptions) ((_thenExpressionIassumptions) :: Assumptions) ->
_guardExpressionIassumptions `combine` _thenExpressionIassumptions `combine` _elseExpressionIassumptions
{-# INLINE rule1118 #-}
rule1118 = \ _conElse _conGuard _conThen ((_elseExpressionIconstraints) :: ConstraintSet) ((_guardExpressionIconstraints) :: ConstraintSet) ((_thenExpressionIconstraints) :: ConstraintSet) ->
Node [ _conGuard .<. _guardExpressionIconstraints
, _conThen .<. _thenExpressionIconstraints
, _conElse .<. _elseExpressionIconstraints
]
{-# INLINE rule1119 #-}
rule1119 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1120 #-}
rule1120 = \ _cinfoGuard ((_guardExpressionIbeta) :: Tp) ->
[ (_guardExpressionIbeta .==. boolType) _cinfoGuard ]
{-# INLINE rule1121 #-}
rule1121 = \ _beta _cinfoThen ((_thenExpressionIbeta) :: Tp) ->
[ (_thenExpressionIbeta .==. _beta ) _cinfoThen ]
{-# INLINE rule1122 #-}
rule1122 = \ _beta _cinfoElse ((_elseExpressionIbeta) :: Tp) ->
[ (_elseExpressionIbeta .==. _beta ) _cinfoElse ]
{-# INLINE rule1123 #-}
rule1123 = \ _parentTree ->
childConstraint 0 "conditional" _parentTree
[]
{-# INLINE rule1124 #-}
rule1124 = \ _beta _localInfo _parentTree ->
childConstraint 1 "then branch of conditional" _parentTree
[ Unifier (head (ftv _beta)) ("conditional", _localInfo, "then branch") ]
{-# INLINE rule1125 #-}
rule1125 = \ _beta _localInfo _parentTree ->
childConstraint 2 "else branch of conditional" _parentTree
[ Unifier (head (ftv _beta)) ("conditional", _localInfo, "else branch") ]
{-# INLINE rule1126 #-}
rule1126 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1127 #-}
rule1127 = \ ((_elseExpressionIinfoTree) :: InfoTree) ((_guardExpressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_thenExpressionIinfoTree) :: InfoTree) ->
node _lhsIparentTree _localInfo [_guardExpressionIinfoTree, _thenExpressionIinfoTree, _elseExpressionIinfoTree]
{-# INLINE rule1128 #-}
rule1128 = \ _parentTree ->
_parentTree
{-# INLINE rule1129 #-}
rule1129 = \ _assumptions _constraints ((_elseExpressionImatches) :: [Maybe MetaVariableTable]) ((_elseExpressionIuniqueSecondRound) :: Int) ((_guardExpressionImatches) :: [Maybe MetaVariableTable]) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ((_thenExpressionImatches) :: [Maybe MetaVariableTable]) ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in match3 infoTuple _elseExpressionIuniqueSecondRound
match_Expression_If
_lhsItryPatterns _lhsIallPatterns
[_guardExpressionImatches,_thenExpressionImatches,_elseExpressionImatches]
{-# INLINE rule1130 #-}
rule1130 = \ ((_elseExpressionImatchIO) :: IO ()) _ioMatch ->
_elseExpressionImatchIO >> _ioMatch
{-# INLINE rule1131 #-}
rule1131 = \ ((_elseExpressionIcollectInstances) :: [(Name, Instance)]) ((_guardExpressionIcollectInstances) :: [(Name, Instance)]) ((_thenExpressionIcollectInstances) :: [(Name, Instance)]) ->
_guardExpressionIcollectInstances ++ _thenExpressionIcollectInstances ++ _elseExpressionIcollectInstances
{-# INLINE rule1132 #-}
rule1132 = \ ((_elseExpressionIunboundNames) :: Names) ((_guardExpressionIunboundNames) :: Names) ((_thenExpressionIunboundNames) :: Names) ->
_guardExpressionIunboundNames ++ _thenExpressionIunboundNames ++ _elseExpressionIunboundNames
{-# INLINE rule1133 #-}
rule1133 = \ ((_elseExpressionIself) :: Expression) ((_guardExpressionIself) :: Expression) ((_rangeIself) :: Range) ((_thenExpressionIself) :: Expression) ->
Expression_If _rangeIself _guardExpressionIself _thenExpressionIself _elseExpressionIself
{-# INLINE rule1134 #-}
rule1134 = \ _self ->
_self
{-# INLINE rule1135 #-}
rule1135 = \ _beta ->
_beta
{-# INLINE rule1136 #-}
rule1136 = \ ((_elseExpressionIbetaUnique) :: Int) ->
_elseExpressionIbetaUnique
{-# INLINE rule1137 #-}
rule1137 = \ ((_elseExpressionIcollectErrors) :: TypeErrors) ->
_elseExpressionIcollectErrors
{-# INLINE rule1138 #-}
rule1138 = \ ((_elseExpressionIcollectWarnings) :: Warnings) ->
_elseExpressionIcollectWarnings
{-# INLINE rule1139 #-}
rule1139 = \ ((_elseExpressionIcounter) :: Int) ->
_elseExpressionIcounter
{-# INLINE rule1140 #-}
rule1140 = \ ((_elseExpressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_elseExpressionIdictionaryEnvironment
{-# INLINE rule1141 #-}
rule1141 = \ ((_elseExpressionIpatternMatchWarnings) :: [Warning]) ->
_elseExpressionIpatternMatchWarnings
{-# INLINE rule1142 #-}
rule1142 = \ ((_elseExpressionIuniqueChunk) :: Int) ->
_elseExpressionIuniqueChunk
{-# INLINE rule1143 #-}
rule1143 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1144 #-}
rule1144 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1145 #-}
rule1145 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1146 #-}
rule1146 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1147 #-}
rule1147 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1148 #-}
rule1148 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1149 #-}
rule1149 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1150 #-}
rule1150 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1151 #-}
rule1151 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1152 #-}
rule1152 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1153 #-}
rule1153 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1154 #-}
rule1154 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1155 #-}
rule1155 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1156 #-}
rule1156 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1157 #-}
rule1157 = \ _parentTree ->
_parentTree
{-# INLINE rule1158 #-}
rule1158 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1159 #-}
rule1159 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1160 #-}
rule1160 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1161 #-}
rule1161 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1162 #-}
rule1162 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule1163 #-}
rule1163 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1164 #-}
rule1164 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1165 #-}
rule1165 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1166 #-}
rule1166 = \ ((_guardExpressionIbetaUnique) :: Int) ->
_guardExpressionIbetaUnique
{-# INLINE rule1167 #-}
rule1167 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1168 #-}
rule1168 = \ ((_guardExpressionIcollectErrors) :: TypeErrors) ->
_guardExpressionIcollectErrors
{-# INLINE rule1169 #-}
rule1169 = \ ((_guardExpressionIcollectWarnings) :: Warnings) ->
_guardExpressionIcollectWarnings
{-# INLINE rule1170 #-}
rule1170 = \ ((_guardExpressionIcounter) :: Int) ->
_guardExpressionIcounter
{-# INLINE rule1171 #-}
rule1171 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1172 #-}
rule1172 = \ ((_guardExpressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_guardExpressionIdictionaryEnvironment
{-# INLINE rule1173 #-}
rule1173 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1174 #-}
rule1174 = \ ((_guardExpressionImatchIO) :: IO ()) ->
_guardExpressionImatchIO
{-# INLINE rule1175 #-}
rule1175 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1176 #-}
rule1176 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1177 #-}
rule1177 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1178 #-}
rule1178 = \ _parentTree ->
_parentTree
{-# INLINE rule1179 #-}
rule1179 = \ ((_guardExpressionIpatternMatchWarnings) :: [Warning]) ->
_guardExpressionIpatternMatchWarnings
{-# INLINE rule1180 #-}
rule1180 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1181 #-}
rule1181 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1182 #-}
rule1182 = \ ((_guardExpressionIuniqueChunk) :: Int) ->
_guardExpressionIuniqueChunk
{-# INLINE rule1183 #-}
rule1183 = \ ((_guardExpressionIuniqueSecondRound) :: Int) ->
_guardExpressionIuniqueSecondRound
{-# INLINE rule1184 #-}
rule1184 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1185 #-}
rule1185 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1186 #-}
rule1186 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1187 #-}
rule1187 = \ ((_thenExpressionIbetaUnique) :: Int) ->
_thenExpressionIbetaUnique
{-# INLINE rule1188 #-}
rule1188 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1189 #-}
rule1189 = \ ((_thenExpressionIcollectErrors) :: TypeErrors) ->
_thenExpressionIcollectErrors
{-# INLINE rule1190 #-}
rule1190 = \ ((_thenExpressionIcollectWarnings) :: Warnings) ->
_thenExpressionIcollectWarnings
{-# INLINE rule1191 #-}
rule1191 = \ ((_thenExpressionIcounter) :: Int) ->
_thenExpressionIcounter
{-# INLINE rule1192 #-}
rule1192 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1193 #-}
rule1193 = \ ((_thenExpressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_thenExpressionIdictionaryEnvironment
{-# INLINE rule1194 #-}
rule1194 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1195 #-}
rule1195 = \ ((_thenExpressionImatchIO) :: IO ()) ->
_thenExpressionImatchIO
{-# INLINE rule1196 #-}
rule1196 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1197 #-}
rule1197 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1198 #-}
rule1198 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1199 #-}
rule1199 = \ _parentTree ->
_parentTree
{-# INLINE rule1200 #-}
rule1200 = \ ((_thenExpressionIpatternMatchWarnings) :: [Warning]) ->
_thenExpressionIpatternMatchWarnings
{-# INLINE rule1201 #-}
rule1201 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1202 #-}
rule1202 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1203 #-}
rule1203 = \ ((_thenExpressionIuniqueChunk) :: Int) ->
_thenExpressionIuniqueChunk
{-# INLINE rule1204 #-}
rule1204 = \ ((_thenExpressionIuniqueSecondRound) :: Int) ->
_thenExpressionIuniqueSecondRound
{-# NOINLINE sem_Expression_Lambda #-}
sem_Expression_Lambda :: T_Range -> T_Patterns -> T_Expression -> T_Expression
sem_Expression_Lambda arg_range_ arg_patterns_ arg_expression_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_patternsX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_patterns_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Patterns_vOut121 _patternsIbetaUnique _patternsIbetas _patternsIconstraintslist _patternsIcounter _patternsIelementss _patternsIenvironment _patternsIinfoTrees _patternsInumberOfPatterns _patternsIpatVarNames _patternsIpatternMatchWarnings _patternsIself _patternsIunboundNames) = inv_Patterns_s122 _patternsX122 (T_Patterns_vIn121 _patternsObetaUnique _patternsOcounter _patternsOimportEnvironment _patternsOmonos _patternsOnamesInScope _patternsOparentTree _patternsOpatternMatchWarnings)
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_patternsObetaUnique = rule1205 _lhsIbetaUnique
_expressionOmonos = rule1206 _csetBinds _lhsImonos _patternsIenvironment
_constraints = rule1207 _csetBinds _expressionIconstraints _newcon _patternsIconstraintslist
_beta = rule1208 _lhsIbetaUnique
_newcon = rule1209 _beta _cinfoType _expressionIbeta _patternsIbetas
(_csetBinds,_assumptions) = rule1210 _cinfoBind _expressionIassumptions _patternsIenvironment
_cinfoBind = rule1211 _parentTree _patternsIenvironment
_cinfoType = rule1212 _parentTree
_localInfo = rule1213 _beta _lhsImonos _self
_parentTree = rule1214 _expressionIinfoTree _lhsIparentTree _localInfo _patternsIinfoTrees
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1215 _parentTree
(_namesInScope,_unboundNames,_scopeInfo) = rule1216 _expressionIunboundNames _lhsInamesInScope _patternsIpatVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1217 _unboundNames
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOmatches = rule1218 _assumptions _constraints _lhsItryPatterns _localInfo
_expressionOtryPatterns = rule1219 ()
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1220 _beta _expressionIpatternMatchWarnings _lhsIimportEnvironment _lhsIsubstitution _patternsIelementss _patternsIself _rangeIself
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1221 _expressionIcollectInstances
_self = rule1222 _expressionIself _patternsIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule1223 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule1224 _assumptions
_lhsObeta :: Tp
_lhsObeta = rule1225 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1226 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1227 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1228 _expressionIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule1229 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule1230 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1231 _expressionIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1232 _expressionImatchIO
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1233 _expressionIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule1234 _expressionIuniqueSecondRound
_patternsOcounter = rule1235 _lhsIcounter
_patternsOimportEnvironment = rule1236 _lhsIimportEnvironment
_patternsOmonos = rule1237 _lhsImonos
_patternsOnamesInScope = rule1238 _namesInScope
_patternsOparentTree = rule1239 _parentTree
_patternsOpatternMatchWarnings = rule1240 _lhsIpatternMatchWarnings
_expressionOallPatterns = rule1241 _lhsIallPatterns
_expressionOallTypeSchemes = rule1242 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule1243 _lhsIavailablePredicates
_expressionObetaUnique = rule1244 _patternsIbetaUnique
_expressionOclassEnvironment = rule1245 _lhsIclassEnvironment
_expressionOcollectErrors = rule1246 _lhsIcollectErrors
_expressionOcollectWarnings = rule1247 _lhsIcollectWarnings
_expressionOcounter = rule1248 _patternsIcounter
_expressionOcurrentChunk = rule1249 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule1250 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule1251 _lhsIimportEnvironment
_expressionOmatchIO = rule1252 _lhsImatchIO
_expressionOnamesInScope = rule1253 _namesInScope
_expressionOorderedTypeSynonyms = rule1254 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule1255 _parentTree
_expressionOpatternMatchWarnings = rule1256 _patternsIpatternMatchWarnings
_expressionOsubstitution = rule1257 _lhsIsubstitution
_expressionOtypeschemeMap = rule1258 _lhsItypeschemeMap
_expressionOuniqueChunk = rule1259 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule1260 _lhsIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1205 #-}
rule1205 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule1206 #-}
rule1206 = \ _csetBinds ((_lhsImonos) :: Monos) ((_patternsIenvironment) :: PatternAssumptions) ->
M.elems _patternsIenvironment ++ getMonos _csetBinds ++ _lhsImonos
{-# INLINE rule1207 #-}
rule1207 = \ _csetBinds ((_expressionIconstraints) :: ConstraintSet) _newcon ((_patternsIconstraintslist) :: ConstraintSets) ->
_newcon .>. _csetBinds .>>.
Node [ Node _patternsIconstraintslist
, _expressionIconstraints
]
{-# INLINE rule1208 #-}
rule1208 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1209 #-}
rule1209 = \ _beta _cinfoType ((_expressionIbeta) :: Tp) ((_patternsIbetas) :: Tps) ->
[ (foldr (.->.) _expressionIbeta _patternsIbetas .==. _beta) _cinfoType ]
{-# INLINE rule1210 #-}
rule1210 = \ _cinfoBind ((_expressionIassumptions) :: Assumptions) ((_patternsIenvironment) :: PatternAssumptions) ->
(_patternsIenvironment .===. _expressionIassumptions) _cinfoBind
{-# INLINE rule1211 #-}
rule1211 = \ _parentTree ((_patternsIenvironment) :: PatternAssumptions) ->
\name -> variableConstraint "variable" (nameToUHA_Expr name)
[ FolkloreConstraint
, makeUnifier name "lambda abstraction" _patternsIenvironment _parentTree
]
{-# INLINE rule1212 #-}
rule1212 = \ _parentTree ->
resultConstraint "lambda abstraction" _parentTree
[ FolkloreConstraint ]
{-# INLINE rule1213 #-}
rule1213 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1214 #-}
rule1214 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternsIinfoTrees) :: InfoTrees) ->
node _lhsIparentTree _localInfo (_patternsIinfoTrees ++ [_expressionIinfoTree])
{-# INLINE rule1215 #-}
rule1215 = \ _parentTree ->
_parentTree
{-# INLINE rule1216 #-}
rule1216 = \ ((_expressionIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ((_patternsIpatVarNames) :: Names) ->
changeOfScope _patternsIpatVarNames _expressionIunboundNames _lhsInamesInScope
{-# INLINE rule1217 #-}
rule1217 = \ _unboundNames ->
_unboundNames
{-# INLINE rule1218 #-}
rule1218 = \ _assumptions _constraints ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in matchOnlyVariable infoTuple _lhsItryPatterns
{-# INLINE rule1219 #-}
rule1219 = \ (_ :: ()) ->
[]
{-# INLINE rule1220 #-}
rule1220 = \ _beta ((_expressionIpatternMatchWarnings) :: [Warning]) ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_patternsIelementss) :: [ [PatternElement] ]) ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
patternMatchWarnings _lhsIimportEnvironment
_lhsIsubstitution
_beta
(take (length _patternsIself) . fst . functionSpine)
[(concat _patternsIelementss, False)]
_rangeIself
(Just $ Name_Special noRange [] "\\")
True
[]
"lambda expression"
"->"
++ _expressionIpatternMatchWarnings
{-# INLINE rule1221 #-}
rule1221 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances
{-# INLINE rule1222 #-}
rule1222 = \ ((_expressionIself) :: Expression) ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
Expression_Lambda _rangeIself _patternsIself _expressionIself
{-# INLINE rule1223 #-}
rule1223 = \ _self ->
_self
{-# INLINE rule1224 #-}
rule1224 = \ _assumptions ->
_assumptions
{-# INLINE rule1225 #-}
rule1225 = \ _beta ->
_beta
{-# INLINE rule1226 #-}
rule1226 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule1227 #-}
rule1227 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule1228 #-}
rule1228 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule1229 #-}
rule1229 = \ _constraints ->
_constraints
{-# INLINE rule1230 #-}
rule1230 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule1231 #-}
rule1231 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule1232 #-}
rule1232 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule1233 #-}
rule1233 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule1234 #-}
rule1234 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule1235 #-}
rule1235 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1236 #-}
rule1236 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1237 #-}
rule1237 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1238 #-}
rule1238 = \ _namesInScope ->
_namesInScope
{-# INLINE rule1239 #-}
rule1239 = \ _parentTree ->
_parentTree
{-# INLINE rule1240 #-}
rule1240 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1241 #-}
rule1241 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1242 #-}
rule1242 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1243 #-}
rule1243 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1244 #-}
rule1244 = \ ((_patternsIbetaUnique) :: Int) ->
_patternsIbetaUnique
{-# INLINE rule1245 #-}
rule1245 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1246 #-}
rule1246 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1247 #-}
rule1247 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1248 #-}
rule1248 = \ ((_patternsIcounter) :: Int) ->
_patternsIcounter
{-# INLINE rule1249 #-}
rule1249 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1250 #-}
rule1250 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1251 #-}
rule1251 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1252 #-}
rule1252 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1253 #-}
rule1253 = \ _namesInScope ->
_namesInScope
{-# INLINE rule1254 #-}
rule1254 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1255 #-}
rule1255 = \ _parentTree ->
_parentTree
{-# INLINE rule1256 #-}
rule1256 = \ ((_patternsIpatternMatchWarnings) :: [Warning]) ->
_patternsIpatternMatchWarnings
{-# INLINE rule1257 #-}
rule1257 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1258 #-}
rule1258 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1259 #-}
rule1259 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1260 #-}
rule1260 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_Case #-}
sem_Expression_Case :: T_Range -> T_Expression -> T_Alternatives -> T_Expression
sem_Expression_Case arg_range_ arg_expression_ arg_alternatives_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
_alternativesX5 = Control.Monad.Identity.runIdentity (attach_T_Alternatives (arg_alternatives_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
(T_Alternatives_vOut4 _alternativesIassumptions _alternativesIbetaUnique _alternativesIcollectErrors _alternativesIcollectInstances _alternativesIcollectWarnings _alternativesIconstraintslist _alternativesIcounter _alternativesIdictionaryEnvironment _alternativesIelementss _alternativesIinfoTrees _alternativesImatchIO _alternativesIpatternMatchWarnings _alternativesIself _alternativesIunboundNames _alternativesIuniqueChunk _alternativesIunrwars) = inv_Alternatives_s5 _alternativesX5 (T_Alternatives_vIn4 _alternativesOallPatterns _alternativesOallTypeSchemes _alternativesOavailablePredicates _alternativesObetaLeft _alternativesObetaRight _alternativesObetaUnique _alternativesOclassEnvironment _alternativesOcollectErrors _alternativesOcollectWarnings _alternativesOcounter _alternativesOcurrentChunk _alternativesOdictionaryEnvironment _alternativesOimportEnvironment _alternativesOmatchIO _alternativesOmonos _alternativesOnamesInScope _alternativesOorderedTypeSynonyms _alternativesOparentTree _alternativesOpatternMatchWarnings _alternativesOsubstitution _alternativesOtypeschemeMap _alternativesOuniqueChunk)
_expressionObetaUnique = rule1261 _lhsIbetaUnique
_alternativesObetaLeft = rule1262 _beta'
_alternativesObetaRight = rule1263 _beta
_assumptions = rule1264 _alternativesIassumptions _expressionIassumptions
_constraints = rule1265 _alternativesIconstraintslist _expressionIconstraints _newcon
_beta = rule1266 _lhsIbetaUnique
_beta' = rule1267 _lhsIbetaUnique
_newcon = rule1268 _beta' _cinfo _expressionIbeta
_cinfo = rule1269 _beta' _localInfo _parentTree
_localInfo = rule1270 _beta _lhsImonos _self
_parentTree = rule1271 _alternativesIinfoTrees _expressionIinfoTree _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1272 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOmatches = rule1273 _assumptions _constraints _lhsItryPatterns _localInfo
_expressionOtryPatterns = rule1274 ()
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1275 _alternativesIelementss _alternativesIpatternMatchWarnings _alternativesIunrwars _expressionIbeta _lhsIimportEnvironment _lhsIsubstitution _rangeIself
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1276 _alternativesIcollectInstances _expressionIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1277 _alternativesIunboundNames _expressionIunboundNames
_self = rule1278 _alternativesIself _expressionIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule1279 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule1280 _assumptions
_lhsObeta :: Tp
_lhsObeta = rule1281 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1282 _alternativesIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1283 _alternativesIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1284 _alternativesIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule1285 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule1286 _alternativesIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1287 _alternativesIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1288 _alternativesImatchIO
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1289 _alternativesIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule1290 _expressionIuniqueSecondRound
_expressionOallPatterns = rule1291 _lhsIallPatterns
_expressionOallTypeSchemes = rule1292 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule1293 _lhsIavailablePredicates
_expressionOclassEnvironment = rule1294 _lhsIclassEnvironment
_expressionOcollectErrors = rule1295 _lhsIcollectErrors
_expressionOcollectWarnings = rule1296 _lhsIcollectWarnings
_expressionOcounter = rule1297 _lhsIcounter
_expressionOcurrentChunk = rule1298 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule1299 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule1300 _lhsIimportEnvironment
_expressionOmatchIO = rule1301 _lhsImatchIO
_expressionOmonos = rule1302 _lhsImonos
_expressionOnamesInScope = rule1303 _lhsInamesInScope
_expressionOorderedTypeSynonyms = rule1304 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule1305 _parentTree
_expressionOpatternMatchWarnings = rule1306 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule1307 _lhsIsubstitution
_expressionOtypeschemeMap = rule1308 _lhsItypeschemeMap
_expressionOuniqueChunk = rule1309 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule1310 _lhsIuniqueSecondRound
_alternativesOallPatterns = rule1311 _lhsIallPatterns
_alternativesOallTypeSchemes = rule1312 _lhsIallTypeSchemes
_alternativesOavailablePredicates = rule1313 _lhsIavailablePredicates
_alternativesObetaUnique = rule1314 _expressionIbetaUnique
_alternativesOclassEnvironment = rule1315 _lhsIclassEnvironment
_alternativesOcollectErrors = rule1316 _expressionIcollectErrors
_alternativesOcollectWarnings = rule1317 _expressionIcollectWarnings
_alternativesOcounter = rule1318 _expressionIcounter
_alternativesOcurrentChunk = rule1319 _lhsIcurrentChunk
_alternativesOdictionaryEnvironment = rule1320 _expressionIdictionaryEnvironment
_alternativesOimportEnvironment = rule1321 _lhsIimportEnvironment
_alternativesOmatchIO = rule1322 _expressionImatchIO
_alternativesOmonos = rule1323 _lhsImonos
_alternativesOnamesInScope = rule1324 _lhsInamesInScope
_alternativesOorderedTypeSynonyms = rule1325 _lhsIorderedTypeSynonyms
_alternativesOparentTree = rule1326 _parentTree
_alternativesOpatternMatchWarnings = rule1327 _expressionIpatternMatchWarnings
_alternativesOsubstitution = rule1328 _lhsIsubstitution
_alternativesOtypeschemeMap = rule1329 _lhsItypeschemeMap
_alternativesOuniqueChunk = rule1330 _expressionIuniqueChunk
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1261 #-}
rule1261 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 2
{-# INLINE rule1262 #-}
rule1262 = \ _beta' ->
_beta'
{-# INLINE rule1263 #-}
rule1263 = \ _beta ->
_beta
{-# INLINE rule1264 #-}
rule1264 = \ ((_alternativesIassumptions) :: Assumptions) ((_expressionIassumptions) :: Assumptions) ->
_expressionIassumptions `combine` _alternativesIassumptions
{-# INLINE rule1265 #-}
rule1265 = \ ((_alternativesIconstraintslist) :: ConstraintSets) ((_expressionIconstraints) :: ConstraintSet) _newcon ->
Node [ _newcon .<. _expressionIconstraints
, Node _alternativesIconstraintslist
]
{-# INLINE rule1266 #-}
rule1266 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1267 #-}
rule1267 = \ ((_lhsIbetaUnique) :: Int) ->
TVar (_lhsIbetaUnique + 1)
{-# INLINE rule1268 #-}
rule1268 = \ _beta' _cinfo ((_expressionIbeta) :: Tp) ->
[ (_expressionIbeta .==. _beta') _cinfo ]
{-# INLINE rule1269 #-}
rule1269 = \ _beta' _localInfo _parentTree ->
childConstraint 0 "scrutinee of case expression" _parentTree
[ Unifier (head (ftv _beta')) ("case patterns", _localInfo, "scrutinee") ]
{-# INLINE rule1270 #-}
rule1270 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1271 #-}
rule1271 = \ ((_alternativesIinfoTrees) :: InfoTrees) ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo (_expressionIinfoTree : _alternativesIinfoTrees)
{-# INLINE rule1272 #-}
rule1272 = \ _parentTree ->
_parentTree
{-# INLINE rule1273 #-}
rule1273 = \ _assumptions _constraints ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in matchOnlyVariable infoTuple _lhsItryPatterns
{-# INLINE rule1274 #-}
rule1274 = \ (_ :: ()) ->
[]
{-# INLINE rule1275 #-}
rule1275 = \ ((_alternativesIelementss) :: [([PatternElement], Bool)]) ((_alternativesIpatternMatchWarnings) :: [Warning]) ((_alternativesIunrwars) :: [Warning]) ((_expressionIbeta) :: Tp) ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_rangeIself) :: Range) ->
patternMatchWarnings _lhsIimportEnvironment
_lhsIsubstitution
_expressionIbeta
(:[])
_alternativesIelementss
_rangeIself
Nothing
False
_alternativesIunrwars
"case expression"
"->"
++ _alternativesIpatternMatchWarnings
{-# INLINE rule1276 #-}
rule1276 = \ ((_alternativesIcollectInstances) :: [(Name, Instance)]) ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances ++ _alternativesIcollectInstances
{-# INLINE rule1277 #-}
rule1277 = \ ((_alternativesIunboundNames) :: Names) ((_expressionIunboundNames) :: Names) ->
_expressionIunboundNames ++ _alternativesIunboundNames
{-# INLINE rule1278 #-}
rule1278 = \ ((_alternativesIself) :: Alternatives) ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
Expression_Case _rangeIself _expressionIself _alternativesIself
{-# INLINE rule1279 #-}
rule1279 = \ _self ->
_self
{-# INLINE rule1280 #-}
rule1280 = \ _assumptions ->
_assumptions
{-# INLINE rule1281 #-}
rule1281 = \ _beta ->
_beta
{-# INLINE rule1282 #-}
rule1282 = \ ((_alternativesIbetaUnique) :: Int) ->
_alternativesIbetaUnique
{-# INLINE rule1283 #-}
rule1283 = \ ((_alternativesIcollectErrors) :: TypeErrors) ->
_alternativesIcollectErrors
{-# INLINE rule1284 #-}
rule1284 = \ ((_alternativesIcollectWarnings) :: Warnings) ->
_alternativesIcollectWarnings
{-# INLINE rule1285 #-}
rule1285 = \ _constraints ->
_constraints
{-# INLINE rule1286 #-}
rule1286 = \ ((_alternativesIcounter) :: Int) ->
_alternativesIcounter
{-# INLINE rule1287 #-}
rule1287 = \ ((_alternativesIdictionaryEnvironment) :: DictionaryEnvironment) ->
_alternativesIdictionaryEnvironment
{-# INLINE rule1288 #-}
rule1288 = \ ((_alternativesImatchIO) :: IO ()) ->
_alternativesImatchIO
{-# INLINE rule1289 #-}
rule1289 = \ ((_alternativesIuniqueChunk) :: Int) ->
_alternativesIuniqueChunk
{-# INLINE rule1290 #-}
rule1290 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule1291 #-}
rule1291 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1292 #-}
rule1292 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1293 #-}
rule1293 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1294 #-}
rule1294 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1295 #-}
rule1295 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1296 #-}
rule1296 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1297 #-}
rule1297 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1298 #-}
rule1298 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1299 #-}
rule1299 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1300 #-}
rule1300 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1301 #-}
rule1301 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1302 #-}
rule1302 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1303 #-}
rule1303 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1304 #-}
rule1304 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1305 #-}
rule1305 = \ _parentTree ->
_parentTree
{-# INLINE rule1306 #-}
rule1306 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1307 #-}
rule1307 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1308 #-}
rule1308 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1309 #-}
rule1309 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1310 #-}
rule1310 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule1311 #-}
rule1311 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1312 #-}
rule1312 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1313 #-}
rule1313 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1314 #-}
rule1314 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule1315 #-}
rule1315 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1316 #-}
rule1316 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule1317 #-}
rule1317 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule1318 #-}
rule1318 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule1319 #-}
rule1319 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1320 #-}
rule1320 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule1321 #-}
rule1321 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1322 #-}
rule1322 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule1323 #-}
rule1323 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1324 #-}
rule1324 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1325 #-}
rule1325 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1326 #-}
rule1326 = \ _parentTree ->
_parentTree
{-# INLINE rule1327 #-}
rule1327 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule1328 #-}
rule1328 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1329 #-}
rule1329 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1330 #-}
rule1330 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# NOINLINE sem_Expression_Let #-}
sem_Expression_Let :: T_Range -> T_Declarations -> T_Expression -> T_Expression
sem_Expression_Let arg_range_ arg_declarations_ arg_expression_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_declarationsX32 = Control.Monad.Identity.runIdentity (attach_T_Declarations (arg_declarations_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Declarations_vOut31 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsIcollectErrors _declarationsIcollectInstances _declarationsIcollectWarnings _declarationsIcounter _declarationsIdeclVarNames _declarationsIdictionaryEnvironment _declarationsIinfoTrees _declarationsImatchIO _declarationsIpatternMatchWarnings _declarationsIrestrictedNames _declarationsIself _declarationsIsimplePatNames _declarationsItypeSignatures _declarationsIunboundNames _declarationsIuniqueChunk) = inv_Declarations_s32 _declarationsX32 (T_Declarations_vIn31 _declarationsOallPatterns _declarationsOallTypeSchemes _declarationsOavailablePredicates _declarationsObetaUnique _declarationsObindingGroups _declarationsOclassEnvironment _declarationsOcollectErrors _declarationsOcollectWarnings _declarationsOcounter _declarationsOcurrentChunk _declarationsOdictionaryEnvironment _declarationsOimportEnvironment _declarationsOinheritedBDG _declarationsOmatchIO _declarationsOmonos _declarationsOnamesInScope _declarationsOorderedTypeSynonyms _declarationsOparentTree _declarationsOpatternMatchWarnings _declarationsOsubstitution _declarationsOtypeSignatures _declarationsOtypeschemeMap _declarationsOuniqueChunk)
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_declarationsObetaUnique = rule1331 _lhsIbetaUnique
_declarationsObindingGroups = rule1332 ()
_constraints = rule1333 _beta _cinfoType _cset _expressionIbeta
_beta = rule1334 _lhsIbetaUnique
_lhsObetaUnique :: Int
(_assumptions,_cset,_inheritedBDG,_chunkNr,_lhsObetaUnique,_implicitsFM) = rule1335 _declarationsIbindingGroups _declarationsItypeSignatures _expressionIassumptions _expressionIbetaUnique _expressionIconstraints _expressionIuniqueChunk _lhsIcurrentChunk _lhsImonos
_inferredTypes = rule1336 _implicitsFM _lhsItypeschemeMap
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1337 _declarationsIsimplePatNames _expressionIcollectWarnings _inferredTypes
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1338 _declarationsIcollectErrors _declarationsIrestrictedNames _inferredTypes
_allTypeSchemes = rule1339 _lhsIallTypeSchemes _localTypes
_localTypes = rule1340 _declarationsIbindingGroups _declarationsItypeSignatures _inferredTypes
_declarationsOtypeSignatures = rule1341 ()
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1342 _chunkNr
_cinfoType = rule1343 _thisTree
_localInfo = rule1344 _beta _lhsImonos _self
_declInfo = rule1345 _declarationsIself _lhsImonos
_thisTree = rule1346 _declTree _expressionIinfoTree _lhsIparentTree _localInfo
_declTree = rule1347 _declInfo _declarationsIinfoTrees _thisTree
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1348 _thisTree
_expressionOparentTree = rule1349 _thisTree
_declarationsOparentTree = rule1350 _declTree
(_collectTypeConstructors,_collectValueConstructors,_collectTypeSynonyms,_collectConstructorEnv,_derivedFunctions,_operatorFixities) = rule1351 ()
(_namesInScope,_unboundNames,_scopeInfo) = rule1352 _declarationsIdeclVarNames _declarationsIunboundNames _expressionIunboundNames _lhsInamesInScope
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1353 _unboundNames
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOmatches = rule1354 _assumptions _constraints _lhsItryPatterns _localInfo
_expressionOtryPatterns = rule1355 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1356 _declarationsIcollectInstances _expressionIcollectInstances
_self = rule1357 _declarationsIself _expressionIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule1358 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule1359 _assumptions
_lhsObeta :: Tp
_lhsObeta = rule1360 _beta
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule1361 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule1362 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1363 _expressionIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1364 _expressionImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1365 _expressionIpatternMatchWarnings
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule1366 _expressionIuniqueSecondRound
_declarationsOallPatterns = rule1367 _lhsIallPatterns
_declarationsOallTypeSchemes = rule1368 _allTypeSchemes
_declarationsOavailablePredicates = rule1369 _lhsIavailablePredicates
_declarationsOclassEnvironment = rule1370 _lhsIclassEnvironment
_declarationsOcollectErrors = rule1371 _lhsIcollectErrors
_declarationsOcollectWarnings = rule1372 _lhsIcollectWarnings
_declarationsOcounter = rule1373 _lhsIcounter
_declarationsOcurrentChunk = rule1374 _lhsIcurrentChunk
_declarationsOdictionaryEnvironment = rule1375 _lhsIdictionaryEnvironment
_declarationsOimportEnvironment = rule1376 _lhsIimportEnvironment
_declarationsOinheritedBDG = rule1377 _inheritedBDG
_declarationsOmatchIO = rule1378 _lhsImatchIO
_declarationsOmonos = rule1379 _lhsImonos
_declarationsOnamesInScope = rule1380 _namesInScope
_declarationsOorderedTypeSynonyms = rule1381 _lhsIorderedTypeSynonyms
_declarationsOpatternMatchWarnings = rule1382 _lhsIpatternMatchWarnings
_declarationsOsubstitution = rule1383 _lhsIsubstitution
_declarationsOtypeschemeMap = rule1384 _lhsItypeschemeMap
_declarationsOuniqueChunk = rule1385 _lhsIuniqueChunk
_expressionOallPatterns = rule1386 _lhsIallPatterns
_expressionOallTypeSchemes = rule1387 _allTypeSchemes
_expressionOavailablePredicates = rule1388 _lhsIavailablePredicates
_expressionObetaUnique = rule1389 _declarationsIbetaUnique
_expressionOclassEnvironment = rule1390 _lhsIclassEnvironment
_expressionOcollectErrors = rule1391 _declarationsIcollectErrors
_expressionOcollectWarnings = rule1392 _declarationsIcollectWarnings
_expressionOcounter = rule1393 _declarationsIcounter
_expressionOcurrentChunk = rule1394 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule1395 _declarationsIdictionaryEnvironment
_expressionOimportEnvironment = rule1396 _lhsIimportEnvironment
_expressionOmatchIO = rule1397 _declarationsImatchIO
_expressionOmonos = rule1398 _lhsImonos
_expressionOnamesInScope = rule1399 _namesInScope
_expressionOorderedTypeSynonyms = rule1400 _lhsIorderedTypeSynonyms
_expressionOpatternMatchWarnings = rule1401 _declarationsIpatternMatchWarnings
_expressionOsubstitution = rule1402 _lhsIsubstitution
_expressionOtypeschemeMap = rule1403 _lhsItypeschemeMap
_expressionOuniqueChunk = rule1404 _declarationsIuniqueChunk
_expressionOuniqueSecondRound = rule1405 _lhsIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1331 #-}
rule1331 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule1332 #-}
rule1332 = \ (_ :: ()) ->
[]
{-# INLINE rule1333 #-}
rule1333 = \ _beta _cinfoType _cset ((_expressionIbeta) :: Tp) ->
[ (_expressionIbeta .==. _beta) _cinfoType ] .>. _cset
{-# INLINE rule1334 #-}
rule1334 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1335 #-}
rule1335 = \ ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) ((_expressionIassumptions) :: Assumptions) ((_expressionIbetaUnique) :: Int) ((_expressionIconstraints) :: ConstraintSet) ((_expressionIuniqueChunk) :: Int) ((_lhsIcurrentChunk) :: Int) ((_lhsImonos) :: Monos) ->
let inputBDG = (False, _lhsIcurrentChunk, _expressionIuniqueChunk, _lhsImonos, _declarationsItypeSignatures, mybdggroup, _expressionIbetaUnique)
mybdggroup = Just (_expressionIassumptions, [_expressionIconstraints])
in performBindingGroup inputBDG _declarationsIbindingGroups
{-# INLINE rule1336 #-}
rule1336 = \ _implicitsFM ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
findInferredTypes _lhsItypeschemeMap _implicitsFM
{-# INLINE rule1337 #-}
rule1337 = \ ((_declarationsIsimplePatNames) :: Names) ((_expressionIcollectWarnings) :: Warnings) _inferredTypes ->
missingTypeSignature False _declarationsIsimplePatNames _inferredTypes
++ _expressionIcollectWarnings
{-# INLINE rule1338 #-}
rule1338 = \ ((_declarationsIcollectErrors) :: TypeErrors) ((_declarationsIrestrictedNames) :: Names) _inferredTypes ->
restrictedNameErrors _inferredTypes _declarationsIrestrictedNames
++ _declarationsIcollectErrors
{-# INLINE rule1339 #-}
rule1339 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) _localTypes ->
_localTypes `M.union` _lhsIallTypeSchemes
{-# INLINE rule1340 #-}
rule1340 = \ ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) _inferredTypes ->
makeLocalTypeEnv (_declarationsItypeSignatures `M.union` _inferredTypes) _declarationsIbindingGroups
{-# INLINE rule1341 #-}
rule1341 = \ (_ :: ()) ->
M.empty
{-# INLINE rule1342 #-}
rule1342 = \ _chunkNr ->
_chunkNr
{-# INLINE rule1343 #-}
rule1343 = \ _thisTree ->
resultConstraint "let expression (INTERNAL ERROR)" _thisTree
[ FolkloreConstraint, highlyTrusted ]
{-# INLINE rule1344 #-}
rule1344 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1345 #-}
rule1345 = \ ((_declarationsIself) :: Declarations) ((_lhsImonos) :: Monos) ->
LocalInfo { self = UHA_Decls _declarationsIself
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule1346 #-}
rule1346 = \ _declTree ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo [_declTree, _expressionIinfoTree]
{-# INLINE rule1347 #-}
rule1347 = \ _declInfo ((_declarationsIinfoTrees) :: InfoTrees) _thisTree ->
node _thisTree _declInfo _declarationsIinfoTrees
{-# INLINE rule1348 #-}
rule1348 = \ _thisTree ->
_thisTree
{-# INLINE rule1349 #-}
rule1349 = \ _thisTree ->
_thisTree
{-# INLINE rule1350 #-}
rule1350 = \ _declTree ->
_declTree
{-# INLINE rule1351 #-}
rule1351 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "toplevel Expression"
{-# INLINE rule1352 #-}
rule1352 = \ ((_declarationsIdeclVarNames) :: Names) ((_declarationsIunboundNames) :: Names) ((_expressionIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ->
changeOfScope _declarationsIdeclVarNames (_declarationsIunboundNames ++ _expressionIunboundNames) _lhsInamesInScope
{-# INLINE rule1353 #-}
rule1353 = \ _unboundNames ->
_unboundNames
{-# INLINE rule1354 #-}
rule1354 = \ _assumptions _constraints ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in matchOnlyVariable infoTuple _lhsItryPatterns
{-# INLINE rule1355 #-}
rule1355 = \ (_ :: ()) ->
[]
{-# INLINE rule1356 #-}
rule1356 = \ ((_declarationsIcollectInstances) :: [(Name, Instance)]) ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_declarationsIcollectInstances ++ _expressionIcollectInstances
{-# INLINE rule1357 #-}
rule1357 = \ ((_declarationsIself) :: Declarations) ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
Expression_Let _rangeIself _declarationsIself _expressionIself
{-# INLINE rule1358 #-}
rule1358 = \ _self ->
_self
{-# INLINE rule1359 #-}
rule1359 = \ _assumptions ->
_assumptions
{-# INLINE rule1360 #-}
rule1360 = \ _beta ->
_beta
{-# INLINE rule1361 #-}
rule1361 = \ _constraints ->
_constraints
{-# INLINE rule1362 #-}
rule1362 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule1363 #-}
rule1363 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule1364 #-}
rule1364 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule1365 #-}
rule1365 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule1366 #-}
rule1366 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule1367 #-}
rule1367 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1368 #-}
rule1368 = \ _allTypeSchemes ->
_allTypeSchemes
{-# INLINE rule1369 #-}
rule1369 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1370 #-}
rule1370 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1371 #-}
rule1371 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1372 #-}
rule1372 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1373 #-}
rule1373 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1374 #-}
rule1374 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1375 #-}
rule1375 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1376 #-}
rule1376 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1377 #-}
rule1377 = \ _inheritedBDG ->
_inheritedBDG
{-# INLINE rule1378 #-}
rule1378 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1379 #-}
rule1379 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1380 #-}
rule1380 = \ _namesInScope ->
_namesInScope
{-# INLINE rule1381 #-}
rule1381 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1382 #-}
rule1382 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1383 #-}
rule1383 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1384 #-}
rule1384 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1385 #-}
rule1385 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1386 #-}
rule1386 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1387 #-}
rule1387 = \ _allTypeSchemes ->
_allTypeSchemes
{-# INLINE rule1388 #-}
rule1388 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1389 #-}
rule1389 = \ ((_declarationsIbetaUnique) :: Int) ->
_declarationsIbetaUnique
{-# INLINE rule1390 #-}
rule1390 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1391 #-}
rule1391 = \ ((_declarationsIcollectErrors) :: TypeErrors) ->
_declarationsIcollectErrors
{-# INLINE rule1392 #-}
rule1392 = \ ((_declarationsIcollectWarnings) :: Warnings) ->
_declarationsIcollectWarnings
{-# INLINE rule1393 #-}
rule1393 = \ ((_declarationsIcounter) :: Int) ->
_declarationsIcounter
{-# INLINE rule1394 #-}
rule1394 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1395 #-}
rule1395 = \ ((_declarationsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_declarationsIdictionaryEnvironment
{-# INLINE rule1396 #-}
rule1396 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1397 #-}
rule1397 = \ ((_declarationsImatchIO) :: IO ()) ->
_declarationsImatchIO
{-# INLINE rule1398 #-}
rule1398 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1399 #-}
rule1399 = \ _namesInScope ->
_namesInScope
{-# INLINE rule1400 #-}
rule1400 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1401 #-}
rule1401 = \ ((_declarationsIpatternMatchWarnings) :: [Warning]) ->
_declarationsIpatternMatchWarnings
{-# INLINE rule1402 #-}
rule1402 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1403 #-}
rule1403 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1404 #-}
rule1404 = \ ((_declarationsIuniqueChunk) :: Int) ->
_declarationsIuniqueChunk
{-# INLINE rule1405 #-}
rule1405 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_Do #-}
sem_Expression_Do :: T_Range -> T_Statements -> T_Expression
sem_Expression_Do arg_range_ arg_statements_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_statementsX158 = Control.Monad.Identity.runIdentity (attach_T_Statements (arg_statements_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Statements_vOut157 _statementsIassumptions _statementsIbetaUnique _statementsIcollectErrors _statementsIcollectInstances _statementsIcollectWarnings _statementsIconstraints _statementsIcounter _statementsIdictionaryEnvironment _statementsIgeneratorBeta _statementsIinfoTrees _statementsImatchIO _statementsInamesInScope _statementsIpatternMatchWarnings _statementsIself _statementsIunboundNames _statementsIuniqueChunk _statementsIuniqueSecondRound) = inv_Statements_s158 _statementsX158 (T_Statements_vIn157 _statementsOallPatterns _statementsOallTypeSchemes _statementsOassumptions _statementsOavailablePredicates _statementsObetaUnique _statementsOclassEnvironment _statementsOcollectErrors _statementsOcollectWarnings _statementsOconstraints _statementsOcounter _statementsOcurrentChunk _statementsOdictionaryEnvironment _statementsOgeneratorBeta _statementsOimportEnvironment _statementsOmatchIO _statementsOmonos _statementsOnamesInScope _statementsOorderedTypeSynonyms _statementsOparentTree _statementsOpatternMatchWarnings _statementsOsubstitution _statementsOtypeschemeMap _statementsOunboundNames _statementsOuniqueChunk _statementsOuniqueSecondRound)
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule1406 _newcon _statementsIconstraints
_statementsObetaUnique = rule1407 _lhsIbetaUnique
_statementsOgeneratorBeta = rule1408 ()
_statementsOassumptions = rule1409 ()
_assumptions = rule1410 _statementsIassumptions
_constraints = rule1411 ()
_beta = rule1412 _lhsIbetaUnique
_newcon = rule1413 _beta _cinfo _statementsIgeneratorBeta
_cinfo = rule1414 _parentTree
_localInfo = rule1415 _beta _lhsImonos _self
_parentTree = rule1416 _lhsIparentTree _localInfo _statementsIinfoTrees
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1417 _parentTree
_statementsOunboundNames = rule1418 ()
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOmatches = rule1419 _assumptions _constraints _lhsItryPatterns _localInfo
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1420 _statementsIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1421 _statementsIunboundNames
_self = rule1422 _rangeIself _statementsIself
_lhsOself :: Expression
_lhsOself = rule1423 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule1424 _assumptions
_lhsObeta :: Tp
_lhsObeta = rule1425 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1426 _statementsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1427 _statementsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1428 _statementsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule1429 _statementsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1430 _statementsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1431 _statementsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1432 _statementsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1433 _statementsIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule1434 _statementsIuniqueSecondRound
_statementsOallPatterns = rule1435 _lhsIallPatterns
_statementsOallTypeSchemes = rule1436 _lhsIallTypeSchemes
_statementsOavailablePredicates = rule1437 _lhsIavailablePredicates
_statementsOclassEnvironment = rule1438 _lhsIclassEnvironment
_statementsOcollectErrors = rule1439 _lhsIcollectErrors
_statementsOcollectWarnings = rule1440 _lhsIcollectWarnings
_statementsOconstraints = rule1441 _constraints
_statementsOcounter = rule1442 _lhsIcounter
_statementsOcurrentChunk = rule1443 _lhsIcurrentChunk
_statementsOdictionaryEnvironment = rule1444 _lhsIdictionaryEnvironment
_statementsOimportEnvironment = rule1445 _lhsIimportEnvironment
_statementsOmatchIO = rule1446 _lhsImatchIO
_statementsOmonos = rule1447 _lhsImonos
_statementsOnamesInScope = rule1448 _lhsInamesInScope
_statementsOorderedTypeSynonyms = rule1449 _lhsIorderedTypeSynonyms
_statementsOparentTree = rule1450 _parentTree
_statementsOpatternMatchWarnings = rule1451 _lhsIpatternMatchWarnings
_statementsOsubstitution = rule1452 _lhsIsubstitution
_statementsOtypeschemeMap = rule1453 _lhsItypeschemeMap
_statementsOuniqueChunk = rule1454 _lhsIuniqueChunk
_statementsOuniqueSecondRound = rule1455 _lhsIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1406 #-}
rule1406 = \ _newcon ((_statementsIconstraints) :: ConstraintSet) ->
Node [ _newcon .<. _statementsIconstraints ]
{-# INLINE rule1407 #-}
rule1407 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule1408 #-}
rule1408 = \ (_ :: ()) ->
Nothing
{-# INLINE rule1409 #-}
rule1409 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule1410 #-}
rule1410 = \ ((_statementsIassumptions) :: Assumptions) ->
_statementsIassumptions
{-# INLINE rule1411 #-}
rule1411 = \ (_ :: ()) ->
emptyTree
{-# INLINE rule1412 #-}
rule1412 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1413 #-}
rule1413 = \ _beta _cinfo ((_statementsIgeneratorBeta) :: Maybe Tp) ->
case _statementsIgeneratorBeta of
Nothing -> []
Just b -> [ (ioType b .==. _beta) _cinfo ]
{-# INLINE rule1414 #-}
rule1414 = \ _parentTree ->
resultConstraint "do-expression" _parentTree
[ FolkloreConstraint ]
{-# INLINE rule1415 #-}
rule1415 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1416 #-}
rule1416 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_statementsIinfoTrees) :: InfoTrees) ->
node _lhsIparentTree _localInfo _statementsIinfoTrees
{-# INLINE rule1417 #-}
rule1417 = \ _parentTree ->
_parentTree
{-# INLINE rule1418 #-}
rule1418 = \ (_ :: ()) ->
[]
{-# INLINE rule1419 #-}
rule1419 = \ _assumptions _constraints ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in matchOnlyVariable infoTuple _lhsItryPatterns
{-# INLINE rule1420 #-}
rule1420 = \ ((_statementsIcollectInstances) :: [(Name, Instance)]) ->
_statementsIcollectInstances
{-# INLINE rule1421 #-}
rule1421 = \ ((_statementsIunboundNames) :: Names) ->
_statementsIunboundNames
{-# INLINE rule1422 #-}
rule1422 = \ ((_rangeIself) :: Range) ((_statementsIself) :: Statements) ->
Expression_Do _rangeIself _statementsIself
{-# INLINE rule1423 #-}
rule1423 = \ _self ->
_self
{-# INLINE rule1424 #-}
rule1424 = \ _assumptions ->
_assumptions
{-# INLINE rule1425 #-}
rule1425 = \ _beta ->
_beta
{-# INLINE rule1426 #-}
rule1426 = \ ((_statementsIbetaUnique) :: Int) ->
_statementsIbetaUnique
{-# INLINE rule1427 #-}
rule1427 = \ ((_statementsIcollectErrors) :: TypeErrors) ->
_statementsIcollectErrors
{-# INLINE rule1428 #-}
rule1428 = \ ((_statementsIcollectWarnings) :: Warnings) ->
_statementsIcollectWarnings
{-# INLINE rule1429 #-}
rule1429 = \ ((_statementsIcounter) :: Int) ->
_statementsIcounter
{-# INLINE rule1430 #-}
rule1430 = \ ((_statementsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_statementsIdictionaryEnvironment
{-# INLINE rule1431 #-}
rule1431 = \ ((_statementsImatchIO) :: IO ()) ->
_statementsImatchIO
{-# INLINE rule1432 #-}
rule1432 = \ ((_statementsIpatternMatchWarnings) :: [Warning]) ->
_statementsIpatternMatchWarnings
{-# INLINE rule1433 #-}
rule1433 = \ ((_statementsIuniqueChunk) :: Int) ->
_statementsIuniqueChunk
{-# INLINE rule1434 #-}
rule1434 = \ ((_statementsIuniqueSecondRound) :: Int) ->
_statementsIuniqueSecondRound
{-# INLINE rule1435 #-}
rule1435 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1436 #-}
rule1436 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1437 #-}
rule1437 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1438 #-}
rule1438 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1439 #-}
rule1439 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1440 #-}
rule1440 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1441 #-}
rule1441 = \ _constraints ->
_constraints
{-# INLINE rule1442 #-}
rule1442 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1443 #-}
rule1443 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1444 #-}
rule1444 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1445 #-}
rule1445 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1446 #-}
rule1446 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1447 #-}
rule1447 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1448 #-}
rule1448 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1449 #-}
rule1449 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1450 #-}
rule1450 = \ _parentTree ->
_parentTree
{-# INLINE rule1451 #-}
rule1451 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1452 #-}
rule1452 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1453 #-}
rule1453 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1454 #-}
rule1454 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1455 #-}
rule1455 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_List #-}
sem_Expression_List :: T_Range -> T_Expressions -> T_Expression
sem_Expression_List arg_range_ arg_expressions_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionsX44 = Control.Monad.Identity.runIdentity (attach_T_Expressions (arg_expressions_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expressions_vOut43 _expressionsIassumptions _expressionsIbetaUnique _expressionsIbetas _expressionsIcollectErrors _expressionsIcollectInstances _expressionsIcollectWarnings _expressionsIconstraintslist _expressionsIcounter _expressionsIdictionaryEnvironment _expressionsIinfoTrees _expressionsImatchIO _expressionsImatches _expressionsIpatternMatchWarnings _expressionsIself _expressionsIunboundNames _expressionsIuniqueChunk _expressionsIuniqueSecondRound) = inv_Expressions_s44 _expressionsX44 (T_Expressions_vIn43 _expressionsOallPatterns _expressionsOallTypeSchemes _expressionsOavailablePredicates _expressionsObetaUnique _expressionsOclassEnvironment _expressionsOcollectErrors _expressionsOcollectWarnings _expressionsOcounter _expressionsOcurrentChunk _expressionsOdictionaryEnvironment _expressionsOimportEnvironment _expressionsOmatchIO _expressionsOmonos _expressionsOnamesInScope _expressionsOorderedTypeSynonyms _expressionsOparentTree _expressionsOpatternMatchWarnings _expressionsOsubstitution _expressionsOtryPatterns _expressionsOtypeschemeMap _expressionsOuniqueChunk _expressionsOuniqueSecondRound)
_expressionsObetaUnique = rule1456 _lhsIbetaUnique
_constraints = rule1457 _expressionsIbetas _expressionsIconstraintslist _newcon _zipf
_beta = rule1458 _lhsIbetaUnique
_beta' = rule1459 _lhsIbetaUnique
_newcon = rule1460 _beta _beta' _cinfoResult
_zipf = rule1461 _beta' _cinfoElem
_cinfoElem = rule1462 _beta' _expressionsIbetas _localInfo _parentTree
_cinfoResult = rule1463 _parentTree
_localInfo = rule1464 _beta _lhsImonos _self
_parentTree = rule1465 _expressionsIinfoTrees _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1466 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOconstraints :: ConstraintSet
_lhsOassumptions :: Assumptions
_lhsOuniqueSecondRound :: Int
(_expressionsOtryPatterns,_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1467 _constraints _expressionsIassumptions _expressionsImatches _expressionsIuniqueSecondRound _lhsIallPatterns _lhsItryPatterns _localInfo
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1468 _expressionsImatchIO _ioMatch
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1469 _expressionsIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1470 _expressionsIunboundNames
_self = rule1471 _expressionsIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule1472 _self
_lhsObeta :: Tp
_lhsObeta = rule1473 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1474 _expressionsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1475 _expressionsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1476 _expressionsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule1477 _expressionsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1478 _expressionsIdictionaryEnvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1479 _expressionsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1480 _expressionsIuniqueChunk
_expressionsOallPatterns = rule1481 _lhsIallPatterns
_expressionsOallTypeSchemes = rule1482 _lhsIallTypeSchemes
_expressionsOavailablePredicates = rule1483 _lhsIavailablePredicates
_expressionsOclassEnvironment = rule1484 _lhsIclassEnvironment
_expressionsOcollectErrors = rule1485 _lhsIcollectErrors
_expressionsOcollectWarnings = rule1486 _lhsIcollectWarnings
_expressionsOcounter = rule1487 _lhsIcounter
_expressionsOcurrentChunk = rule1488 _lhsIcurrentChunk
_expressionsOdictionaryEnvironment = rule1489 _lhsIdictionaryEnvironment
_expressionsOimportEnvironment = rule1490 _lhsIimportEnvironment
_expressionsOmatchIO = rule1491 _lhsImatchIO
_expressionsOmonos = rule1492 _lhsImonos
_expressionsOnamesInScope = rule1493 _lhsInamesInScope
_expressionsOorderedTypeSynonyms = rule1494 _lhsIorderedTypeSynonyms
_expressionsOparentTree = rule1495 _parentTree
_expressionsOpatternMatchWarnings = rule1496 _lhsIpatternMatchWarnings
_expressionsOsubstitution = rule1497 _lhsIsubstitution
_expressionsOtypeschemeMap = rule1498 _lhsItypeschemeMap
_expressionsOuniqueChunk = rule1499 _lhsIuniqueChunk
_expressionsOuniqueSecondRound = rule1500 _lhsIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1456 #-}
rule1456 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 2
{-# INLINE rule1457 #-}
rule1457 = \ ((_expressionsIbetas) :: Tps) ((_expressionsIconstraintslist) :: ConstraintSets) _newcon _zipf ->
_newcon .>.
Node (zipWith3 _zipf _expressionsIbetas [0..] _expressionsIconstraintslist)
{-# INLINE rule1458 #-}
rule1458 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1459 #-}
rule1459 = \ ((_lhsIbetaUnique) :: Int) ->
TVar (_lhsIbetaUnique + 1)
{-# INLINE rule1460 #-}
rule1460 = \ _beta _beta' _cinfoResult ->
[ (listType _beta' .==. _beta) _cinfoResult ]
{-# INLINE rule1461 #-}
rule1461 = \ _beta' _cinfoElem ->
\tp childNr ctree -> [ (tp .==. _beta') (_cinfoElem childNr) ] .<. ctree
{-# INLINE rule1462 #-}
rule1462 = \ _beta' ((_expressionsIbetas) :: Tps) _localInfo _parentTree ->
\elemNr ->
childConstraint elemNr "element of list" _parentTree $
[ HasTrustFactor 10.0 | length _expressionsIbetas < 2 ] ++
[ Unifier (head (ftv _beta')) ("list", _localInfo, ordinal False (elemNr+1) ++ " element") ]
{-# INLINE rule1463 #-}
rule1463 = \ _parentTree ->
resultConstraint "list" _parentTree
[ FolkloreConstraint ]
{-# INLINE rule1464 #-}
rule1464 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1465 #-}
rule1465 = \ ((_expressionsIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo (_expressionsIinfoTrees)
{-# INLINE rule1466 #-}
rule1466 = \ _parentTree ->
_parentTree
{-# INLINE rule1467 #-}
rule1467 = \ _constraints ((_expressionsIassumptions) :: Assumptions) ((_expressionsImatches) :: [Maybe MetaVariableTable]) ((_expressionsIuniqueSecondRound) :: Int) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ->
let infoTuple = metaVarInfo _constraints _expressionsIassumptions _localInfo
in match1 infoTuple _expressionsIuniqueSecondRound
match_Expression_List
_lhsItryPatterns _lhsIallPatterns
[_expressionsImatches]
{-# INLINE rule1468 #-}
rule1468 = \ ((_expressionsImatchIO) :: IO ()) _ioMatch ->
_expressionsImatchIO >> _ioMatch
{-# INLINE rule1469 #-}
rule1469 = \ ((_expressionsIcollectInstances) :: [(Name, Instance)]) ->
_expressionsIcollectInstances
{-# INLINE rule1470 #-}
rule1470 = \ ((_expressionsIunboundNames) :: Names) ->
_expressionsIunboundNames
{-# INLINE rule1471 #-}
rule1471 = \ ((_expressionsIself) :: Expressions) ((_rangeIself) :: Range) ->
Expression_List _rangeIself _expressionsIself
{-# INLINE rule1472 #-}
rule1472 = \ _self ->
_self
{-# INLINE rule1473 #-}
rule1473 = \ _beta ->
_beta
{-# INLINE rule1474 #-}
rule1474 = \ ((_expressionsIbetaUnique) :: Int) ->
_expressionsIbetaUnique
{-# INLINE rule1475 #-}
rule1475 = \ ((_expressionsIcollectErrors) :: TypeErrors) ->
_expressionsIcollectErrors
{-# INLINE rule1476 #-}
rule1476 = \ ((_expressionsIcollectWarnings) :: Warnings) ->
_expressionsIcollectWarnings
{-# INLINE rule1477 #-}
rule1477 = \ ((_expressionsIcounter) :: Int) ->
_expressionsIcounter
{-# INLINE rule1478 #-}
rule1478 = \ ((_expressionsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionsIdictionaryEnvironment
{-# INLINE rule1479 #-}
rule1479 = \ ((_expressionsIpatternMatchWarnings) :: [Warning]) ->
_expressionsIpatternMatchWarnings
{-# INLINE rule1480 #-}
rule1480 = \ ((_expressionsIuniqueChunk) :: Int) ->
_expressionsIuniqueChunk
{-# INLINE rule1481 #-}
rule1481 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1482 #-}
rule1482 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1483 #-}
rule1483 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1484 #-}
rule1484 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1485 #-}
rule1485 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1486 #-}
rule1486 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1487 #-}
rule1487 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1488 #-}
rule1488 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1489 #-}
rule1489 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1490 #-}
rule1490 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1491 #-}
rule1491 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1492 #-}
rule1492 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1493 #-}
rule1493 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1494 #-}
rule1494 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1495 #-}
rule1495 = \ _parentTree ->
_parentTree
{-# INLINE rule1496 #-}
rule1496 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1497 #-}
rule1497 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1498 #-}
rule1498 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1499 #-}
rule1499 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1500 #-}
rule1500 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_Tuple #-}
sem_Expression_Tuple :: T_Range -> T_Expressions -> T_Expression
sem_Expression_Tuple arg_range_ arg_expressions_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionsX44 = Control.Monad.Identity.runIdentity (attach_T_Expressions (arg_expressions_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expressions_vOut43 _expressionsIassumptions _expressionsIbetaUnique _expressionsIbetas _expressionsIcollectErrors _expressionsIcollectInstances _expressionsIcollectWarnings _expressionsIconstraintslist _expressionsIcounter _expressionsIdictionaryEnvironment _expressionsIinfoTrees _expressionsImatchIO _expressionsImatches _expressionsIpatternMatchWarnings _expressionsIself _expressionsIunboundNames _expressionsIuniqueChunk _expressionsIuniqueSecondRound) = inv_Expressions_s44 _expressionsX44 (T_Expressions_vIn43 _expressionsOallPatterns _expressionsOallTypeSchemes _expressionsOavailablePredicates _expressionsObetaUnique _expressionsOclassEnvironment _expressionsOcollectErrors _expressionsOcollectWarnings _expressionsOcounter _expressionsOcurrentChunk _expressionsOdictionaryEnvironment _expressionsOimportEnvironment _expressionsOmatchIO _expressionsOmonos _expressionsOnamesInScope _expressionsOorderedTypeSynonyms _expressionsOparentTree _expressionsOpatternMatchWarnings _expressionsOsubstitution _expressionsOtryPatterns _expressionsOtypeschemeMap _expressionsOuniqueChunk _expressionsOuniqueSecondRound)
_expressionsObetaUnique = rule1501 _lhsIbetaUnique
_constraints = rule1502 _expressionsIconstraintslist _newcon
_beta = rule1503 _lhsIbetaUnique
_newcon = rule1504 _beta _cinfo _expressionsIbetas
_cinfo = rule1505 _parentTree
_localInfo = rule1506 _beta _lhsImonos _self
_parentTree = rule1507 _expressionsIinfoTrees _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1508 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOconstraints :: ConstraintSet
_lhsOassumptions :: Assumptions
_lhsOuniqueSecondRound :: Int
(_expressionsOtryPatterns,_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1509 _constraints _expressionsIassumptions _expressionsImatches _expressionsIuniqueSecondRound _lhsIallPatterns _lhsItryPatterns _localInfo
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1510 _expressionsImatchIO _ioMatch
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1511 _expressionsIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1512 _expressionsIunboundNames
_self = rule1513 _expressionsIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule1514 _self
_lhsObeta :: Tp
_lhsObeta = rule1515 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1516 _expressionsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1517 _expressionsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1518 _expressionsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule1519 _expressionsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1520 _expressionsIdictionaryEnvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1521 _expressionsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1522 _expressionsIuniqueChunk
_expressionsOallPatterns = rule1523 _lhsIallPatterns
_expressionsOallTypeSchemes = rule1524 _lhsIallTypeSchemes
_expressionsOavailablePredicates = rule1525 _lhsIavailablePredicates
_expressionsOclassEnvironment = rule1526 _lhsIclassEnvironment
_expressionsOcollectErrors = rule1527 _lhsIcollectErrors
_expressionsOcollectWarnings = rule1528 _lhsIcollectWarnings
_expressionsOcounter = rule1529 _lhsIcounter
_expressionsOcurrentChunk = rule1530 _lhsIcurrentChunk
_expressionsOdictionaryEnvironment = rule1531 _lhsIdictionaryEnvironment
_expressionsOimportEnvironment = rule1532 _lhsIimportEnvironment
_expressionsOmatchIO = rule1533 _lhsImatchIO
_expressionsOmonos = rule1534 _lhsImonos
_expressionsOnamesInScope = rule1535 _lhsInamesInScope
_expressionsOorderedTypeSynonyms = rule1536 _lhsIorderedTypeSynonyms
_expressionsOparentTree = rule1537 _parentTree
_expressionsOpatternMatchWarnings = rule1538 _lhsIpatternMatchWarnings
_expressionsOsubstitution = rule1539 _lhsIsubstitution
_expressionsOtypeschemeMap = rule1540 _lhsItypeschemeMap
_expressionsOuniqueChunk = rule1541 _lhsIuniqueChunk
_expressionsOuniqueSecondRound = rule1542 _lhsIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1501 #-}
rule1501 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule1502 #-}
rule1502 = \ ((_expressionsIconstraintslist) :: ConstraintSets) _newcon ->
_newcon .>. Node _expressionsIconstraintslist
{-# INLINE rule1503 #-}
rule1503 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1504 #-}
rule1504 = \ _beta _cinfo ((_expressionsIbetas) :: Tps) ->
[ (tupleType _expressionsIbetas .==. _beta) _cinfo ]
{-# INLINE rule1505 #-}
rule1505 = \ _parentTree ->
resultConstraint "tuple" _parentTree
[ FolkloreConstraint ]
{-# INLINE rule1506 #-}
rule1506 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1507 #-}
rule1507 = \ ((_expressionsIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo (_expressionsIinfoTrees)
{-# INLINE rule1508 #-}
rule1508 = \ _parentTree ->
_parentTree
{-# INLINE rule1509 #-}
rule1509 = \ _constraints ((_expressionsIassumptions) :: Assumptions) ((_expressionsImatches) :: [Maybe MetaVariableTable]) ((_expressionsIuniqueSecondRound) :: Int) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ->
let infoTuple = metaVarInfo _constraints _expressionsIassumptions _localInfo
in match1 infoTuple _expressionsIuniqueSecondRound
match_Expression_Tuple
_lhsItryPatterns _lhsIallPatterns
[_expressionsImatches]
{-# INLINE rule1510 #-}
rule1510 = \ ((_expressionsImatchIO) :: IO ()) _ioMatch ->
_expressionsImatchIO >> _ioMatch
{-# INLINE rule1511 #-}
rule1511 = \ ((_expressionsIcollectInstances) :: [(Name, Instance)]) ->
_expressionsIcollectInstances
{-# INLINE rule1512 #-}
rule1512 = \ ((_expressionsIunboundNames) :: Names) ->
_expressionsIunboundNames
{-# INLINE rule1513 #-}
rule1513 = \ ((_expressionsIself) :: Expressions) ((_rangeIself) :: Range) ->
Expression_Tuple _rangeIself _expressionsIself
{-# INLINE rule1514 #-}
rule1514 = \ _self ->
_self
{-# INLINE rule1515 #-}
rule1515 = \ _beta ->
_beta
{-# INLINE rule1516 #-}
rule1516 = \ ((_expressionsIbetaUnique) :: Int) ->
_expressionsIbetaUnique
{-# INLINE rule1517 #-}
rule1517 = \ ((_expressionsIcollectErrors) :: TypeErrors) ->
_expressionsIcollectErrors
{-# INLINE rule1518 #-}
rule1518 = \ ((_expressionsIcollectWarnings) :: Warnings) ->
_expressionsIcollectWarnings
{-# INLINE rule1519 #-}
rule1519 = \ ((_expressionsIcounter) :: Int) ->
_expressionsIcounter
{-# INLINE rule1520 #-}
rule1520 = \ ((_expressionsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionsIdictionaryEnvironment
{-# INLINE rule1521 #-}
rule1521 = \ ((_expressionsIpatternMatchWarnings) :: [Warning]) ->
_expressionsIpatternMatchWarnings
{-# INLINE rule1522 #-}
rule1522 = \ ((_expressionsIuniqueChunk) :: Int) ->
_expressionsIuniqueChunk
{-# INLINE rule1523 #-}
rule1523 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1524 #-}
rule1524 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1525 #-}
rule1525 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1526 #-}
rule1526 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1527 #-}
rule1527 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1528 #-}
rule1528 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1529 #-}
rule1529 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1530 #-}
rule1530 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1531 #-}
rule1531 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1532 #-}
rule1532 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1533 #-}
rule1533 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1534 #-}
rule1534 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1535 #-}
rule1535 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1536 #-}
rule1536 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1537 #-}
rule1537 = \ _parentTree ->
_parentTree
{-# INLINE rule1538 #-}
rule1538 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1539 #-}
rule1539 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1540 #-}
rule1540 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1541 #-}
rule1541 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1542 #-}
rule1542 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_Comprehension #-}
sem_Expression_Comprehension :: T_Range -> T_Expression -> T_Qualifiers -> T_Expression
sem_Expression_Comprehension arg_range_ arg_expression_ arg_qualifiers_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
_qualifiersX131 = Control.Monad.Identity.runIdentity (attach_T_Qualifiers (arg_qualifiers_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
(T_Qualifiers_vOut130 _qualifiersIassumptions _qualifiersIbetaUnique _qualifiersIcollectErrors _qualifiersIcollectInstances _qualifiersIcollectWarnings _qualifiersIconstraints _qualifiersIcounter _qualifiersIdictionaryEnvironment _qualifiersIinfoTrees _qualifiersImatchIO _qualifiersImonos _qualifiersInamesInScope _qualifiersIpatternMatchWarnings _qualifiersIself _qualifiersIunboundNames _qualifiersIuniqueChunk _qualifiersIuniqueSecondRound) = inv_Qualifiers_s131 _qualifiersX131 (T_Qualifiers_vIn130 _qualifiersOallPatterns _qualifiersOallTypeSchemes _qualifiersOassumptions _qualifiersOavailablePredicates _qualifiersObetaUnique _qualifiersOclassEnvironment _qualifiersOcollectErrors _qualifiersOcollectWarnings _qualifiersOconstraints _qualifiersOcounter _qualifiersOcurrentChunk _qualifiersOdictionaryEnvironment _qualifiersOimportEnvironment _qualifiersOmatchIO _qualifiersOmonos _qualifiersOnamesInScope _qualifiersOorderedTypeSynonyms _qualifiersOparentTree _qualifiersOpatternMatchWarnings _qualifiersOsubstitution _qualifiersOtypeschemeMap _qualifiersOunboundNames _qualifiersOuniqueChunk _qualifiersOuniqueSecondRound)
_expressionObetaUnique = rule1543 _lhsIbetaUnique
_expressionOmonos = rule1544 _qualifiersImonos
_qualifiersOassumptions = rule1545 _expressionIassumptions
_qualifiersOconstraints = rule1546 _expressionIconstraints
_qualifiersOmonos = rule1547 _lhsImonos
_assumptions = rule1548 _qualifiersIassumptions
_constraints = rule1549 _newcon _qualifiersIconstraints
_beta = rule1550 _lhsIbetaUnique
_newcon = rule1551 _beta _cinfo _expressionIbeta
_cinfo = rule1552 _parentTree
_localInfo = rule1553 _beta _lhsImonos _self
_parentTree = rule1554 _lhsIparentTree _localInfo _qualifiersIinfoTrees
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1555 _parentTree
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1556 _qualifiersIunboundNames
_expressionOnamesInScope = rule1557 _qualifiersInamesInScope
_qualifiersOnamesInScope = rule1558 _lhsInamesInScope
_qualifiersOunboundNames = rule1559 _expressionIunboundNames
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOmatches = rule1560 _assumptions _constraints _lhsItryPatterns _localInfo
_expressionOtryPatterns = rule1561 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1562 _expressionIcollectInstances _qualifiersIcollectInstances
_self = rule1563 _expressionIself _qualifiersIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule1564 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule1565 _assumptions
_lhsObeta :: Tp
_lhsObeta = rule1566 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1567 _qualifiersIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1568 _qualifiersIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1569 _qualifiersIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule1570 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule1571 _qualifiersIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1572 _qualifiersIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1573 _qualifiersImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1574 _qualifiersIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1575 _qualifiersIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule1576 _qualifiersIuniqueSecondRound
_expressionOallPatterns = rule1577 _lhsIallPatterns
_expressionOallTypeSchemes = rule1578 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule1579 _lhsIavailablePredicates
_expressionOclassEnvironment = rule1580 _lhsIclassEnvironment
_expressionOcollectErrors = rule1581 _lhsIcollectErrors
_expressionOcollectWarnings = rule1582 _lhsIcollectWarnings
_expressionOcounter = rule1583 _lhsIcounter
_expressionOcurrentChunk = rule1584 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule1585 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule1586 _lhsIimportEnvironment
_expressionOmatchIO = rule1587 _lhsImatchIO
_expressionOorderedTypeSynonyms = rule1588 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule1589 _parentTree
_expressionOpatternMatchWarnings = rule1590 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule1591 _lhsIsubstitution
_expressionOtypeschemeMap = rule1592 _lhsItypeschemeMap
_expressionOuniqueChunk = rule1593 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule1594 _lhsIuniqueSecondRound
_qualifiersOallPatterns = rule1595 _lhsIallPatterns
_qualifiersOallTypeSchemes = rule1596 _lhsIallTypeSchemes
_qualifiersOavailablePredicates = rule1597 _lhsIavailablePredicates
_qualifiersObetaUnique = rule1598 _expressionIbetaUnique
_qualifiersOclassEnvironment = rule1599 _lhsIclassEnvironment
_qualifiersOcollectErrors = rule1600 _expressionIcollectErrors
_qualifiersOcollectWarnings = rule1601 _expressionIcollectWarnings
_qualifiersOcounter = rule1602 _expressionIcounter
_qualifiersOcurrentChunk = rule1603 _lhsIcurrentChunk
_qualifiersOdictionaryEnvironment = rule1604 _expressionIdictionaryEnvironment
_qualifiersOimportEnvironment = rule1605 _lhsIimportEnvironment
_qualifiersOmatchIO = rule1606 _expressionImatchIO
_qualifiersOorderedTypeSynonyms = rule1607 _lhsIorderedTypeSynonyms
_qualifiersOparentTree = rule1608 _parentTree
_qualifiersOpatternMatchWarnings = rule1609 _expressionIpatternMatchWarnings
_qualifiersOsubstitution = rule1610 _lhsIsubstitution
_qualifiersOtypeschemeMap = rule1611 _lhsItypeschemeMap
_qualifiersOuniqueChunk = rule1612 _expressionIuniqueChunk
_qualifiersOuniqueSecondRound = rule1613 _expressionIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1543 #-}
rule1543 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule1544 #-}
rule1544 = \ ((_qualifiersImonos) :: Monos) ->
_qualifiersImonos
{-# INLINE rule1545 #-}
rule1545 = \ ((_expressionIassumptions) :: Assumptions) ->
_expressionIassumptions
{-# INLINE rule1546 #-}
rule1546 = \ ((_expressionIconstraints) :: ConstraintSet) ->
_expressionIconstraints
{-# INLINE rule1547 #-}
rule1547 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1548 #-}
rule1548 = \ ((_qualifiersIassumptions) :: Assumptions) ->
_qualifiersIassumptions
{-# INLINE rule1549 #-}
rule1549 = \ _newcon ((_qualifiersIconstraints) :: ConstraintSet) ->
_newcon .>. Node [ _qualifiersIconstraints ]
{-# INLINE rule1550 #-}
rule1550 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1551 #-}
rule1551 = \ _beta _cinfo ((_expressionIbeta) :: Tp) ->
[ (listType _expressionIbeta .==. _beta) _cinfo ]
{-# INLINE rule1552 #-}
rule1552 = \ _parentTree ->
resultConstraint "list comprehension" _parentTree
[ FolkloreConstraint ]
{-# INLINE rule1553 #-}
rule1553 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1554 #-}
rule1554 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_qualifiersIinfoTrees) :: InfoTrees) ->
node _lhsIparentTree _localInfo _qualifiersIinfoTrees
{-# INLINE rule1555 #-}
rule1555 = \ _parentTree ->
_parentTree
{-# INLINE rule1556 #-}
rule1556 = \ ((_qualifiersIunboundNames) :: Names) ->
_qualifiersIunboundNames
{-# INLINE rule1557 #-}
rule1557 = \ ((_qualifiersInamesInScope) :: Names) ->
_qualifiersInamesInScope
{-# INLINE rule1558 #-}
rule1558 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1559 #-}
rule1559 = \ ((_expressionIunboundNames) :: Names) ->
_expressionIunboundNames
{-# INLINE rule1560 #-}
rule1560 = \ _assumptions _constraints ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in matchOnlyVariable infoTuple _lhsItryPatterns
{-# INLINE rule1561 #-}
rule1561 = \ (_ :: ()) ->
[]
{-# INLINE rule1562 #-}
rule1562 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ((_qualifiersIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances ++ _qualifiersIcollectInstances
{-# INLINE rule1563 #-}
rule1563 = \ ((_expressionIself) :: Expression) ((_qualifiersIself) :: Qualifiers) ((_rangeIself) :: Range) ->
Expression_Comprehension _rangeIself _expressionIself _qualifiersIself
{-# INLINE rule1564 #-}
rule1564 = \ _self ->
_self
{-# INLINE rule1565 #-}
rule1565 = \ _assumptions ->
_assumptions
{-# INLINE rule1566 #-}
rule1566 = \ _beta ->
_beta
{-# INLINE rule1567 #-}
rule1567 = \ ((_qualifiersIbetaUnique) :: Int) ->
_qualifiersIbetaUnique
{-# INLINE rule1568 #-}
rule1568 = \ ((_qualifiersIcollectErrors) :: TypeErrors) ->
_qualifiersIcollectErrors
{-# INLINE rule1569 #-}
rule1569 = \ ((_qualifiersIcollectWarnings) :: Warnings) ->
_qualifiersIcollectWarnings
{-# INLINE rule1570 #-}
rule1570 = \ _constraints ->
_constraints
{-# INLINE rule1571 #-}
rule1571 = \ ((_qualifiersIcounter) :: Int) ->
_qualifiersIcounter
{-# INLINE rule1572 #-}
rule1572 = \ ((_qualifiersIdictionaryEnvironment) :: DictionaryEnvironment) ->
_qualifiersIdictionaryEnvironment
{-# INLINE rule1573 #-}
rule1573 = \ ((_qualifiersImatchIO) :: IO ()) ->
_qualifiersImatchIO
{-# INLINE rule1574 #-}
rule1574 = \ ((_qualifiersIpatternMatchWarnings) :: [Warning]) ->
_qualifiersIpatternMatchWarnings
{-# INLINE rule1575 #-}
rule1575 = \ ((_qualifiersIuniqueChunk) :: Int) ->
_qualifiersIuniqueChunk
{-# INLINE rule1576 #-}
rule1576 = \ ((_qualifiersIuniqueSecondRound) :: Int) ->
_qualifiersIuniqueSecondRound
{-# INLINE rule1577 #-}
rule1577 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1578 #-}
rule1578 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1579 #-}
rule1579 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1580 #-}
rule1580 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1581 #-}
rule1581 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1582 #-}
rule1582 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1583 #-}
rule1583 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1584 #-}
rule1584 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1585 #-}
rule1585 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1586 #-}
rule1586 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1587 #-}
rule1587 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1588 #-}
rule1588 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1589 #-}
rule1589 = \ _parentTree ->
_parentTree
{-# INLINE rule1590 #-}
rule1590 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1591 #-}
rule1591 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1592 #-}
rule1592 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1593 #-}
rule1593 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1594 #-}
rule1594 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule1595 #-}
rule1595 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1596 #-}
rule1596 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1597 #-}
rule1597 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1598 #-}
rule1598 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule1599 #-}
rule1599 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1600 #-}
rule1600 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule1601 #-}
rule1601 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule1602 #-}
rule1602 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule1603 #-}
rule1603 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1604 #-}
rule1604 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule1605 #-}
rule1605 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1606 #-}
rule1606 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule1607 #-}
rule1607 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1608 #-}
rule1608 = \ _parentTree ->
_parentTree
{-# INLINE rule1609 #-}
rule1609 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule1610 #-}
rule1610 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1611 #-}
rule1611 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1612 #-}
rule1612 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule1613 #-}
rule1613 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# NOINLINE sem_Expression_Typed #-}
sem_Expression_Typed :: T_Range -> T_Expression -> T_Type -> T_Expression
sem_Expression_Typed arg_range_ arg_expression_ arg_type_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
_typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
(T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
_expressionObetaUnique = rule1614 _lhsIbetaUnique
_assumptions = rule1615 _expressionIassumptions
_constraints = rule1616 _conExpr _conResult _expressionIconstraints
_beta = rule1617 _lhsIbetaUnique
_typeScheme = rule1618 _typeIself
_conResult = rule1619 _beta _cinfoResult _typeScheme
_conExpr = rule1620 _cinfoExpr _expressionIbeta _lhsImonos _typeScheme
_cinfoExpr = rule1621 _parentTree _typeIself
_cinfoResult = rule1622 _parentTree
_localInfo = rule1623 _beta _lhsImonos _self
_parentTree = rule1624 _expressionIinfoTree _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1625 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOmatches = rule1626 _assumptions _constraints _lhsItryPatterns _localInfo
_expressionOtryPatterns = rule1627 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1628 _expressionIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1629 _expressionIunboundNames
_self = rule1630 _expressionIself _rangeIself _typeIself
_lhsOself :: Expression
_lhsOself = rule1631 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule1632 _assumptions
_lhsObeta :: Tp
_lhsObeta = rule1633 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1634 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1635 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1636 _expressionIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule1637 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule1638 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1639 _expressionIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1640 _expressionImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1641 _expressionIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1642 _expressionIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule1643 _expressionIuniqueSecondRound
_expressionOallPatterns = rule1644 _lhsIallPatterns
_expressionOallTypeSchemes = rule1645 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule1646 _lhsIavailablePredicates
_expressionOclassEnvironment = rule1647 _lhsIclassEnvironment
_expressionOcollectErrors = rule1648 _lhsIcollectErrors
_expressionOcollectWarnings = rule1649 _lhsIcollectWarnings
_expressionOcounter = rule1650 _lhsIcounter
_expressionOcurrentChunk = rule1651 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule1652 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule1653 _lhsIimportEnvironment
_expressionOmatchIO = rule1654 _lhsImatchIO
_expressionOmonos = rule1655 _lhsImonos
_expressionOnamesInScope = rule1656 _lhsInamesInScope
_expressionOorderedTypeSynonyms = rule1657 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule1658 _parentTree
_expressionOpatternMatchWarnings = rule1659 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule1660 _lhsIsubstitution
_expressionOtypeschemeMap = rule1661 _lhsItypeschemeMap
_expressionOuniqueChunk = rule1662 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule1663 _lhsIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1614 #-}
rule1614 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule1615 #-}
rule1615 = \ ((_expressionIassumptions) :: Assumptions) ->
_expressionIassumptions
{-# INLINE rule1616 #-}
rule1616 = \ _conExpr _conResult ((_expressionIconstraints) :: ConstraintSet) ->
_conResult .>.
Node [ _conExpr .<. _expressionIconstraints ]
{-# INLINE rule1617 #-}
rule1617 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1618 #-}
rule1618 = \ ((_typeIself) :: Type) ->
makeTpSchemeFromType _typeIself
{-# INLINE rule1619 #-}
rule1619 = \ _beta _cinfoResult _typeScheme ->
[ (_beta .::. _typeScheme) _cinfoResult ]
{-# INLINE rule1620 #-}
rule1620 = \ _cinfoExpr ((_expressionIbeta) :: Tp) ((_lhsImonos) :: Monos) _typeScheme ->
[ (_expressionIbeta !::! _typeScheme) _lhsImonos _cinfoExpr ]
{-# INLINE rule1621 #-}
rule1621 = \ _parentTree ((_typeIself) :: Type) ->
childConstraint 0 "type annotation" _parentTree
[ TypeSignatureLocation (getTypeRange _typeIself) ]
{-# INLINE rule1622 #-}
rule1622 = \ _parentTree ->
resultConstraint "type annotation" _parentTree
[ FolkloreConstraint ]
{-# INLINE rule1623 #-}
rule1623 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1624 #-}
rule1624 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo [_expressionIinfoTree]
{-# INLINE rule1625 #-}
rule1625 = \ _parentTree ->
_parentTree
{-# INLINE rule1626 #-}
rule1626 = \ _assumptions _constraints ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in matchOnlyVariable infoTuple _lhsItryPatterns
{-# INLINE rule1627 #-}
rule1627 = \ (_ :: ()) ->
[]
{-# INLINE rule1628 #-}
rule1628 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances
{-# INLINE rule1629 #-}
rule1629 = \ ((_expressionIunboundNames) :: Names) ->
_expressionIunboundNames
{-# INLINE rule1630 #-}
rule1630 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ((_typeIself) :: Type) ->
Expression_Typed _rangeIself _expressionIself _typeIself
{-# INLINE rule1631 #-}
rule1631 = \ _self ->
_self
{-# INLINE rule1632 #-}
rule1632 = \ _assumptions ->
_assumptions
{-# INLINE rule1633 #-}
rule1633 = \ _beta ->
_beta
{-# INLINE rule1634 #-}
rule1634 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule1635 #-}
rule1635 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule1636 #-}
rule1636 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule1637 #-}
rule1637 = \ _constraints ->
_constraints
{-# INLINE rule1638 #-}
rule1638 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule1639 #-}
rule1639 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule1640 #-}
rule1640 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule1641 #-}
rule1641 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule1642 #-}
rule1642 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule1643 #-}
rule1643 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule1644 #-}
rule1644 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1645 #-}
rule1645 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1646 #-}
rule1646 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1647 #-}
rule1647 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1648 #-}
rule1648 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1649 #-}
rule1649 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1650 #-}
rule1650 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1651 #-}
rule1651 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1652 #-}
rule1652 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1653 #-}
rule1653 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1654 #-}
rule1654 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1655 #-}
rule1655 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1656 #-}
rule1656 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1657 #-}
rule1657 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1658 #-}
rule1658 = \ _parentTree ->
_parentTree
{-# INLINE rule1659 #-}
rule1659 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1660 #-}
rule1660 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1661 #-}
rule1661 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1662 #-}
rule1662 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1663 #-}
rule1663 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_RecordConstruction #-}
sem_Expression_RecordConstruction :: T_Range -> T_Name -> T_RecordExpressionBindings -> T_Expression
sem_Expression_RecordConstruction arg_range_ arg_name_ arg_recordExpressionBindings_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_recordExpressionBindingsX140 = Control.Monad.Identity.runIdentity (attach_T_RecordExpressionBindings (arg_recordExpressionBindings_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_RecordExpressionBindings_vOut139 _recordExpressionBindingsIcollectErrors _recordExpressionBindingsIcollectInstances _recordExpressionBindingsIcollectWarnings _recordExpressionBindingsIcounter _recordExpressionBindingsIdictionaryEnvironment _recordExpressionBindingsIpatternMatchWarnings _recordExpressionBindingsIself _recordExpressionBindingsIunboundNames _recordExpressionBindingsIuniqueChunk) = inv_RecordExpressionBindings_s140 _recordExpressionBindingsX140 (T_RecordExpressionBindings_vIn139 _recordExpressionBindingsOallTypeSchemes _recordExpressionBindingsOavailablePredicates _recordExpressionBindingsOclassEnvironment _recordExpressionBindingsOcollectErrors _recordExpressionBindingsOcollectWarnings _recordExpressionBindingsOcounter _recordExpressionBindingsOcurrentChunk _recordExpressionBindingsOdictionaryEnvironment _recordExpressionBindingsOimportEnvironment _recordExpressionBindingsOnamesInScope _recordExpressionBindingsOorderedTypeSynonyms _recordExpressionBindingsOpatternMatchWarnings _recordExpressionBindingsOsubstitution _recordExpressionBindingsOtypeschemeMap _recordExpressionBindingsOuniqueChunk)
_infoTree = rule1664 ()
(_assumptions,_constraints,_beta) = rule1665 ()
_matches = rule1666 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1667 _recordExpressionBindingsIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1668 _recordExpressionBindingsIunboundNames
_self = rule1669 _nameIself _rangeIself _recordExpressionBindingsIself
_lhsOself :: Expression
_lhsOself = rule1670 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule1671 _assumptions
_lhsObeta :: Tp
_lhsObeta = rule1672 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1673 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1674 _recordExpressionBindingsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1675 _recordExpressionBindingsIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule1676 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule1677 _recordExpressionBindingsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1678 _recordExpressionBindingsIdictionaryEnvironment
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1679 _infoTree
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1680 _lhsImatchIO
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOmatches = rule1681 _matches
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1682 _recordExpressionBindingsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1683 _recordExpressionBindingsIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule1684 _lhsIuniqueSecondRound
_recordExpressionBindingsOallTypeSchemes = rule1685 _lhsIallTypeSchemes
_recordExpressionBindingsOavailablePredicates = rule1686 _lhsIavailablePredicates
_recordExpressionBindingsOclassEnvironment = rule1687 _lhsIclassEnvironment
_recordExpressionBindingsOcollectErrors = rule1688 _lhsIcollectErrors
_recordExpressionBindingsOcollectWarnings = rule1689 _lhsIcollectWarnings
_recordExpressionBindingsOcounter = rule1690 _lhsIcounter
_recordExpressionBindingsOcurrentChunk = rule1691 _lhsIcurrentChunk
_recordExpressionBindingsOdictionaryEnvironment = rule1692 _lhsIdictionaryEnvironment
_recordExpressionBindingsOimportEnvironment = rule1693 _lhsIimportEnvironment
_recordExpressionBindingsOnamesInScope = rule1694 _lhsInamesInScope
_recordExpressionBindingsOorderedTypeSynonyms = rule1695 _lhsIorderedTypeSynonyms
_recordExpressionBindingsOpatternMatchWarnings = rule1696 _lhsIpatternMatchWarnings
_recordExpressionBindingsOsubstitution = rule1697 _lhsIsubstitution
_recordExpressionBindingsOtypeschemeMap = rule1698 _lhsItypeschemeMap
_recordExpressionBindingsOuniqueChunk = rule1699 _lhsIuniqueChunk
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1664 #-}
rule1664 = \ (_ :: ()) ->
globalInfoError
{-# INLINE rule1665 #-}
rule1665 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "Expression.RecordConstruction"
{-# INLINE rule1666 #-}
rule1666 = \ (_ :: ()) ->
internalError "TS_PatternMatching.ag" "n/a" "RecordConstruction is not supported"
{-# INLINE rule1667 #-}
rule1667 = \ ((_recordExpressionBindingsIcollectInstances) :: [(Name, Instance)]) ->
_recordExpressionBindingsIcollectInstances
{-# INLINE rule1668 #-}
rule1668 = \ ((_recordExpressionBindingsIunboundNames) :: Names) ->
_recordExpressionBindingsIunboundNames
{-# INLINE rule1669 #-}
rule1669 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ((_recordExpressionBindingsIself) :: RecordExpressionBindings) ->
Expression_RecordConstruction _rangeIself _nameIself _recordExpressionBindingsIself
{-# INLINE rule1670 #-}
rule1670 = \ _self ->
_self
{-# INLINE rule1671 #-}
rule1671 = \ _assumptions ->
_assumptions
{-# INLINE rule1672 #-}
rule1672 = \ _beta ->
_beta
{-# INLINE rule1673 #-}
rule1673 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule1674 #-}
rule1674 = \ ((_recordExpressionBindingsIcollectErrors) :: TypeErrors) ->
_recordExpressionBindingsIcollectErrors
{-# INLINE rule1675 #-}
rule1675 = \ ((_recordExpressionBindingsIcollectWarnings) :: Warnings) ->
_recordExpressionBindingsIcollectWarnings
{-# INLINE rule1676 #-}
rule1676 = \ _constraints ->
_constraints
{-# INLINE rule1677 #-}
rule1677 = \ ((_recordExpressionBindingsIcounter) :: Int) ->
_recordExpressionBindingsIcounter
{-# INLINE rule1678 #-}
rule1678 = \ ((_recordExpressionBindingsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_recordExpressionBindingsIdictionaryEnvironment
{-# INLINE rule1679 #-}
rule1679 = \ _infoTree ->
_infoTree
{-# INLINE rule1680 #-}
rule1680 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1681 #-}
rule1681 = \ _matches ->
_matches
{-# INLINE rule1682 #-}
rule1682 = \ ((_recordExpressionBindingsIpatternMatchWarnings) :: [Warning]) ->
_recordExpressionBindingsIpatternMatchWarnings
{-# INLINE rule1683 #-}
rule1683 = \ ((_recordExpressionBindingsIuniqueChunk) :: Int) ->
_recordExpressionBindingsIuniqueChunk
{-# INLINE rule1684 #-}
rule1684 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule1685 #-}
rule1685 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1686 #-}
rule1686 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1687 #-}
rule1687 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1688 #-}
rule1688 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1689 #-}
rule1689 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1690 #-}
rule1690 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1691 #-}
rule1691 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1692 #-}
rule1692 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1693 #-}
rule1693 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1694 #-}
rule1694 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1695 #-}
rule1695 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1696 #-}
rule1696 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1697 #-}
rule1697 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1698 #-}
rule1698 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1699 #-}
rule1699 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Expression_RecordUpdate #-}
sem_Expression_RecordUpdate :: T_Range -> T_Expression -> T_RecordExpressionBindings -> T_Expression
sem_Expression_RecordUpdate arg_range_ arg_expression_ arg_recordExpressionBindings_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
_recordExpressionBindingsX140 = Control.Monad.Identity.runIdentity (attach_T_RecordExpressionBindings (arg_recordExpressionBindings_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
(T_RecordExpressionBindings_vOut139 _recordExpressionBindingsIcollectErrors _recordExpressionBindingsIcollectInstances _recordExpressionBindingsIcollectWarnings _recordExpressionBindingsIcounter _recordExpressionBindingsIdictionaryEnvironment _recordExpressionBindingsIpatternMatchWarnings _recordExpressionBindingsIself _recordExpressionBindingsIunboundNames _recordExpressionBindingsIuniqueChunk) = inv_RecordExpressionBindings_s140 _recordExpressionBindingsX140 (T_RecordExpressionBindings_vIn139 _recordExpressionBindingsOallTypeSchemes _recordExpressionBindingsOavailablePredicates _recordExpressionBindingsOclassEnvironment _recordExpressionBindingsOcollectErrors _recordExpressionBindingsOcollectWarnings _recordExpressionBindingsOcounter _recordExpressionBindingsOcurrentChunk _recordExpressionBindingsOdictionaryEnvironment _recordExpressionBindingsOimportEnvironment _recordExpressionBindingsOnamesInScope _recordExpressionBindingsOorderedTypeSynonyms _recordExpressionBindingsOpatternMatchWarnings _recordExpressionBindingsOsubstitution _recordExpressionBindingsOtypeschemeMap _recordExpressionBindingsOuniqueChunk)
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1700 _expressionIcollectInstances _recordExpressionBindingsIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1701 _expressionIunboundNames _recordExpressionBindingsIunboundNames
_self = rule1702 _expressionIself _rangeIself _recordExpressionBindingsIself
_lhsOself :: Expression
_lhsOself = rule1703 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule1704 _expressionIassumptions
_lhsObeta :: Tp
_lhsObeta = rule1705 _expressionIbeta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1706 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1707 _recordExpressionBindingsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1708 _recordExpressionBindingsIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule1709 _expressionIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule1710 _recordExpressionBindingsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1711 _recordExpressionBindingsIdictionaryEnvironment
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1712 _expressionIinfoTree
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1713 _expressionImatchIO
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOmatches = rule1714 _expressionImatches
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1715 _recordExpressionBindingsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1716 _recordExpressionBindingsIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule1717 _expressionIuniqueSecondRound
_expressionOallPatterns = rule1718 _lhsIallPatterns
_expressionOallTypeSchemes = rule1719 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule1720 _lhsIavailablePredicates
_expressionObetaUnique = rule1721 _lhsIbetaUnique
_expressionOclassEnvironment = rule1722 _lhsIclassEnvironment
_expressionOcollectErrors = rule1723 _lhsIcollectErrors
_expressionOcollectWarnings = rule1724 _lhsIcollectWarnings
_expressionOcounter = rule1725 _lhsIcounter
_expressionOcurrentChunk = rule1726 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule1727 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule1728 _lhsIimportEnvironment
_expressionOmatchIO = rule1729 _lhsImatchIO
_expressionOmonos = rule1730 _lhsImonos
_expressionOnamesInScope = rule1731 _lhsInamesInScope
_expressionOorderedTypeSynonyms = rule1732 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule1733 _lhsIparentTree
_expressionOpatternMatchWarnings = rule1734 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule1735 _lhsIsubstitution
_expressionOtryPatterns = rule1736 _lhsItryPatterns
_expressionOtypeschemeMap = rule1737 _lhsItypeschemeMap
_expressionOuniqueChunk = rule1738 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule1739 _lhsIuniqueSecondRound
_recordExpressionBindingsOallTypeSchemes = rule1740 _lhsIallTypeSchemes
_recordExpressionBindingsOavailablePredicates = rule1741 _lhsIavailablePredicates
_recordExpressionBindingsOclassEnvironment = rule1742 _lhsIclassEnvironment
_recordExpressionBindingsOcollectErrors = rule1743 _expressionIcollectErrors
_recordExpressionBindingsOcollectWarnings = rule1744 _expressionIcollectWarnings
_recordExpressionBindingsOcounter = rule1745 _expressionIcounter
_recordExpressionBindingsOcurrentChunk = rule1746 _lhsIcurrentChunk
_recordExpressionBindingsOdictionaryEnvironment = rule1747 _expressionIdictionaryEnvironment
_recordExpressionBindingsOimportEnvironment = rule1748 _lhsIimportEnvironment
_recordExpressionBindingsOnamesInScope = rule1749 _lhsInamesInScope
_recordExpressionBindingsOorderedTypeSynonyms = rule1750 _lhsIorderedTypeSynonyms
_recordExpressionBindingsOpatternMatchWarnings = rule1751 _expressionIpatternMatchWarnings
_recordExpressionBindingsOsubstitution = rule1752 _lhsIsubstitution
_recordExpressionBindingsOtypeschemeMap = rule1753 _lhsItypeschemeMap
_recordExpressionBindingsOuniqueChunk = rule1754 _expressionIuniqueChunk
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1700 #-}
rule1700 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ((_recordExpressionBindingsIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances ++ _recordExpressionBindingsIcollectInstances
{-# INLINE rule1701 #-}
rule1701 = \ ((_expressionIunboundNames) :: Names) ((_recordExpressionBindingsIunboundNames) :: Names) ->
_expressionIunboundNames ++ _recordExpressionBindingsIunboundNames
{-# INLINE rule1702 #-}
rule1702 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ((_recordExpressionBindingsIself) :: RecordExpressionBindings) ->
Expression_RecordUpdate _rangeIself _expressionIself _recordExpressionBindingsIself
{-# INLINE rule1703 #-}
rule1703 = \ _self ->
_self
{-# INLINE rule1704 #-}
rule1704 = \ ((_expressionIassumptions) :: Assumptions) ->
_expressionIassumptions
{-# INLINE rule1705 #-}
rule1705 = \ ((_expressionIbeta) :: Tp) ->
_expressionIbeta
{-# INLINE rule1706 #-}
rule1706 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule1707 #-}
rule1707 = \ ((_recordExpressionBindingsIcollectErrors) :: TypeErrors) ->
_recordExpressionBindingsIcollectErrors
{-# INLINE rule1708 #-}
rule1708 = \ ((_recordExpressionBindingsIcollectWarnings) :: Warnings) ->
_recordExpressionBindingsIcollectWarnings
{-# INLINE rule1709 #-}
rule1709 = \ ((_expressionIconstraints) :: ConstraintSet) ->
_expressionIconstraints
{-# INLINE rule1710 #-}
rule1710 = \ ((_recordExpressionBindingsIcounter) :: Int) ->
_recordExpressionBindingsIcounter
{-# INLINE rule1711 #-}
rule1711 = \ ((_recordExpressionBindingsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_recordExpressionBindingsIdictionaryEnvironment
{-# INLINE rule1712 #-}
rule1712 = \ ((_expressionIinfoTree) :: InfoTree) ->
_expressionIinfoTree
{-# INLINE rule1713 #-}
rule1713 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule1714 #-}
rule1714 = \ ((_expressionImatches) :: [Maybe MetaVariableTable]) ->
_expressionImatches
{-# INLINE rule1715 #-}
rule1715 = \ ((_recordExpressionBindingsIpatternMatchWarnings) :: [Warning]) ->
_recordExpressionBindingsIpatternMatchWarnings
{-# INLINE rule1716 #-}
rule1716 = \ ((_recordExpressionBindingsIuniqueChunk) :: Int) ->
_recordExpressionBindingsIuniqueChunk
{-# INLINE rule1717 #-}
rule1717 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule1718 #-}
rule1718 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1719 #-}
rule1719 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1720 #-}
rule1720 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1721 #-}
rule1721 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule1722 #-}
rule1722 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1723 #-}
rule1723 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1724 #-}
rule1724 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1725 #-}
rule1725 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1726 #-}
rule1726 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1727 #-}
rule1727 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1728 #-}
rule1728 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1729 #-}
rule1729 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1730 #-}
rule1730 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1731 #-}
rule1731 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1732 #-}
rule1732 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1733 #-}
rule1733 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule1734 #-}
rule1734 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1735 #-}
rule1735 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1736 #-}
rule1736 = \ ((_lhsItryPatterns) :: [(Expression , [String])]) ->
_lhsItryPatterns
{-# INLINE rule1737 #-}
rule1737 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1738 #-}
rule1738 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1739 #-}
rule1739 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule1740 #-}
rule1740 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1741 #-}
rule1741 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1742 #-}
rule1742 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1743 #-}
rule1743 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule1744 #-}
rule1744 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule1745 #-}
rule1745 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule1746 #-}
rule1746 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1747 #-}
rule1747 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule1748 #-}
rule1748 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1749 #-}
rule1749 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1750 #-}
rule1750 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1751 #-}
rule1751 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule1752 #-}
rule1752 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1753 #-}
rule1753 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1754 #-}
rule1754 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# NOINLINE sem_Expression_Enum #-}
sem_Expression_Enum :: T_Range -> T_Expression -> T_MaybeExpression -> T_MaybeExpression -> T_Expression
sem_Expression_Enum arg_range_ arg_from_ arg_then_ arg_to_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_fromX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_from_))
_thenX95 = Control.Monad.Identity.runIdentity (attach_T_MaybeExpression (arg_then_))
_toX95 = Control.Monad.Identity.runIdentity (attach_T_MaybeExpression (arg_to_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _fromIassumptions _fromIbeta _fromIbetaUnique _fromIcollectErrors _fromIcollectInstances _fromIcollectWarnings _fromIconstraints _fromIcounter _fromIdictionaryEnvironment _fromIinfoTree _fromImatchIO _fromImatches _fromIpatternMatchWarnings _fromIself _fromIunboundNames _fromIuniqueChunk _fromIuniqueSecondRound) = inv_Expression_s41 _fromX41 (T_Expression_vIn40 _fromOallPatterns _fromOallTypeSchemes _fromOavailablePredicates _fromObetaUnique _fromOclassEnvironment _fromOcollectErrors _fromOcollectWarnings _fromOcounter _fromOcurrentChunk _fromOdictionaryEnvironment _fromOimportEnvironment _fromOmatchIO _fromOmonos _fromOnamesInScope _fromOorderedTypeSynonyms _fromOparentTree _fromOpatternMatchWarnings _fromOsubstitution _fromOtryPatterns _fromOtypeschemeMap _fromOuniqueChunk _fromOuniqueSecondRound)
(T_MaybeExpression_vOut94 _thenIassumptions _thenIbeta _thenIbetaUnique _thenIcollectErrors _thenIcollectInstances _thenIcollectWarnings _thenIconstraints _thenIcounter _thenIdictionaryEnvironment _thenIinfoTrees _thenImatchIO _thenImatches _thenIpatternMatchWarnings _thenIsection _thenIself _thenIunboundNames _thenIuniqueChunk _thenIuniqueSecondRound) = inv_MaybeExpression_s95 _thenX95 (T_MaybeExpression_vIn94 _thenOallPatterns _thenOallTypeSchemes _thenOavailablePredicates _thenObetaUnique _thenOclassEnvironment _thenOcollectErrors _thenOcollectWarnings _thenOcounter _thenOcurrentChunk _thenOdictionaryEnvironment _thenOimportEnvironment _thenOmatchIO _thenOmonos _thenOnamesInScope _thenOorderedTypeSynonyms _thenOparentTree _thenOpatternMatchWarnings _thenOsubstitution _thenOtryPatterns _thenOtypeschemeMap _thenOuniqueChunk _thenOuniqueSecondRound)
(T_MaybeExpression_vOut94 _toIassumptions _toIbeta _toIbetaUnique _toIcollectErrors _toIcollectInstances _toIcollectWarnings _toIconstraints _toIcounter _toIdictionaryEnvironment _toIinfoTrees _toImatchIO _toImatches _toIpatternMatchWarnings _toIsection _toIself _toIunboundNames _toIuniqueChunk _toIuniqueSecondRound) = inv_MaybeExpression_s95 _toX95 (T_MaybeExpression_vIn94 _toOallPatterns _toOallTypeSchemes _toOavailablePredicates _toObetaUnique _toOclassEnvironment _toOcollectErrors _toOcollectWarnings _toOcounter _toOcurrentChunk _toOdictionaryEnvironment _toOimportEnvironment _toOmatchIO _toOmonos _toOnamesInScope _toOorderedTypeSynonyms _toOparentTree _toOpatternMatchWarnings _toOsubstitution _toOtryPatterns _toOtypeschemeMap _toOuniqueChunk _toOuniqueSecondRound)
_fromObetaUnique = rule1755 _lhsIbetaUnique _overloaded
_assumptions = rule1756 _fromIassumptions _thenIassumptions _toIassumptions
_constraints = rule1757 _conFrom _conList _conPredicate _conThen _conTo _fromIconstraints _thenIconstraints _toIconstraints
_beta = rule1758 _lhsIbetaUnique
_overloaded = rule1759 _lhsIimportEnvironment
_elementType = rule1760 _lhsIbetaUnique _overloaded
_conPredicate = rule1761 _cinfoPred _elementType _overloaded
_conList = rule1762 _beta _cinfoResult _elementType
_conFrom = rule1763 _cinfoFrom _elementType _fromIbeta
_conThen = rule1764 _cinfoThen _elementType _thenIbeta
_conTo = rule1765 _cinfoTo _elementType _toIbeta
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1766 _newDEnv
_localName = rule1767 _rangeIself _thenIsection _toIsection
_requiredDictionaries = rule1768 _elementType _lhsIsubstitution _overloaded
_newDEnv = rule1769 _lhsIavailablePredicates _lhsIclassEnvironment _lhsIsubstitution _localName _requiredDictionaries _toIdictionaryEnvironment
_cinfoFrom = rule1770 _parentTree
_cinfoThen = rule1771 _parentTree
_toChildNr = rule1772 _thenIinfoTrees
_cinfoTo = rule1773 _parentTree _toChildNr
_cinfoResult = rule1774 _parentTree
_cinfoPred = rule1775 _elementType _parentTree
_localInfo = rule1776 _beta _lhsImonos _self
_parentTree = rule1777 _fromIinfoTree _lhsIparentTree _localInfo _thenIinfoTrees _toIinfoTrees
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1778 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOconstraints :: ConstraintSet
_lhsOassumptions :: Assumptions
_lhsOuniqueSecondRound :: Int
((_fromOtryPatterns,_thenOtryPatterns,_toOtryPatterns),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1779 _assumptions _constraints _fromImatches _lhsIallPatterns _lhsItryPatterns _localInfo _thenImatches _toImatches _toIuniqueSecondRound
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1780 _ioMatch _toImatchIO
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1781 _fromIcollectInstances _thenIcollectInstances _toIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1782 _fromIunboundNames _thenIunboundNames _toIunboundNames
_self = rule1783 _fromIself _rangeIself _thenIself _toIself
_lhsOself :: Expression
_lhsOself = rule1784 _self
_lhsObeta :: Tp
_lhsObeta = rule1785 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1786 _toIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1787 _toIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1788 _toIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule1789 _toIcounter
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1790 _toIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1791 _toIuniqueChunk
_fromOallPatterns = rule1792 _lhsIallPatterns
_fromOallTypeSchemes = rule1793 _lhsIallTypeSchemes
_fromOavailablePredicates = rule1794 _lhsIavailablePredicates
_fromOclassEnvironment = rule1795 _lhsIclassEnvironment
_fromOcollectErrors = rule1796 _lhsIcollectErrors
_fromOcollectWarnings = rule1797 _lhsIcollectWarnings
_fromOcounter = rule1798 _lhsIcounter
_fromOcurrentChunk = rule1799 _lhsIcurrentChunk
_fromOdictionaryEnvironment = rule1800 _lhsIdictionaryEnvironment
_fromOimportEnvironment = rule1801 _lhsIimportEnvironment
_fromOmatchIO = rule1802 _lhsImatchIO
_fromOmonos = rule1803 _lhsImonos
_fromOnamesInScope = rule1804 _lhsInamesInScope
_fromOorderedTypeSynonyms = rule1805 _lhsIorderedTypeSynonyms
_fromOparentTree = rule1806 _parentTree
_fromOpatternMatchWarnings = rule1807 _lhsIpatternMatchWarnings
_fromOsubstitution = rule1808 _lhsIsubstitution
_fromOtypeschemeMap = rule1809 _lhsItypeschemeMap
_fromOuniqueChunk = rule1810 _lhsIuniqueChunk
_fromOuniqueSecondRound = rule1811 _lhsIuniqueSecondRound
_thenOallPatterns = rule1812 _lhsIallPatterns
_thenOallTypeSchemes = rule1813 _lhsIallTypeSchemes
_thenOavailablePredicates = rule1814 _lhsIavailablePredicates
_thenObetaUnique = rule1815 _fromIbetaUnique
_thenOclassEnvironment = rule1816 _lhsIclassEnvironment
_thenOcollectErrors = rule1817 _fromIcollectErrors
_thenOcollectWarnings = rule1818 _fromIcollectWarnings
_thenOcounter = rule1819 _fromIcounter
_thenOcurrentChunk = rule1820 _lhsIcurrentChunk
_thenOdictionaryEnvironment = rule1821 _fromIdictionaryEnvironment
_thenOimportEnvironment = rule1822 _lhsIimportEnvironment
_thenOmatchIO = rule1823 _fromImatchIO
_thenOmonos = rule1824 _lhsImonos
_thenOnamesInScope = rule1825 _lhsInamesInScope
_thenOorderedTypeSynonyms = rule1826 _lhsIorderedTypeSynonyms
_thenOparentTree = rule1827 _parentTree
_thenOpatternMatchWarnings = rule1828 _fromIpatternMatchWarnings
_thenOsubstitution = rule1829 _lhsIsubstitution
_thenOtypeschemeMap = rule1830 _lhsItypeschemeMap
_thenOuniqueChunk = rule1831 _fromIuniqueChunk
_thenOuniqueSecondRound = rule1832 _fromIuniqueSecondRound
_toOallPatterns = rule1833 _lhsIallPatterns
_toOallTypeSchemes = rule1834 _lhsIallTypeSchemes
_toOavailablePredicates = rule1835 _lhsIavailablePredicates
_toObetaUnique = rule1836 _thenIbetaUnique
_toOclassEnvironment = rule1837 _lhsIclassEnvironment
_toOcollectErrors = rule1838 _thenIcollectErrors
_toOcollectWarnings = rule1839 _thenIcollectWarnings
_toOcounter = rule1840 _thenIcounter
_toOcurrentChunk = rule1841 _lhsIcurrentChunk
_toOdictionaryEnvironment = rule1842 _thenIdictionaryEnvironment
_toOimportEnvironment = rule1843 _lhsIimportEnvironment
_toOmatchIO = rule1844 _thenImatchIO
_toOmonos = rule1845 _lhsImonos
_toOnamesInScope = rule1846 _lhsInamesInScope
_toOorderedTypeSynonyms = rule1847 _lhsIorderedTypeSynonyms
_toOparentTree = rule1848 _parentTree
_toOpatternMatchWarnings = rule1849 _thenIpatternMatchWarnings
_toOsubstitution = rule1850 _lhsIsubstitution
_toOtypeschemeMap = rule1851 _lhsItypeschemeMap
_toOuniqueChunk = rule1852 _thenIuniqueChunk
_toOuniqueSecondRound = rule1853 _thenIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1755 #-}
rule1755 = \ ((_lhsIbetaUnique) :: Int) _overloaded ->
_lhsIbetaUnique + (if _overloaded then 2 else 1)
{-# INLINE rule1756 #-}
rule1756 = \ ((_fromIassumptions) :: Assumptions) ((_thenIassumptions) :: Assumptions) ((_toIassumptions) :: Assumptions) ->
_fromIassumptions `combine` _thenIassumptions `combine` _toIassumptions
{-# INLINE rule1757 #-}
rule1757 = \ _conFrom _conList _conPredicate _conThen _conTo ((_fromIconstraints) :: ConstraintSet) ((_thenIconstraints) :: ConstraintSet) ((_toIconstraints) :: ConstraintSet) ->
(_conList ++ _conPredicate) .>.
Node [ _conFrom .<. _fromIconstraints
, _conThen .<. _thenIconstraints
, _conTo .<. _toIconstraints
]
{-# INLINE rule1758 #-}
rule1758 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1759 #-}
rule1759 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
case M.lookup enumFromName (typeEnvironment _lhsIimportEnvironment) of
Just scheme -> isOverloaded scheme
Nothing -> False
{-# INLINE rule1760 #-}
rule1760 = \ ((_lhsIbetaUnique) :: Int) _overloaded ->
if _overloaded then TVar (_lhsIbetaUnique + 1) else intType
{-# INLINE rule1761 #-}
rule1761 = \ _cinfoPred _elementType _overloaded ->
if _overloaded then [predicate (Predicate "Enum" _elementType) _cinfoPred] else []
{-# INLINE rule1762 #-}
rule1762 = \ _beta _cinfoResult _elementType ->
[ (listType _elementType .==. _beta) _cinfoResult ]
{-# INLINE rule1763 #-}
rule1763 = \ _cinfoFrom _elementType ((_fromIbeta) :: Tp) ->
[ (_fromIbeta .==. _elementType) _cinfoFrom ]
{-# INLINE rule1764 #-}
rule1764 = \ _cinfoThen _elementType ((_thenIbeta) :: Tp) ->
[ (_thenIbeta .==. _elementType) _cinfoThen ]
{-# INLINE rule1765 #-}
rule1765 = \ _cinfoTo _elementType ((_toIbeta) :: Tp) ->
[ (_toIbeta .==. _elementType) _cinfoTo ]
{-# INLINE rule1766 #-}
rule1766 = \ _newDEnv ->
_newDEnv
{-# INLINE rule1767 #-}
rule1767 = \ ((_rangeIself) :: Range) ((_thenIsection) :: Bool) ((_toIsection) :: Bool) ->
flip setNameRange _rangeIself $
case (_thenIsection, _toIsection) of
(False, False) -> enumFromThenToName
(False, True ) -> enumFromThenName
(True , False) -> enumFromToName
(True , True ) -> enumFromName
{-# INLINE rule1768 #-}
rule1768 = \ _elementType ((_lhsIsubstitution) :: FixpointSubstitution) _overloaded ->
if _overloaded then _lhsIsubstitution |-> [Predicate "Enum" _elementType] else []
{-# INLINE rule1769 #-}
rule1769 = \ ((_lhsIavailablePredicates) :: Predicates) ((_lhsIclassEnvironment) :: ClassEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) _localName _requiredDictionaries ((_toIdictionaryEnvironment) :: DictionaryEnvironment) ->
resolveOverloading (_lhsIclassEnvironment) _localName
(_lhsIsubstitution |-> _lhsIavailablePredicates)
(_lhsIsubstitution |-> _requiredDictionaries)
_toIdictionaryEnvironment
{-# INLINE rule1770 #-}
rule1770 = \ _parentTree ->
childConstraint 0 "enumeration" _parentTree
[]
{-# INLINE rule1771 #-}
rule1771 = \ _parentTree ->
childConstraint 1 "enumeration" _parentTree
[]
{-# INLINE rule1772 #-}
rule1772 = \ ((_thenIinfoTrees) :: InfoTrees) ->
1 + length _thenIinfoTrees
{-# INLINE rule1773 #-}
rule1773 = \ _parentTree _toChildNr ->
childConstraint _toChildNr "enumeration" _parentTree
[]
{-# INLINE rule1774 #-}
rule1774 = \ _parentTree ->
resultConstraint "enumeration" _parentTree
[ FolkloreConstraint ]
{-# INLINE rule1775 #-}
rule1775 = \ _elementType _parentTree ->
resultConstraint "enumeration" _parentTree
[ ReductionErrorInfo (Predicate "Enum" _elementType) ]
{-# INLINE rule1776 #-}
rule1776 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1777 #-}
rule1777 = \ ((_fromIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_thenIinfoTrees) :: InfoTrees) ((_toIinfoTrees) :: InfoTrees) ->
node _lhsIparentTree _localInfo (_fromIinfoTree : _thenIinfoTrees ++ _toIinfoTrees)
{-# INLINE rule1778 #-}
rule1778 = \ _parentTree ->
_parentTree
{-# INLINE rule1779 #-}
rule1779 = \ _assumptions _constraints ((_fromImatches) :: [Maybe MetaVariableTable]) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ((_thenImatches) :: [Maybe MetaVariableTable]) ((_toImatches) :: [Maybe MetaVariableTable]) ((_toIuniqueSecondRound) :: Int) ->
let infoTuple = metaVarInfo _constraints _assumptions _localInfo
in match3 infoTuple _toIuniqueSecondRound
match_Expression_Enum
_lhsItryPatterns _lhsIallPatterns
[_fromImatches, _thenImatches, _toImatches]
{-# INLINE rule1780 #-}
rule1780 = \ _ioMatch ((_toImatchIO) :: IO ()) ->
_toImatchIO >> _ioMatch
{-# INLINE rule1781 #-}
rule1781 = \ ((_fromIcollectInstances) :: [(Name, Instance)]) ((_thenIcollectInstances) :: [(Name, Instance)]) ((_toIcollectInstances) :: [(Name, Instance)]) ->
_fromIcollectInstances ++ _thenIcollectInstances ++ _toIcollectInstances
{-# INLINE rule1782 #-}
rule1782 = \ ((_fromIunboundNames) :: Names) ((_thenIunboundNames) :: Names) ((_toIunboundNames) :: Names) ->
_fromIunboundNames ++ _thenIunboundNames ++ _toIunboundNames
{-# INLINE rule1783 #-}
rule1783 = \ ((_fromIself) :: Expression) ((_rangeIself) :: Range) ((_thenIself) :: MaybeExpression) ((_toIself) :: MaybeExpression) ->
Expression_Enum _rangeIself _fromIself _thenIself _toIself
{-# INLINE rule1784 #-}
rule1784 = \ _self ->
_self
{-# INLINE rule1785 #-}
rule1785 = \ _beta ->
_beta
{-# INLINE rule1786 #-}
rule1786 = \ ((_toIbetaUnique) :: Int) ->
_toIbetaUnique
{-# INLINE rule1787 #-}
rule1787 = \ ((_toIcollectErrors) :: TypeErrors) ->
_toIcollectErrors
{-# INLINE rule1788 #-}
rule1788 = \ ((_toIcollectWarnings) :: Warnings) ->
_toIcollectWarnings
{-# INLINE rule1789 #-}
rule1789 = \ ((_toIcounter) :: Int) ->
_toIcounter
{-# INLINE rule1790 #-}
rule1790 = \ ((_toIpatternMatchWarnings) :: [Warning]) ->
_toIpatternMatchWarnings
{-# INLINE rule1791 #-}
rule1791 = \ ((_toIuniqueChunk) :: Int) ->
_toIuniqueChunk
{-# INLINE rule1792 #-}
rule1792 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1793 #-}
rule1793 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1794 #-}
rule1794 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1795 #-}
rule1795 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1796 #-}
rule1796 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1797 #-}
rule1797 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1798 #-}
rule1798 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1799 #-}
rule1799 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1800 #-}
rule1800 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1801 #-}
rule1801 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1802 #-}
rule1802 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1803 #-}
rule1803 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1804 #-}
rule1804 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1805 #-}
rule1805 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1806 #-}
rule1806 = \ _parentTree ->
_parentTree
{-# INLINE rule1807 #-}
rule1807 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1808 #-}
rule1808 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1809 #-}
rule1809 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1810 #-}
rule1810 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1811 #-}
rule1811 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule1812 #-}
rule1812 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1813 #-}
rule1813 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1814 #-}
rule1814 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1815 #-}
rule1815 = \ ((_fromIbetaUnique) :: Int) ->
_fromIbetaUnique
{-# INLINE rule1816 #-}
rule1816 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1817 #-}
rule1817 = \ ((_fromIcollectErrors) :: TypeErrors) ->
_fromIcollectErrors
{-# INLINE rule1818 #-}
rule1818 = \ ((_fromIcollectWarnings) :: Warnings) ->
_fromIcollectWarnings
{-# INLINE rule1819 #-}
rule1819 = \ ((_fromIcounter) :: Int) ->
_fromIcounter
{-# INLINE rule1820 #-}
rule1820 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1821 #-}
rule1821 = \ ((_fromIdictionaryEnvironment) :: DictionaryEnvironment) ->
_fromIdictionaryEnvironment
{-# INLINE rule1822 #-}
rule1822 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1823 #-}
rule1823 = \ ((_fromImatchIO) :: IO ()) ->
_fromImatchIO
{-# INLINE rule1824 #-}
rule1824 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1825 #-}
rule1825 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1826 #-}
rule1826 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1827 #-}
rule1827 = \ _parentTree ->
_parentTree
{-# INLINE rule1828 #-}
rule1828 = \ ((_fromIpatternMatchWarnings) :: [Warning]) ->
_fromIpatternMatchWarnings
{-# INLINE rule1829 #-}
rule1829 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1830 #-}
rule1830 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1831 #-}
rule1831 = \ ((_fromIuniqueChunk) :: Int) ->
_fromIuniqueChunk
{-# INLINE rule1832 #-}
rule1832 = \ ((_fromIuniqueSecondRound) :: Int) ->
_fromIuniqueSecondRound
{-# INLINE rule1833 #-}
rule1833 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1834 #-}
rule1834 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1835 #-}
rule1835 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1836 #-}
rule1836 = \ ((_thenIbetaUnique) :: Int) ->
_thenIbetaUnique
{-# INLINE rule1837 #-}
rule1837 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1838 #-}
rule1838 = \ ((_thenIcollectErrors) :: TypeErrors) ->
_thenIcollectErrors
{-# INLINE rule1839 #-}
rule1839 = \ ((_thenIcollectWarnings) :: Warnings) ->
_thenIcollectWarnings
{-# INLINE rule1840 #-}
rule1840 = \ ((_thenIcounter) :: Int) ->
_thenIcounter
{-# INLINE rule1841 #-}
rule1841 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1842 #-}
rule1842 = \ ((_thenIdictionaryEnvironment) :: DictionaryEnvironment) ->
_thenIdictionaryEnvironment
{-# INLINE rule1843 #-}
rule1843 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1844 #-}
rule1844 = \ ((_thenImatchIO) :: IO ()) ->
_thenImatchIO
{-# INLINE rule1845 #-}
rule1845 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1846 #-}
rule1846 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1847 #-}
rule1847 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1848 #-}
rule1848 = \ _parentTree ->
_parentTree
{-# INLINE rule1849 #-}
rule1849 = \ ((_thenIpatternMatchWarnings) :: [Warning]) ->
_thenIpatternMatchWarnings
{-# INLINE rule1850 #-}
rule1850 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1851 #-}
rule1851 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1852 #-}
rule1852 = \ ((_thenIuniqueChunk) :: Int) ->
_thenIuniqueChunk
{-# INLINE rule1853 #-}
rule1853 = \ ((_thenIuniqueSecondRound) :: Int) ->
_thenIuniqueSecondRound
{-# NOINLINE sem_Expression_Negate #-}
sem_Expression_Negate :: T_Range -> T_Expression -> T_Expression
sem_Expression_Negate arg_range_ arg_expression_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_expressionObetaUnique = rule1854 _lhsIbetaUnique
_constraints = rule1855 _expressionIconstraints _newcon
_beta = rule1856 _lhsIbetaUnique
_newcon = rule1857 _beta _cinfo _expressionIbeta _lhsIimportEnvironment
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1858 _newDEnv
_localName = rule1859 _rangeIself
_negateTypeScheme = rule1860 _lhsIimportEnvironment _localName
_requiredDictionaries = rule1861 _lhsIimportEnvironment _lhsIsubstitution _negateTypeScheme _usedAsType
_usedAsType = rule1862 _beta _expressionIbeta _lhsIsubstitution
_newDEnv = rule1863 _expressionIdictionaryEnvironment _lhsIavailablePredicates _lhsIclassEnvironment _lhsIsubstitution _localName _requiredDictionaries
_cinfo = rule1864 _localInfo _parentTree _rangeIself
_localInfo = rule1865 _beta _lhsImonos _self
_parentTree = rule1866 _expressionIinfoTree _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1867 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOconstraints :: ConstraintSet
_lhsOassumptions :: Assumptions
_lhsOuniqueSecondRound :: Int
(_expressionOtryPatterns,_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1868 _constraints _expressionIassumptions _expressionImatches _expressionIuniqueSecondRound _lhsIallPatterns _lhsItryPatterns _localInfo
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1869 _expressionImatchIO _ioMatch
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1870 _expressionIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1871 _expressionIunboundNames
_self = rule1872 _expressionIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule1873 _self
_lhsObeta :: Tp
_lhsObeta = rule1874 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1875 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1876 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1877 _expressionIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule1878 _expressionIcounter
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1879 _expressionIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1880 _expressionIuniqueChunk
_expressionOallPatterns = rule1881 _lhsIallPatterns
_expressionOallTypeSchemes = rule1882 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule1883 _lhsIavailablePredicates
_expressionOclassEnvironment = rule1884 _lhsIclassEnvironment
_expressionOcollectErrors = rule1885 _lhsIcollectErrors
_expressionOcollectWarnings = rule1886 _lhsIcollectWarnings
_expressionOcounter = rule1887 _lhsIcounter
_expressionOcurrentChunk = rule1888 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule1889 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule1890 _lhsIimportEnvironment
_expressionOmatchIO = rule1891 _lhsImatchIO
_expressionOmonos = rule1892 _lhsImonos
_expressionOnamesInScope = rule1893 _lhsInamesInScope
_expressionOorderedTypeSynonyms = rule1894 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule1895 _parentTree
_expressionOpatternMatchWarnings = rule1896 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule1897 _lhsIsubstitution
_expressionOtypeschemeMap = rule1898 _lhsItypeschemeMap
_expressionOuniqueChunk = rule1899 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule1900 _lhsIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1854 #-}
rule1854 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule1855 #-}
rule1855 = \ ((_expressionIconstraints) :: ConstraintSet) _newcon ->
_newcon .>. Node [ _expressionIconstraints ]
{-# INLINE rule1856 #-}
rule1856 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1857 #-}
rule1857 = \ _beta _cinfo ((_expressionIbeta) :: Tp) ((_lhsIimportEnvironment) :: ImportEnvironment) ->
let standard = makeScheme [] [Predicate "Num" (TVar 0)] (TVar 0 .->. TVar 0)
tpscheme = M.findWithDefault standard (nameFromString "negate") (typeEnvironment _lhsIimportEnvironment)
in [ (_expressionIbeta .->. _beta .::. tpscheme) _cinfo]
{-# INLINE rule1858 #-}
rule1858 = \ _newDEnv ->
_newDEnv
{-# INLINE rule1859 #-}
rule1859 = \ ((_rangeIself) :: Range) ->
setNameRange intUnaryMinusName _rangeIself
{-# INLINE rule1860 #-}
rule1860 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) _localName ->
case M.lookup _localName (typeEnvironment _lhsIimportEnvironment) of
Just scheme -> scheme
Nothing -> internalError "TypeInferenceOverloading.ag" "n/a" "type of negate unknown"
{-# INLINE rule1861 #-}
rule1861 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) _negateTypeScheme _usedAsType ->
getRequiredDictionaries
(getOrderedTypeSynonyms _lhsIimportEnvironment)
(_lhsIsubstitution |-> _usedAsType)
(_lhsIsubstitution |-> _negateTypeScheme)
{-# INLINE rule1862 #-}
rule1862 = \ _beta ((_expressionIbeta) :: Tp) ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution |-> (_expressionIbeta .->. _beta)
{-# INLINE rule1863 #-}
rule1863 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ((_lhsIavailablePredicates) :: Predicates) ((_lhsIclassEnvironment) :: ClassEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) _localName _requiredDictionaries ->
resolveOverloading (_lhsIclassEnvironment) _localName
(_lhsIsubstitution |-> _lhsIavailablePredicates)
(_lhsIsubstitution |-> _requiredDictionaries)
_expressionIdictionaryEnvironment
{-# INLINE rule1864 #-}
rule1864 = \ _localInfo _parentTree ((_rangeIself) :: Range) ->
specialConstraint "negation" _parentTree
(self _localInfo, Just $ nameToUHA_Expr (Name_Operator _rangeIself [] "-"))
[]
{-# INLINE rule1865 #-}
rule1865 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1866 #-}
rule1866 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo [_expressionIinfoTree]
{-# INLINE rule1867 #-}
rule1867 = \ _parentTree ->
_parentTree
{-# INLINE rule1868 #-}
rule1868 = \ _constraints ((_expressionIassumptions) :: Assumptions) ((_expressionImatches) :: [Maybe MetaVariableTable]) ((_expressionIuniqueSecondRound) :: Int) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ->
let infoTuple = metaVarInfo _constraints _expressionIassumptions _localInfo
in match1 infoTuple _expressionIuniqueSecondRound
match_Expression_Negate
_lhsItryPatterns _lhsIallPatterns
[_expressionImatches]
{-# INLINE rule1869 #-}
rule1869 = \ ((_expressionImatchIO) :: IO ()) _ioMatch ->
_expressionImatchIO >> _ioMatch
{-# INLINE rule1870 #-}
rule1870 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances
{-# INLINE rule1871 #-}
rule1871 = \ ((_expressionIunboundNames) :: Names) ->
_expressionIunboundNames
{-# INLINE rule1872 #-}
rule1872 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
Expression_Negate _rangeIself _expressionIself
{-# INLINE rule1873 #-}
rule1873 = \ _self ->
_self
{-# INLINE rule1874 #-}
rule1874 = \ _beta ->
_beta
{-# INLINE rule1875 #-}
rule1875 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule1876 #-}
rule1876 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule1877 #-}
rule1877 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule1878 #-}
rule1878 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule1879 #-}
rule1879 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule1880 #-}
rule1880 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule1881 #-}
rule1881 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1882 #-}
rule1882 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1883 #-}
rule1883 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1884 #-}
rule1884 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1885 #-}
rule1885 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1886 #-}
rule1886 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1887 #-}
rule1887 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1888 #-}
rule1888 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1889 #-}
rule1889 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1890 #-}
rule1890 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1891 #-}
rule1891 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1892 #-}
rule1892 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1893 #-}
rule1893 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1894 #-}
rule1894 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1895 #-}
rule1895 = \ _parentTree ->
_parentTree
{-# INLINE rule1896 #-}
rule1896 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1897 #-}
rule1897 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1898 #-}
rule1898 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1899 #-}
rule1899 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1900 #-}
rule1900 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_NegateFloat #-}
sem_Expression_NegateFloat :: T_Range -> T_Expression -> T_Expression
sem_Expression_NegateFloat arg_range_ arg_expression_ = T_Expression (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_expressionObetaUnique = rule1901 _lhsIbetaUnique
_constraints = rule1902 _expressionIconstraints _newcon
_beta = rule1903 _lhsIbetaUnique
_newcon = rule1904 _beta _cinfo _expressionIbeta
_cinfo = rule1905 _localInfo _parentTree _rangeIself
_localInfo = rule1906 _beta _lhsImonos _self
_parentTree = rule1907 _expressionIinfoTree _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule1908 _parentTree
_lhsOmatches :: [Maybe MetaVariableTable]
_lhsOconstraints :: ConstraintSet
_lhsOassumptions :: Assumptions
_lhsOuniqueSecondRound :: Int
(_expressionOtryPatterns,_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1909 _constraints _expressionIassumptions _expressionImatches _expressionIuniqueSecondRound _lhsIallPatterns _lhsItryPatterns _localInfo
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1910 _expressionImatchIO _ioMatch
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1911 _expressionIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1912 _expressionIunboundNames
_self = rule1913 _expressionIself _rangeIself
_lhsOself :: Expression
_lhsOself = rule1914 _self
_lhsObeta :: Tp
_lhsObeta = rule1915 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1916 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1917 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1918 _expressionIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule1919 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1920 _expressionIdictionaryEnvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1921 _expressionIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1922 _expressionIuniqueChunk
_expressionOallPatterns = rule1923 _lhsIallPatterns
_expressionOallTypeSchemes = rule1924 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule1925 _lhsIavailablePredicates
_expressionOclassEnvironment = rule1926 _lhsIclassEnvironment
_expressionOcollectErrors = rule1927 _lhsIcollectErrors
_expressionOcollectWarnings = rule1928 _lhsIcollectWarnings
_expressionOcounter = rule1929 _lhsIcounter
_expressionOcurrentChunk = rule1930 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule1931 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule1932 _lhsIimportEnvironment
_expressionOmatchIO = rule1933 _lhsImatchIO
_expressionOmonos = rule1934 _lhsImonos
_expressionOnamesInScope = rule1935 _lhsInamesInScope
_expressionOorderedTypeSynonyms = rule1936 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule1937 _parentTree
_expressionOpatternMatchWarnings = rule1938 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule1939 _lhsIsubstitution
_expressionOtypeschemeMap = rule1940 _lhsItypeschemeMap
_expressionOuniqueChunk = rule1941 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule1942 _lhsIuniqueSecondRound
__result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expression_s41 v40
{-# INLINE rule1901 #-}
rule1901 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule1902 #-}
rule1902 = \ ((_expressionIconstraints) :: ConstraintSet) _newcon ->
_newcon .>. Node [ _expressionIconstraints ]
{-# INLINE rule1903 #-}
rule1903 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule1904 #-}
rule1904 = \ _beta _cinfo ((_expressionIbeta) :: Tp) ->
[ (floatType .->. floatType .==. _expressionIbeta .->. _beta) _cinfo]
{-# INLINE rule1905 #-}
rule1905 = \ _localInfo _parentTree ((_rangeIself) :: Range) ->
specialConstraint "negation" _parentTree
(self _localInfo, Just $ nameToUHA_Expr (Name_Operator _rangeIself [] "-."))
[]
{-# INLINE rule1906 #-}
rule1906 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Expr _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule1907 #-}
rule1907 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo [_expressionIinfoTree]
{-# INLINE rule1908 #-}
rule1908 = \ _parentTree ->
_parentTree
{-# INLINE rule1909 #-}
rule1909 = \ _constraints ((_expressionIassumptions) :: Assumptions) ((_expressionImatches) :: [Maybe MetaVariableTable]) ((_expressionIuniqueSecondRound) :: Int) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression , [String])]) _localInfo ->
let infoTuple = metaVarInfo _constraints _expressionIassumptions _localInfo
in match1 infoTuple _expressionIuniqueSecondRound
match_Expression_NegateFloat
_lhsItryPatterns _lhsIallPatterns
[_expressionImatches]
{-# INLINE rule1910 #-}
rule1910 = \ ((_expressionImatchIO) :: IO ()) _ioMatch ->
_expressionImatchIO >> _ioMatch
{-# INLINE rule1911 #-}
rule1911 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances
{-# INLINE rule1912 #-}
rule1912 = \ ((_expressionIunboundNames) :: Names) ->
_expressionIunboundNames
{-# INLINE rule1913 #-}
rule1913 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
Expression_NegateFloat _rangeIself _expressionIself
{-# INLINE rule1914 #-}
rule1914 = \ _self ->
_self
{-# INLINE rule1915 #-}
rule1915 = \ _beta ->
_beta
{-# INLINE rule1916 #-}
rule1916 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule1917 #-}
rule1917 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule1918 #-}
rule1918 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule1919 #-}
rule1919 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule1920 #-}
rule1920 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule1921 #-}
rule1921 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule1922 #-}
rule1922 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule1923 #-}
rule1923 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1924 #-}
rule1924 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1925 #-}
rule1925 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1926 #-}
rule1926 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1927 #-}
rule1927 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1928 #-}
rule1928 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1929 #-}
rule1929 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1930 #-}
rule1930 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1931 #-}
rule1931 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1932 #-}
rule1932 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1933 #-}
rule1933 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1934 #-}
rule1934 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1935 #-}
rule1935 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1936 #-}
rule1936 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1937 #-}
rule1937 = \ _parentTree ->
_parentTree
{-# INLINE rule1938 #-}
rule1938 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1939 #-}
rule1939 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1940 #-}
rule1940 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1941 #-}
rule1941 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1942 #-}
rule1942 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
-- Expressions -------------------------------------------------
-- wrapper
data Inh_Expressions = Inh_Expressions { allPatterns_Inh_Expressions :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Expressions :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Expressions :: (Predicates), betaUnique_Inh_Expressions :: (Int), classEnvironment_Inh_Expressions :: (ClassEnvironment), collectErrors_Inh_Expressions :: (TypeErrors), collectWarnings_Inh_Expressions :: (Warnings), counter_Inh_Expressions :: (Int), currentChunk_Inh_Expressions :: (Int), dictionaryEnvironment_Inh_Expressions :: (DictionaryEnvironment), importEnvironment_Inh_Expressions :: (ImportEnvironment), matchIO_Inh_Expressions :: (IO ()), monos_Inh_Expressions :: (Monos), namesInScope_Inh_Expressions :: (Names), orderedTypeSynonyms_Inh_Expressions :: (OrderedTypeSynonyms), parentTree_Inh_Expressions :: (InfoTree), patternMatchWarnings_Inh_Expressions :: ([Warning]), substitution_Inh_Expressions :: (FixpointSubstitution), tryPatterns_Inh_Expressions :: ([(Expressions , [String])]), typeschemeMap_Inh_Expressions :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Expressions :: (Int), uniqueSecondRound_Inh_Expressions :: (Int) }
data Syn_Expressions = Syn_Expressions { assumptions_Syn_Expressions :: (Assumptions), betaUnique_Syn_Expressions :: (Int), betas_Syn_Expressions :: (Tps), collectErrors_Syn_Expressions :: (TypeErrors), collectInstances_Syn_Expressions :: ([(Name, Instance)]), collectWarnings_Syn_Expressions :: (Warnings), constraintslist_Syn_Expressions :: (ConstraintSets), counter_Syn_Expressions :: (Int), dictionaryEnvironment_Syn_Expressions :: (DictionaryEnvironment), infoTrees_Syn_Expressions :: (InfoTrees), matchIO_Syn_Expressions :: (IO ()), matches_Syn_Expressions :: ([Maybe MetaVariableTable]), patternMatchWarnings_Syn_Expressions :: ([Warning]), self_Syn_Expressions :: (Expressions), unboundNames_Syn_Expressions :: (Names), uniqueChunk_Syn_Expressions :: (Int), uniqueSecondRound_Syn_Expressions :: (Int) }
{-# INLINABLE wrap_Expressions #-}
wrap_Expressions :: T_Expressions -> Inh_Expressions -> (Syn_Expressions )
wrap_Expressions (T_Expressions act) (Inh_Expressions _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Expressions_vIn43 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound
(T_Expressions_vOut43 _lhsOassumptions _lhsObetaUnique _lhsObetas _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_Expressions_s44 sem arg)
return (Syn_Expressions _lhsOassumptions _lhsObetaUnique _lhsObetas _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
)
-- cata
{-# NOINLINE sem_Expressions #-}
sem_Expressions :: Expressions -> T_Expressions
sem_Expressions list = Prelude.foldr sem_Expressions_Cons sem_Expressions_Nil (Prelude.map sem_Expression list)
-- semantic domain
newtype T_Expressions = T_Expressions {
attach_T_Expressions :: Identity (T_Expressions_s44 )
}
newtype T_Expressions_s44 = C_Expressions_s44 {
inv_Expressions_s44 :: (T_Expressions_v43 )
}
data T_Expressions_s45 = C_Expressions_s45
type T_Expressions_v43 = (T_Expressions_vIn43 ) -> (T_Expressions_vOut43 )
data T_Expressions_vIn43 = T_Expressions_vIn43 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) ([(Expressions , [String])]) (M.Map Int (Scheme Predicates)) (Int) (Int)
data T_Expressions_vOut43 = T_Expressions_vOut43 (Assumptions) (Int) (Tps) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSets) (Int) (DictionaryEnvironment) (InfoTrees) (IO ()) ([Maybe MetaVariableTable]) ([Warning]) (Expressions) (Names) (Int) (Int)
{-# NOINLINE sem_Expressions_Cons #-}
sem_Expressions_Cons :: T_Expression -> T_Expressions -> T_Expressions
sem_Expressions_Cons arg_hd_ arg_tl_ = T_Expressions (return st44) where
{-# NOINLINE st44 #-}
st44 = let
v43 :: T_Expressions_v43
v43 = \ (T_Expressions_vIn43 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_hdX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_hd_))
_tlX44 = Control.Monad.Identity.runIdentity (attach_T_Expressions (arg_tl_))
(T_Expression_vOut40 _hdIassumptions _hdIbeta _hdIbetaUnique _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIconstraints _hdIcounter _hdIdictionaryEnvironment _hdIinfoTree _hdImatchIO _hdImatches _hdIpatternMatchWarnings _hdIself _hdIunboundNames _hdIuniqueChunk _hdIuniqueSecondRound) = inv_Expression_s41 _hdX41 (T_Expression_vIn40 _hdOallPatterns _hdOallTypeSchemes _hdOavailablePredicates _hdObetaUnique _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtryPatterns _hdOtypeschemeMap _hdOuniqueChunk _hdOuniqueSecondRound)
(T_Expressions_vOut43 _tlIassumptions _tlIbetaUnique _tlIbetas _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIconstraintslist _tlIcounter _tlIdictionaryEnvironment _tlIinfoTrees _tlImatchIO _tlImatches _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk _tlIuniqueSecondRound) = inv_Expressions_s44 _tlX44 (T_Expressions_vIn43 _tlOallPatterns _tlOallTypeSchemes _tlOavailablePredicates _tlObetaUnique _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtryPatterns _tlOtypeschemeMap _tlOuniqueChunk _tlOuniqueSecondRound)
_lhsObetas :: Tps
_lhsObetas = rule1943 _hdIbeta _tlIbetas
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule1944 _hdIassumptions _tlIassumptions
_lhsOconstraintslist :: ConstraintSets
_lhsOconstraintslist = rule1945 _hdIconstraints _tlIconstraintslist
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule1946 _hdIinfoTree _tlIinfoTrees
_lhsOmatches :: [Maybe MetaVariableTable]
((_hdOtryPatterns,_tlOtryPatterns),_lhsOmatches,_,_,_,_) = rule1947 _hdImatches _lhsItryPatterns _tlImatches
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule1948 _hdIcollectInstances _tlIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule1949 _hdIunboundNames _tlIunboundNames
_self = rule1950 _hdIself _tlIself
_lhsOself :: Expressions
_lhsOself = rule1951 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule1952 _tlIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule1953 _tlIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule1954 _tlIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule1955 _tlIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule1956 _tlIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule1957 _tlImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule1958 _tlIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule1959 _tlIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule1960 _tlIuniqueSecondRound
_hdOallPatterns = rule1961 _lhsIallPatterns
_hdOallTypeSchemes = rule1962 _lhsIallTypeSchemes
_hdOavailablePredicates = rule1963 _lhsIavailablePredicates
_hdObetaUnique = rule1964 _lhsIbetaUnique
_hdOclassEnvironment = rule1965 _lhsIclassEnvironment
_hdOcollectErrors = rule1966 _lhsIcollectErrors
_hdOcollectWarnings = rule1967 _lhsIcollectWarnings
_hdOcounter = rule1968 _lhsIcounter
_hdOcurrentChunk = rule1969 _lhsIcurrentChunk
_hdOdictionaryEnvironment = rule1970 _lhsIdictionaryEnvironment
_hdOimportEnvironment = rule1971 _lhsIimportEnvironment
_hdOmatchIO = rule1972 _lhsImatchIO
_hdOmonos = rule1973 _lhsImonos
_hdOnamesInScope = rule1974 _lhsInamesInScope
_hdOorderedTypeSynonyms = rule1975 _lhsIorderedTypeSynonyms
_hdOparentTree = rule1976 _lhsIparentTree
_hdOpatternMatchWarnings = rule1977 _lhsIpatternMatchWarnings
_hdOsubstitution = rule1978 _lhsIsubstitution
_hdOtypeschemeMap = rule1979 _lhsItypeschemeMap
_hdOuniqueChunk = rule1980 _lhsIuniqueChunk
_hdOuniqueSecondRound = rule1981 _lhsIuniqueSecondRound
_tlOallPatterns = rule1982 _lhsIallPatterns
_tlOallTypeSchemes = rule1983 _lhsIallTypeSchemes
_tlOavailablePredicates = rule1984 _lhsIavailablePredicates
_tlObetaUnique = rule1985 _hdIbetaUnique
_tlOclassEnvironment = rule1986 _lhsIclassEnvironment
_tlOcollectErrors = rule1987 _hdIcollectErrors
_tlOcollectWarnings = rule1988 _hdIcollectWarnings
_tlOcounter = rule1989 _hdIcounter
_tlOcurrentChunk = rule1990 _lhsIcurrentChunk
_tlOdictionaryEnvironment = rule1991 _hdIdictionaryEnvironment
_tlOimportEnvironment = rule1992 _lhsIimportEnvironment
_tlOmatchIO = rule1993 _hdImatchIO
_tlOmonos = rule1994 _lhsImonos
_tlOnamesInScope = rule1995 _lhsInamesInScope
_tlOorderedTypeSynonyms = rule1996 _lhsIorderedTypeSynonyms
_tlOparentTree = rule1997 _lhsIparentTree
_tlOpatternMatchWarnings = rule1998 _hdIpatternMatchWarnings
_tlOsubstitution = rule1999 _lhsIsubstitution
_tlOtypeschemeMap = rule2000 _lhsItypeschemeMap
_tlOuniqueChunk = rule2001 _hdIuniqueChunk
_tlOuniqueSecondRound = rule2002 _hdIuniqueSecondRound
__result_ = T_Expressions_vOut43 _lhsOassumptions _lhsObetaUnique _lhsObetas _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expressions_s44 v43
{-# INLINE rule1943 #-}
rule1943 = \ ((_hdIbeta) :: Tp) ((_tlIbetas) :: Tps) ->
_hdIbeta : _tlIbetas
{-# INLINE rule1944 #-}
rule1944 = \ ((_hdIassumptions) :: Assumptions) ((_tlIassumptions) :: Assumptions) ->
_hdIassumptions `combine` _tlIassumptions
{-# INLINE rule1945 #-}
rule1945 = \ ((_hdIconstraints) :: ConstraintSet) ((_tlIconstraintslist) :: ConstraintSets) ->
_hdIconstraints : _tlIconstraintslist
{-# INLINE rule1946 #-}
rule1946 = \ ((_hdIinfoTree) :: InfoTree) ((_tlIinfoTrees) :: InfoTrees) ->
_hdIinfoTree : _tlIinfoTrees
{-# INLINE rule1947 #-}
rule1947 = \ ((_hdImatches) :: [Maybe MetaVariableTable]) ((_lhsItryPatterns) :: [(Expressions , [String])]) ((_tlImatches) :: [Maybe MetaVariableTable]) ->
match2' match_Expressions_Cons _lhsItryPatterns [] [_hdImatches, _tlImatches]
{-# INLINE rule1948 #-}
rule1948 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
_hdIcollectInstances ++ _tlIcollectInstances
{-# INLINE rule1949 #-}
rule1949 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
_hdIunboundNames ++ _tlIunboundNames
{-# INLINE rule1950 #-}
rule1950 = \ ((_hdIself) :: Expression) ((_tlIself) :: Expressions) ->
(:) _hdIself _tlIself
{-# INLINE rule1951 #-}
rule1951 = \ _self ->
_self
{-# INLINE rule1952 #-}
rule1952 = \ ((_tlIbetaUnique) :: Int) ->
_tlIbetaUnique
{-# INLINE rule1953 #-}
rule1953 = \ ((_tlIcollectErrors) :: TypeErrors) ->
_tlIcollectErrors
{-# INLINE rule1954 #-}
rule1954 = \ ((_tlIcollectWarnings) :: Warnings) ->
_tlIcollectWarnings
{-# INLINE rule1955 #-}
rule1955 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule1956 #-}
rule1956 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
_tlIdictionaryEnvironment
{-# INLINE rule1957 #-}
rule1957 = \ ((_tlImatchIO) :: IO ()) ->
_tlImatchIO
{-# INLINE rule1958 #-}
rule1958 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
_tlIpatternMatchWarnings
{-# INLINE rule1959 #-}
rule1959 = \ ((_tlIuniqueChunk) :: Int) ->
_tlIuniqueChunk
{-# INLINE rule1960 #-}
rule1960 = \ ((_tlIuniqueSecondRound) :: Int) ->
_tlIuniqueSecondRound
{-# INLINE rule1961 #-}
rule1961 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1962 #-}
rule1962 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1963 #-}
rule1963 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1964 #-}
rule1964 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule1965 #-}
rule1965 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1966 #-}
rule1966 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule1967 #-}
rule1967 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule1968 #-}
rule1968 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule1969 #-}
rule1969 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1970 #-}
rule1970 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule1971 #-}
rule1971 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1972 #-}
rule1972 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule1973 #-}
rule1973 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1974 #-}
rule1974 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1975 #-}
rule1975 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1976 #-}
rule1976 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule1977 #-}
rule1977 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule1978 #-}
rule1978 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule1979 #-}
rule1979 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule1980 #-}
rule1980 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule1981 #-}
rule1981 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule1982 #-}
rule1982 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule1983 #-}
rule1983 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule1984 #-}
rule1984 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule1985 #-}
rule1985 = \ ((_hdIbetaUnique) :: Int) ->
_hdIbetaUnique
{-# INLINE rule1986 #-}
rule1986 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule1987 #-}
rule1987 = \ ((_hdIcollectErrors) :: TypeErrors) ->
_hdIcollectErrors
{-# INLINE rule1988 #-}
rule1988 = \ ((_hdIcollectWarnings) :: Warnings) ->
_hdIcollectWarnings
{-# INLINE rule1989 #-}
rule1989 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule1990 #-}
rule1990 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule1991 #-}
rule1991 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
_hdIdictionaryEnvironment
{-# INLINE rule1992 #-}
rule1992 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule1993 #-}
rule1993 = \ ((_hdImatchIO) :: IO ()) ->
_hdImatchIO
{-# INLINE rule1994 #-}
rule1994 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule1995 #-}
rule1995 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule1996 #-}
rule1996 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule1997 #-}
rule1997 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule1998 #-}
rule1998 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
_hdIpatternMatchWarnings
{-# INLINE rule1999 #-}
rule1999 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule2000 #-}
rule2000 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule2001 #-}
rule2001 = \ ((_hdIuniqueChunk) :: Int) ->
_hdIuniqueChunk
{-# INLINE rule2002 #-}
rule2002 = \ ((_hdIuniqueSecondRound) :: Int) ->
_hdIuniqueSecondRound
{-# NOINLINE sem_Expressions_Nil #-}
sem_Expressions_Nil :: T_Expressions
sem_Expressions_Nil = T_Expressions (return st44) where
{-# NOINLINE st44 #-}
st44 = let
v43 :: T_Expressions_v43
v43 = \ (T_Expressions_vIn43 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_lhsObetas :: Tps
_lhsObetas = rule2003 ()
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule2004 ()
_lhsOconstraintslist :: ConstraintSets
_lhsOconstraintslist = rule2005 ()
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2006 ()
_lhsOmatches :: [Maybe MetaVariableTable]
((),_lhsOmatches,_,_,_,_) = rule2007 _lhsItryPatterns
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2008 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2009 ()
_self = rule2010 ()
_lhsOself :: Expressions
_lhsOself = rule2011 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2012 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2013 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2014 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule2015 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2016 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2017 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2018 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2019 _lhsIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule2020 _lhsIuniqueSecondRound
__result_ = T_Expressions_vOut43 _lhsOassumptions _lhsObetaUnique _lhsObetas _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Expressions_s44 v43
{-# INLINE rule2003 #-}
rule2003 = \ (_ :: ()) ->
[]
{-# INLINE rule2004 #-}
rule2004 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule2005 #-}
rule2005 = \ (_ :: ()) ->
[]
{-# INLINE rule2006 #-}
rule2006 = \ (_ :: ()) ->
[]
{-# INLINE rule2007 #-}
rule2007 = \ ((_lhsItryPatterns) :: [(Expressions , [String])]) ->
match0' match_Expressions_Nil _lhsItryPatterns [] []
{-# INLINE rule2008 #-}
rule2008 = \ (_ :: ()) ->
[]
{-# INLINE rule2009 #-}
rule2009 = \ (_ :: ()) ->
[]
{-# INLINE rule2010 #-}
rule2010 = \ (_ :: ()) ->
[]
{-# INLINE rule2011 #-}
rule2011 = \ _self ->
_self
{-# INLINE rule2012 #-}
rule2012 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2013 #-}
rule2013 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2014 #-}
rule2014 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2015 #-}
rule2015 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2016 #-}
rule2016 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2017 #-}
rule2017 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2018 #-}
rule2018 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2019 #-}
rule2019 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule2020 #-}
rule2020 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
-- FieldDeclaration --------------------------------------------
-- wrapper
data Inh_FieldDeclaration = Inh_FieldDeclaration { counter_Inh_FieldDeclaration :: (Int), namesInScope_Inh_FieldDeclaration :: (Names) }
data Syn_FieldDeclaration = Syn_FieldDeclaration { counter_Syn_FieldDeclaration :: (Int), self_Syn_FieldDeclaration :: (FieldDeclaration), unboundNames_Syn_FieldDeclaration :: (Names) }
{-# INLINABLE wrap_FieldDeclaration #-}
wrap_FieldDeclaration :: T_FieldDeclaration -> Inh_FieldDeclaration -> (Syn_FieldDeclaration )
wrap_FieldDeclaration (T_FieldDeclaration act) (Inh_FieldDeclaration _lhsIcounter _lhsInamesInScope) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_FieldDeclaration_vIn46 _lhsIcounter _lhsInamesInScope
(T_FieldDeclaration_vOut46 _lhsOcounter _lhsOself _lhsOunboundNames) <- return (inv_FieldDeclaration_s47 sem arg)
return (Syn_FieldDeclaration _lhsOcounter _lhsOself _lhsOunboundNames)
)
-- cata
{-# INLINE sem_FieldDeclaration #-}
sem_FieldDeclaration :: FieldDeclaration -> T_FieldDeclaration
sem_FieldDeclaration ( FieldDeclaration_FieldDeclaration range_ names_ type_ ) = sem_FieldDeclaration_FieldDeclaration ( sem_Range range_ ) ( sem_Names names_ ) ( sem_AnnotatedType type_ )
-- semantic domain
newtype T_FieldDeclaration = T_FieldDeclaration {
attach_T_FieldDeclaration :: Identity (T_FieldDeclaration_s47 )
}
newtype T_FieldDeclaration_s47 = C_FieldDeclaration_s47 {
inv_FieldDeclaration_s47 :: (T_FieldDeclaration_v46 )
}
data T_FieldDeclaration_s48 = C_FieldDeclaration_s48
type T_FieldDeclaration_v46 = (T_FieldDeclaration_vIn46 ) -> (T_FieldDeclaration_vOut46 )
data T_FieldDeclaration_vIn46 = T_FieldDeclaration_vIn46 (Int) (Names)
data T_FieldDeclaration_vOut46 = T_FieldDeclaration_vOut46 (Int) (FieldDeclaration) (Names)
{-# NOINLINE sem_FieldDeclaration_FieldDeclaration #-}
sem_FieldDeclaration_FieldDeclaration :: T_Range -> T_Names -> T_AnnotatedType -> T_FieldDeclaration
sem_FieldDeclaration_FieldDeclaration arg_range_ arg_names_ arg_type_ = T_FieldDeclaration (return st47) where
{-# NOINLINE st47 #-}
st47 = let
v46 :: T_FieldDeclaration_v46
v46 = \ (T_FieldDeclaration_vIn46 _lhsIcounter _lhsInamesInScope) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_namesX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_names_))
_typeX8 = Control.Monad.Identity.runIdentity (attach_T_AnnotatedType (arg_type_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Names_vOut115 _namesIself) = inv_Names_s116 _namesX116 (T_Names_vIn115 )
(T_AnnotatedType_vOut7 _typeIcounter _typeIself _typeIunboundNames) = inv_AnnotatedType_s8 _typeX8 (T_AnnotatedType_vIn7 _typeOcounter _typeOnamesInScope)
(_kindErrors,_tyconEnv,_constructorenv,_importEnvironment,_valueConstructors,_allValueConstructors,_typeConstructors,_allTypeConstructors,_warnings) = rule2021 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2022 _typeIunboundNames
_self = rule2023 _namesIself _rangeIself _typeIself
_lhsOself :: FieldDeclaration
_lhsOself = rule2024 _self
_lhsOcounter :: Int
_lhsOcounter = rule2025 _typeIcounter
_typeOcounter = rule2026 _lhsIcounter
_typeOnamesInScope = rule2027 _lhsInamesInScope
__result_ = T_FieldDeclaration_vOut46 _lhsOcounter _lhsOself _lhsOunboundNames
in __result_ )
in C_FieldDeclaration_s47 v46
{-# INLINE rule2021 #-}
rule2021 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "FieldDeclaration.FieldDeclaration"
{-# INLINE rule2022 #-}
rule2022 = \ ((_typeIunboundNames) :: Names) ->
_typeIunboundNames
{-# INLINE rule2023 #-}
rule2023 = \ ((_namesIself) :: Names) ((_rangeIself) :: Range) ((_typeIself) :: AnnotatedType) ->
FieldDeclaration_FieldDeclaration _rangeIself _namesIself _typeIself
{-# INLINE rule2024 #-}
rule2024 = \ _self ->
_self
{-# INLINE rule2025 #-}
rule2025 = \ ((_typeIcounter) :: Int) ->
_typeIcounter
{-# INLINE rule2026 #-}
rule2026 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2027 #-}
rule2027 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
-- FieldDeclarations -------------------------------------------
-- wrapper
data Inh_FieldDeclarations = Inh_FieldDeclarations { counter_Inh_FieldDeclarations :: (Int), namesInScope_Inh_FieldDeclarations :: (Names) }
data Syn_FieldDeclarations = Syn_FieldDeclarations { counter_Syn_FieldDeclarations :: (Int), self_Syn_FieldDeclarations :: (FieldDeclarations), unboundNames_Syn_FieldDeclarations :: (Names) }
{-# INLINABLE wrap_FieldDeclarations #-}
wrap_FieldDeclarations :: T_FieldDeclarations -> Inh_FieldDeclarations -> (Syn_FieldDeclarations )
wrap_FieldDeclarations (T_FieldDeclarations act) (Inh_FieldDeclarations _lhsIcounter _lhsInamesInScope) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_FieldDeclarations_vIn49 _lhsIcounter _lhsInamesInScope
(T_FieldDeclarations_vOut49 _lhsOcounter _lhsOself _lhsOunboundNames) <- return (inv_FieldDeclarations_s50 sem arg)
return (Syn_FieldDeclarations _lhsOcounter _lhsOself _lhsOunboundNames)
)
-- cata
{-# NOINLINE sem_FieldDeclarations #-}
sem_FieldDeclarations :: FieldDeclarations -> T_FieldDeclarations
sem_FieldDeclarations list = Prelude.foldr sem_FieldDeclarations_Cons sem_FieldDeclarations_Nil (Prelude.map sem_FieldDeclaration list)
-- semantic domain
newtype T_FieldDeclarations = T_FieldDeclarations {
attach_T_FieldDeclarations :: Identity (T_FieldDeclarations_s50 )
}
newtype T_FieldDeclarations_s50 = C_FieldDeclarations_s50 {
inv_FieldDeclarations_s50 :: (T_FieldDeclarations_v49 )
}
data T_FieldDeclarations_s51 = C_FieldDeclarations_s51
type T_FieldDeclarations_v49 = (T_FieldDeclarations_vIn49 ) -> (T_FieldDeclarations_vOut49 )
data T_FieldDeclarations_vIn49 = T_FieldDeclarations_vIn49 (Int) (Names)
data T_FieldDeclarations_vOut49 = T_FieldDeclarations_vOut49 (Int) (FieldDeclarations) (Names)
{-# NOINLINE sem_FieldDeclarations_Cons #-}
sem_FieldDeclarations_Cons :: T_FieldDeclaration -> T_FieldDeclarations -> T_FieldDeclarations
sem_FieldDeclarations_Cons arg_hd_ arg_tl_ = T_FieldDeclarations (return st50) where
{-# NOINLINE st50 #-}
st50 = let
v49 :: T_FieldDeclarations_v49
v49 = \ (T_FieldDeclarations_vIn49 _lhsIcounter _lhsInamesInScope) -> ( let
_hdX47 = Control.Monad.Identity.runIdentity (attach_T_FieldDeclaration (arg_hd_))
_tlX50 = Control.Monad.Identity.runIdentity (attach_T_FieldDeclarations (arg_tl_))
(T_FieldDeclaration_vOut46 _hdIcounter _hdIself _hdIunboundNames) = inv_FieldDeclaration_s47 _hdX47 (T_FieldDeclaration_vIn46 _hdOcounter _hdOnamesInScope)
(T_FieldDeclarations_vOut49 _tlIcounter _tlIself _tlIunboundNames) = inv_FieldDeclarations_s50 _tlX50 (T_FieldDeclarations_vIn49 _tlOcounter _tlOnamesInScope)
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2028 _hdIunboundNames _tlIunboundNames
_self = rule2029 _hdIself _tlIself
_lhsOself :: FieldDeclarations
_lhsOself = rule2030 _self
_lhsOcounter :: Int
_lhsOcounter = rule2031 _tlIcounter
_hdOcounter = rule2032 _lhsIcounter
_hdOnamesInScope = rule2033 _lhsInamesInScope
_tlOcounter = rule2034 _hdIcounter
_tlOnamesInScope = rule2035 _lhsInamesInScope
__result_ = T_FieldDeclarations_vOut49 _lhsOcounter _lhsOself _lhsOunboundNames
in __result_ )
in C_FieldDeclarations_s50 v49
{-# INLINE rule2028 #-}
rule2028 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
_hdIunboundNames ++ _tlIunboundNames
{-# INLINE rule2029 #-}
rule2029 = \ ((_hdIself) :: FieldDeclaration) ((_tlIself) :: FieldDeclarations) ->
(:) _hdIself _tlIself
{-# INLINE rule2030 #-}
rule2030 = \ _self ->
_self
{-# INLINE rule2031 #-}
rule2031 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule2032 #-}
rule2032 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2033 #-}
rule2033 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2034 #-}
rule2034 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule2035 #-}
rule2035 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# NOINLINE sem_FieldDeclarations_Nil #-}
sem_FieldDeclarations_Nil :: T_FieldDeclarations
sem_FieldDeclarations_Nil = T_FieldDeclarations (return st50) where
{-# NOINLINE st50 #-}
st50 = let
v49 :: T_FieldDeclarations_v49
v49 = \ (T_FieldDeclarations_vIn49 _lhsIcounter _lhsInamesInScope) -> ( let
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2036 ()
_self = rule2037 ()
_lhsOself :: FieldDeclarations
_lhsOself = rule2038 _self
_lhsOcounter :: Int
_lhsOcounter = rule2039 _lhsIcounter
__result_ = T_FieldDeclarations_vOut49 _lhsOcounter _lhsOself _lhsOunboundNames
in __result_ )
in C_FieldDeclarations_s50 v49
{-# INLINE rule2036 #-}
rule2036 = \ (_ :: ()) ->
[]
{-# INLINE rule2037 #-}
rule2037 = \ (_ :: ()) ->
[]
{-# INLINE rule2038 #-}
rule2038 = \ _self ->
_self
{-# INLINE rule2039 #-}
rule2039 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
-- Fixity ------------------------------------------------------
-- wrapper
data Inh_Fixity = Inh_Fixity { }
data Syn_Fixity = Syn_Fixity { self_Syn_Fixity :: (Fixity) }
{-# INLINABLE wrap_Fixity #-}
wrap_Fixity :: T_Fixity -> Inh_Fixity -> (Syn_Fixity )
wrap_Fixity (T_Fixity act) (Inh_Fixity ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Fixity_vIn52
(T_Fixity_vOut52 _lhsOself) <- return (inv_Fixity_s53 sem arg)
return (Syn_Fixity _lhsOself)
)
-- cata
{-# NOINLINE sem_Fixity #-}
sem_Fixity :: Fixity -> T_Fixity
sem_Fixity ( Fixity_Infixl range_ ) = sem_Fixity_Infixl ( sem_Range range_ )
sem_Fixity ( Fixity_Infixr range_ ) = sem_Fixity_Infixr ( sem_Range range_ )
sem_Fixity ( Fixity_Infix range_ ) = sem_Fixity_Infix ( sem_Range range_ )
-- semantic domain
newtype T_Fixity = T_Fixity {
attach_T_Fixity :: Identity (T_Fixity_s53 )
}
newtype T_Fixity_s53 = C_Fixity_s53 {
inv_Fixity_s53 :: (T_Fixity_v52 )
}
data T_Fixity_s54 = C_Fixity_s54
type T_Fixity_v52 = (T_Fixity_vIn52 ) -> (T_Fixity_vOut52 )
data T_Fixity_vIn52 = T_Fixity_vIn52
data T_Fixity_vOut52 = T_Fixity_vOut52 (Fixity)
{-# NOINLINE sem_Fixity_Infixl #-}
sem_Fixity_Infixl :: T_Range -> T_Fixity
sem_Fixity_Infixl arg_range_ = T_Fixity (return st53) where
{-# NOINLINE st53 #-}
st53 = let
v52 :: T_Fixity_v52
v52 = \ (T_Fixity_vIn52 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_self = rule2040 _rangeIself
_lhsOself :: Fixity
_lhsOself = rule2041 _self
__result_ = T_Fixity_vOut52 _lhsOself
in __result_ )
in C_Fixity_s53 v52
{-# INLINE rule2040 #-}
rule2040 = \ ((_rangeIself) :: Range) ->
Fixity_Infixl _rangeIself
{-# INLINE rule2041 #-}
rule2041 = \ _self ->
_self
{-# NOINLINE sem_Fixity_Infixr #-}
sem_Fixity_Infixr :: T_Range -> T_Fixity
sem_Fixity_Infixr arg_range_ = T_Fixity (return st53) where
{-# NOINLINE st53 #-}
st53 = let
v52 :: T_Fixity_v52
v52 = \ (T_Fixity_vIn52 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_self = rule2042 _rangeIself
_lhsOself :: Fixity
_lhsOself = rule2043 _self
__result_ = T_Fixity_vOut52 _lhsOself
in __result_ )
in C_Fixity_s53 v52
{-# INLINE rule2042 #-}
rule2042 = \ ((_rangeIself) :: Range) ->
Fixity_Infixr _rangeIself
{-# INLINE rule2043 #-}
rule2043 = \ _self ->
_self
{-# NOINLINE sem_Fixity_Infix #-}
sem_Fixity_Infix :: T_Range -> T_Fixity
sem_Fixity_Infix arg_range_ = T_Fixity (return st53) where
{-# NOINLINE st53 #-}
st53 = let
v52 :: T_Fixity_v52
v52 = \ (T_Fixity_vIn52 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_self = rule2044 _rangeIself
_lhsOself :: Fixity
_lhsOself = rule2045 _self
__result_ = T_Fixity_vOut52 _lhsOself
in __result_ )
in C_Fixity_s53 v52
{-# INLINE rule2044 #-}
rule2044 = \ ((_rangeIself) :: Range) ->
Fixity_Infix _rangeIself
{-# INLINE rule2045 #-}
rule2045 = \ _self ->
_self
-- FunctionBinding ---------------------------------------------
-- wrapper
data Inh_FunctionBinding = Inh_FunctionBinding { allPatterns_Inh_FunctionBinding :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_FunctionBinding :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_FunctionBinding :: (Predicates), betaRight_Inh_FunctionBinding :: (Tp), betaUnique_Inh_FunctionBinding :: (Int), betasLeft_Inh_FunctionBinding :: (Tps), classEnvironment_Inh_FunctionBinding :: (ClassEnvironment), collectErrors_Inh_FunctionBinding :: (TypeErrors), collectWarnings_Inh_FunctionBinding :: (Warnings), counter_Inh_FunctionBinding :: (Int), currentChunk_Inh_FunctionBinding :: (Int), dictionaryEnvironment_Inh_FunctionBinding :: (DictionaryEnvironment), importEnvironment_Inh_FunctionBinding :: (ImportEnvironment), matchIO_Inh_FunctionBinding :: (IO ()), monos_Inh_FunctionBinding :: (Monos), namesInScope_Inh_FunctionBinding :: (Names), orderedTypeSynonyms_Inh_FunctionBinding :: (OrderedTypeSynonyms), parentTree_Inh_FunctionBinding :: (InfoTree), patternMatchWarnings_Inh_FunctionBinding :: ([Warning]), substitution_Inh_FunctionBinding :: (FixpointSubstitution), typeschemeMap_Inh_FunctionBinding :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_FunctionBinding :: (Int) }
data Syn_FunctionBinding = Syn_FunctionBinding { argcount_Syn_FunctionBinding :: (Int), assumptions_Syn_FunctionBinding :: (Assumptions), betaUnique_Syn_FunctionBinding :: (Int), collectErrors_Syn_FunctionBinding :: (TypeErrors), collectInstances_Syn_FunctionBinding :: ([(Name, Instance)]), collectWarnings_Syn_FunctionBinding :: (Warnings), constraints_Syn_FunctionBinding :: (ConstraintSet), counter_Syn_FunctionBinding :: (Int), dictionaryEnvironment_Syn_FunctionBinding :: (DictionaryEnvironment), elements_Syn_FunctionBinding :: ( ([PatternElement], Bool) ), infoTree_Syn_FunctionBinding :: (InfoTree), matchIO_Syn_FunctionBinding :: (IO ()), name_Syn_FunctionBinding :: (Name), numberOfPatterns_Syn_FunctionBinding :: (Int), patternMatchWarnings_Syn_FunctionBinding :: ([Warning]), self_Syn_FunctionBinding :: (FunctionBinding), unboundNames_Syn_FunctionBinding :: (Names), uniqueChunk_Syn_FunctionBinding :: (Int), unrwar_Syn_FunctionBinding :: (Warning) }
{-# INLINABLE wrap_FunctionBinding #-}
wrap_FunctionBinding :: T_FunctionBinding -> Inh_FunctionBinding -> (Syn_FunctionBinding )
wrap_FunctionBinding (T_FunctionBinding act) (Inh_FunctionBinding _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_FunctionBinding_vIn55 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
(T_FunctionBinding_vOut55 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTree _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar) <- return (inv_FunctionBinding_s56 sem arg)
return (Syn_FunctionBinding _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTree _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar)
)
-- cata
{-# NOINLINE sem_FunctionBinding #-}
sem_FunctionBinding :: FunctionBinding -> T_FunctionBinding
sem_FunctionBinding ( FunctionBinding_Hole range_ id_ ) = sem_FunctionBinding_Hole ( sem_Range range_ ) id_
sem_FunctionBinding ( FunctionBinding_Feedback range_ feedback_ functionBinding_ ) = sem_FunctionBinding_Feedback ( sem_Range range_ ) feedback_ ( sem_FunctionBinding functionBinding_ )
sem_FunctionBinding ( FunctionBinding_FunctionBinding range_ lefthandside_ righthandside_ ) = sem_FunctionBinding_FunctionBinding ( sem_Range range_ ) ( sem_LeftHandSide lefthandside_ ) ( sem_RightHandSide righthandside_ )
-- semantic domain
newtype T_FunctionBinding = T_FunctionBinding {
attach_T_FunctionBinding :: Identity (T_FunctionBinding_s56 )
}
newtype T_FunctionBinding_s56 = C_FunctionBinding_s56 {
inv_FunctionBinding_s56 :: (T_FunctionBinding_v55 )
}
data T_FunctionBinding_s57 = C_FunctionBinding_s57
type T_FunctionBinding_v55 = (T_FunctionBinding_vIn55 ) -> (T_FunctionBinding_vOut55 )
data T_FunctionBinding_vIn55 = T_FunctionBinding_vIn55 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Int) (Tps) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_FunctionBinding_vOut55 = T_FunctionBinding_vOut55 (Int) (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) ( ([PatternElement], Bool) ) (InfoTree) (IO ()) (Name) (Int) ([Warning]) (FunctionBinding) (Names) (Int) (Warning)
{-# NOINLINE sem_FunctionBinding_Hole #-}
sem_FunctionBinding_Hole :: T_Range -> (Integer) -> T_FunctionBinding
sem_FunctionBinding_Hole arg_range_ arg_id_ = T_FunctionBinding (return st56) where
{-# NOINLINE st56 #-}
st56 = let
v55 :: T_FunctionBinding_v55
v55 = \ (T_FunctionBinding_vIn55 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_assumptions = rule2046 ()
_constraints = rule2047 ()
_numberOfPatterns = rule2048 ()
_name = rule2049 ()
_localInfo = rule2050 _lhsImonos _self
_parentTree = rule2051 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2052 _parentTree
_lhsOargcount :: Int
_lhsOargcount = rule2053 ()
_lhsOelements :: ([PatternElement], Bool)
_lhsOelements = rule2054 ()
_lhsOunrwar :: Warning
_lhsOunrwar = rule2055 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2056 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2057 ()
_self = rule2058 _rangeIself arg_id_
_lhsOself :: FunctionBinding
_lhsOself = rule2059 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule2060 _assumptions
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2061 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2062 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2063 _lhsIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2064 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2065 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2066 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2067 _lhsImatchIO
_lhsOname :: Name
_lhsOname = rule2068 _name
_lhsOnumberOfPatterns :: Int
_lhsOnumberOfPatterns = rule2069 _numberOfPatterns
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2070 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2071 _lhsIuniqueChunk
__result_ = T_FunctionBinding_vOut55 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTree _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
in __result_ )
in C_FunctionBinding_s56 v55
{-# INLINE rule2046 #-}
rule2046 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule2047 #-}
rule2047 = \ (_ :: ()) ->
emptyTree
{-# INLINE rule2048 #-}
rule2048 = \ (_ :: ()) ->
0
{-# INLINE rule2049 #-}
rule2049 = \ (_ :: ()) ->
internalError "TypeInferencing.ag" "n/a" "FunctionBindings(2)"
{-# INLINE rule2050 #-}
rule2050 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_FB _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule2051 #-}
rule2051 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule2052 #-}
rule2052 = \ _parentTree ->
_parentTree
{-# INLINE rule2053 #-}
rule2053 = \ (_ :: ()) ->
0
{-# INLINE rule2054 #-}
rule2054 = \ (_ :: ()) ->
([], False)
{-# INLINE rule2055 #-}
rule2055 = \ (_ :: ()) ->
pmError "FunctionBinding_Hole.unrwar" "hole unrwar"
{-# INLINE rule2056 #-}
rule2056 = \ (_ :: ()) ->
[]
{-# INLINE rule2057 #-}
rule2057 = \ (_ :: ()) ->
[]
{-# INLINE rule2058 #-}
rule2058 = \ ((_rangeIself) :: Range) id_ ->
FunctionBinding_Hole _rangeIself id_
{-# INLINE rule2059 #-}
rule2059 = \ _self ->
_self
{-# INLINE rule2060 #-}
rule2060 = \ _assumptions ->
_assumptions
{-# INLINE rule2061 #-}
rule2061 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2062 #-}
rule2062 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2063 #-}
rule2063 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2064 #-}
rule2064 = \ _constraints ->
_constraints
{-# INLINE rule2065 #-}
rule2065 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2066 #-}
rule2066 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2067 #-}
rule2067 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2068 #-}
rule2068 = \ _name ->
_name
{-# INLINE rule2069 #-}
rule2069 = \ _numberOfPatterns ->
_numberOfPatterns
{-# INLINE rule2070 #-}
rule2070 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2071 #-}
rule2071 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_FunctionBinding_Feedback #-}
sem_FunctionBinding_Feedback :: T_Range -> (String) -> T_FunctionBinding -> T_FunctionBinding
sem_FunctionBinding_Feedback arg_range_ arg_feedback_ arg_functionBinding_ = T_FunctionBinding (return st56) where
{-# NOINLINE st56 #-}
st56 = let
v55 :: T_FunctionBinding_v55
v55 = \ (T_FunctionBinding_vIn55 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_functionBindingX56 = Control.Monad.Identity.runIdentity (attach_T_FunctionBinding (arg_functionBinding_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_FunctionBinding_vOut55 _functionBindingIargcount _functionBindingIassumptions _functionBindingIbetaUnique _functionBindingIcollectErrors _functionBindingIcollectInstances _functionBindingIcollectWarnings _functionBindingIconstraints _functionBindingIcounter _functionBindingIdictionaryEnvironment _functionBindingIelements _functionBindingIinfoTree _functionBindingImatchIO _functionBindingIname _functionBindingInumberOfPatterns _functionBindingIpatternMatchWarnings _functionBindingIself _functionBindingIunboundNames _functionBindingIuniqueChunk _functionBindingIunrwar) = inv_FunctionBinding_s56 _functionBindingX56 (T_FunctionBinding_vIn55 _functionBindingOallPatterns _functionBindingOallTypeSchemes _functionBindingOavailablePredicates _functionBindingObetaRight _functionBindingObetaUnique _functionBindingObetasLeft _functionBindingOclassEnvironment _functionBindingOcollectErrors _functionBindingOcollectWarnings _functionBindingOcounter _functionBindingOcurrentChunk _functionBindingOdictionaryEnvironment _functionBindingOimportEnvironment _functionBindingOmatchIO _functionBindingOmonos _functionBindingOnamesInScope _functionBindingOorderedTypeSynonyms _functionBindingOparentTree _functionBindingOpatternMatchWarnings _functionBindingOsubstitution _functionBindingOtypeschemeMap _functionBindingOuniqueChunk)
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2072 _functionBindingIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2073 _functionBindingIunboundNames
_self = rule2074 _functionBindingIself _rangeIself arg_feedback_
_lhsOself :: FunctionBinding
_lhsOself = rule2075 _self
_lhsOargcount :: Int
_lhsOargcount = rule2076 _functionBindingIargcount
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule2077 _functionBindingIassumptions
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2078 _functionBindingIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2079 _functionBindingIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2080 _functionBindingIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2081 _functionBindingIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule2082 _functionBindingIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2083 _functionBindingIdictionaryEnvironment
_lhsOelements :: ([PatternElement], Bool)
_lhsOelements = rule2084 _functionBindingIelements
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2085 _functionBindingIinfoTree
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2086 _functionBindingImatchIO
_lhsOname :: Name
_lhsOname = rule2087 _functionBindingIname
_lhsOnumberOfPatterns :: Int
_lhsOnumberOfPatterns = rule2088 _functionBindingInumberOfPatterns
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2089 _functionBindingIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2090 _functionBindingIuniqueChunk
_lhsOunrwar :: Warning
_lhsOunrwar = rule2091 _functionBindingIunrwar
_functionBindingOallPatterns = rule2092 _lhsIallPatterns
_functionBindingOallTypeSchemes = rule2093 _lhsIallTypeSchemes
_functionBindingOavailablePredicates = rule2094 _lhsIavailablePredicates
_functionBindingObetaRight = rule2095 _lhsIbetaRight
_functionBindingObetaUnique = rule2096 _lhsIbetaUnique
_functionBindingObetasLeft = rule2097 _lhsIbetasLeft
_functionBindingOclassEnvironment = rule2098 _lhsIclassEnvironment
_functionBindingOcollectErrors = rule2099 _lhsIcollectErrors
_functionBindingOcollectWarnings = rule2100 _lhsIcollectWarnings
_functionBindingOcounter = rule2101 _lhsIcounter
_functionBindingOcurrentChunk = rule2102 _lhsIcurrentChunk
_functionBindingOdictionaryEnvironment = rule2103 _lhsIdictionaryEnvironment
_functionBindingOimportEnvironment = rule2104 _lhsIimportEnvironment
_functionBindingOmatchIO = rule2105 _lhsImatchIO
_functionBindingOmonos = rule2106 _lhsImonos
_functionBindingOnamesInScope = rule2107 _lhsInamesInScope
_functionBindingOorderedTypeSynonyms = rule2108 _lhsIorderedTypeSynonyms
_functionBindingOparentTree = rule2109 _lhsIparentTree
_functionBindingOpatternMatchWarnings = rule2110 _lhsIpatternMatchWarnings
_functionBindingOsubstitution = rule2111 _lhsIsubstitution
_functionBindingOtypeschemeMap = rule2112 _lhsItypeschemeMap
_functionBindingOuniqueChunk = rule2113 _lhsIuniqueChunk
__result_ = T_FunctionBinding_vOut55 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTree _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
in __result_ )
in C_FunctionBinding_s56 v55
{-# INLINE rule2072 #-}
rule2072 = \ ((_functionBindingIcollectInstances) :: [(Name, Instance)]) ->
_functionBindingIcollectInstances
{-# INLINE rule2073 #-}
rule2073 = \ ((_functionBindingIunboundNames) :: Names) ->
_functionBindingIunboundNames
{-# INLINE rule2074 #-}
rule2074 = \ ((_functionBindingIself) :: FunctionBinding) ((_rangeIself) :: Range) feedback_ ->
FunctionBinding_Feedback _rangeIself feedback_ _functionBindingIself
{-# INLINE rule2075 #-}
rule2075 = \ _self ->
_self
{-# INLINE rule2076 #-}
rule2076 = \ ((_functionBindingIargcount) :: Int) ->
_functionBindingIargcount
{-# INLINE rule2077 #-}
rule2077 = \ ((_functionBindingIassumptions) :: Assumptions) ->
_functionBindingIassumptions
{-# INLINE rule2078 #-}
rule2078 = \ ((_functionBindingIbetaUnique) :: Int) ->
_functionBindingIbetaUnique
{-# INLINE rule2079 #-}
rule2079 = \ ((_functionBindingIcollectErrors) :: TypeErrors) ->
_functionBindingIcollectErrors
{-# INLINE rule2080 #-}
rule2080 = \ ((_functionBindingIcollectWarnings) :: Warnings) ->
_functionBindingIcollectWarnings
{-# INLINE rule2081 #-}
rule2081 = \ ((_functionBindingIconstraints) :: ConstraintSet) ->
_functionBindingIconstraints
{-# INLINE rule2082 #-}
rule2082 = \ ((_functionBindingIcounter) :: Int) ->
_functionBindingIcounter
{-# INLINE rule2083 #-}
rule2083 = \ ((_functionBindingIdictionaryEnvironment) :: DictionaryEnvironment) ->
_functionBindingIdictionaryEnvironment
{-# INLINE rule2084 #-}
rule2084 = \ ((_functionBindingIelements) :: ([PatternElement], Bool) ) ->
_functionBindingIelements
{-# INLINE rule2085 #-}
rule2085 = \ ((_functionBindingIinfoTree) :: InfoTree) ->
_functionBindingIinfoTree
{-# INLINE rule2086 #-}
rule2086 = \ ((_functionBindingImatchIO) :: IO ()) ->
_functionBindingImatchIO
{-# INLINE rule2087 #-}
rule2087 = \ ((_functionBindingIname) :: Name) ->
_functionBindingIname
{-# INLINE rule2088 #-}
rule2088 = \ ((_functionBindingInumberOfPatterns) :: Int) ->
_functionBindingInumberOfPatterns
{-# INLINE rule2089 #-}
rule2089 = \ ((_functionBindingIpatternMatchWarnings) :: [Warning]) ->
_functionBindingIpatternMatchWarnings
{-# INLINE rule2090 #-}
rule2090 = \ ((_functionBindingIuniqueChunk) :: Int) ->
_functionBindingIuniqueChunk
{-# INLINE rule2091 #-}
rule2091 = \ ((_functionBindingIunrwar) :: Warning) ->
_functionBindingIunrwar
{-# INLINE rule2092 #-}
rule2092 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule2093 #-}
rule2093 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule2094 #-}
rule2094 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule2095 #-}
rule2095 = \ ((_lhsIbetaRight) :: Tp) ->
_lhsIbetaRight
{-# INLINE rule2096 #-}
rule2096 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2097 #-}
rule2097 = \ ((_lhsIbetasLeft) :: Tps) ->
_lhsIbetasLeft
{-# INLINE rule2098 #-}
rule2098 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule2099 #-}
rule2099 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2100 #-}
rule2100 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2101 #-}
rule2101 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2102 #-}
rule2102 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule2103 #-}
rule2103 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2104 #-}
rule2104 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2105 #-}
rule2105 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2106 #-}
rule2106 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2107 #-}
rule2107 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2108 #-}
rule2108 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule2109 #-}
rule2109 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2110 #-}
rule2110 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2111 #-}
rule2111 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule2112 #-}
rule2112 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule2113 #-}
rule2113 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_FunctionBinding_FunctionBinding #-}
sem_FunctionBinding_FunctionBinding :: T_Range -> T_LeftHandSide -> T_RightHandSide -> T_FunctionBinding
sem_FunctionBinding_FunctionBinding arg_range_ arg_lefthandside_ arg_righthandside_ = T_FunctionBinding (return st56) where
{-# NOINLINE st56 #-}
st56 = let
v55 :: T_FunctionBinding_v55
v55 = \ (T_FunctionBinding_vIn55 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_lefthandsideX83 = Control.Monad.Identity.runIdentity (attach_T_LeftHandSide (arg_lefthandside_))
_righthandsideX149 = Control.Monad.Identity.runIdentity (attach_T_RightHandSide (arg_righthandside_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_LeftHandSide_vOut82 _lefthandsideIargcount _lefthandsideIbetaUnique _lefthandsideIbetas _lefthandsideIconstraints _lefthandsideIcounter _lefthandsideIelements _lefthandsideIenvironment _lefthandsideIinfoTrees _lefthandsideIname _lefthandsideInumberOfPatterns _lefthandsideIpatVarNames _lefthandsideIpatternMatchWarnings _lefthandsideIself _lefthandsideIunboundNames) = inv_LeftHandSide_s83 _lefthandsideX83 (T_LeftHandSide_vIn82 _lefthandsideObetaUnique _lefthandsideOcounter _lefthandsideOimportEnvironment _lefthandsideOmonos _lefthandsideOnamesInScope _lefthandsideOparentTree _lefthandsideOpatternMatchWarnings)
(T_RightHandSide_vOut148 _righthandsideIassumptions _righthandsideIbetaUnique _righthandsideIcollectErrors _righthandsideIcollectInstances _righthandsideIcollectWarnings _righthandsideIconstraints _righthandsideIcounter _righthandsideIdictionaryEnvironment _righthandsideIfallthrough _righthandsideIinfoTree _righthandsideImatchIO _righthandsideIpatternMatchWarnings _righthandsideIself _righthandsideIunboundNames _righthandsideIuniqueChunk) = inv_RightHandSide_s149 _righthandsideX149 (T_RightHandSide_vIn148 _righthandsideOallPatterns _righthandsideOallTypeSchemes _righthandsideOavailablePredicates _righthandsideObetaRight _righthandsideObetaUnique _righthandsideOclassEnvironment _righthandsideOcollectErrors _righthandsideOcollectWarnings _righthandsideOcounter _righthandsideOcurrentChunk _righthandsideOdictionaryEnvironment _righthandsideOimportEnvironment _righthandsideOmatchIO _righthandsideOmonos _righthandsideOnamesInScope _righthandsideOorderedTypeSynonyms _righthandsideOparentTree _righthandsideOpatternMatchWarnings _righthandsideOsubstitution _righthandsideOtypeschemeMap _righthandsideOuniqueChunk)
_righthandsideOmonos = rule2114 _csetBinds _lefthandsideIenvironment _lhsImonos
_constraints = rule2115 _conLeft _csetBinds _lefthandsideIconstraints _righthandsideIconstraints
_conLeft = rule2116 _cinfoLeft _lefthandsideIbetas _lhsIbetasLeft
_lhsOassumptions :: Assumptions
(_csetBinds,_lhsOassumptions) = rule2117 _cinfoBind _lefthandsideIenvironment _righthandsideIassumptions
_cinfoLeft = rule2118 _lhsIbetasLeft _lhsIparentTree _parentTree
_cinfoBind = rule2119 _lefthandsideIenvironment _parentTree
_localInfo = rule2120 _lhsImonos _self
_parentTree = rule2121 _lefthandsideIinfoTrees _lhsIparentTree _localInfo _righthandsideIinfoTree
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2122 _parentTree
(_namesInScope,_unboundNames,_scopeInfo) = rule2123 _lefthandsideIpatVarNames _lhsInamesInScope _righthandsideIunboundNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2124 _unboundNames
_lhsOunrwar :: Warning
_lhsOunrwar = rule2125 _lefthandsideIself
_lhsOelements :: ([PatternElement], Bool)
_lhsOelements = rule2126 _lefthandsideIelements _righthandsideIfallthrough
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2127 _righthandsideIcollectInstances
_self = rule2128 _lefthandsideIself _rangeIself _righthandsideIself
_lhsOself :: FunctionBinding
_lhsOself = rule2129 _self
_lhsOargcount :: Int
_lhsOargcount = rule2130 _lefthandsideIargcount
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2131 _righthandsideIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2132 _righthandsideIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2133 _righthandsideIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2134 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2135 _righthandsideIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2136 _righthandsideIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2137 _righthandsideImatchIO
_lhsOname :: Name
_lhsOname = rule2138 _lefthandsideIname
_lhsOnumberOfPatterns :: Int
_lhsOnumberOfPatterns = rule2139 _lefthandsideInumberOfPatterns
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2140 _righthandsideIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2141 _righthandsideIuniqueChunk
_lefthandsideObetaUnique = rule2142 _lhsIbetaUnique
_lefthandsideOcounter = rule2143 _lhsIcounter
_lefthandsideOimportEnvironment = rule2144 _lhsIimportEnvironment
_lefthandsideOmonos = rule2145 _lhsImonos
_lefthandsideOnamesInScope = rule2146 _namesInScope
_lefthandsideOparentTree = rule2147 _parentTree
_lefthandsideOpatternMatchWarnings = rule2148 _lhsIpatternMatchWarnings
_righthandsideOallPatterns = rule2149 _lhsIallPatterns
_righthandsideOallTypeSchemes = rule2150 _lhsIallTypeSchemes
_righthandsideOavailablePredicates = rule2151 _lhsIavailablePredicates
_righthandsideObetaRight = rule2152 _lhsIbetaRight
_righthandsideObetaUnique = rule2153 _lefthandsideIbetaUnique
_righthandsideOclassEnvironment = rule2154 _lhsIclassEnvironment
_righthandsideOcollectErrors = rule2155 _lhsIcollectErrors
_righthandsideOcollectWarnings = rule2156 _lhsIcollectWarnings
_righthandsideOcounter = rule2157 _lefthandsideIcounter
_righthandsideOcurrentChunk = rule2158 _lhsIcurrentChunk
_righthandsideOdictionaryEnvironment = rule2159 _lhsIdictionaryEnvironment
_righthandsideOimportEnvironment = rule2160 _lhsIimportEnvironment
_righthandsideOmatchIO = rule2161 _lhsImatchIO
_righthandsideOnamesInScope = rule2162 _namesInScope
_righthandsideOorderedTypeSynonyms = rule2163 _lhsIorderedTypeSynonyms
_righthandsideOparentTree = rule2164 _parentTree
_righthandsideOpatternMatchWarnings = rule2165 _lefthandsideIpatternMatchWarnings
_righthandsideOsubstitution = rule2166 _lhsIsubstitution
_righthandsideOtypeschemeMap = rule2167 _lhsItypeschemeMap
_righthandsideOuniqueChunk = rule2168 _lhsIuniqueChunk
__result_ = T_FunctionBinding_vOut55 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTree _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
in __result_ )
in C_FunctionBinding_s56 v55
{-# INLINE rule2114 #-}
rule2114 = \ _csetBinds ((_lefthandsideIenvironment) :: PatternAssumptions) ((_lhsImonos) :: Monos) ->
M.elems _lefthandsideIenvironment ++ getMonos _csetBinds ++ _lhsImonos
{-# INLINE rule2115 #-}
rule2115 = \ _conLeft _csetBinds ((_lefthandsideIconstraints) :: ConstraintSet) ((_righthandsideIconstraints) :: ConstraintSet) ->
_csetBinds .>>.
Node [ _conLeft .<. _lefthandsideIconstraints
, _righthandsideIconstraints
]
{-# INLINE rule2116 #-}
rule2116 = \ _cinfoLeft ((_lefthandsideIbetas) :: Tps) ((_lhsIbetasLeft) :: Tps) ->
zipWith3 (\t1 t2 nr -> (t1 .==. t2) (_cinfoLeft nr)) _lefthandsideIbetas _lhsIbetasLeft [0..]
{-# INLINE rule2117 #-}
rule2117 = \ _cinfoBind ((_lefthandsideIenvironment) :: PatternAssumptions) ((_righthandsideIassumptions) :: Assumptions) ->
(_lefthandsideIenvironment .===. _righthandsideIassumptions) _cinfoBind
{-# INLINE rule2118 #-}
rule2118 = \ ((_lhsIbetasLeft) :: Tps) ((_lhsIparentTree) :: InfoTree) _parentTree ->
\num ->
orphanConstraint num "pattern of function binding" _parentTree
[ Unifier (head (ftv (_lhsIbetasLeft !! num))) (ordinal True (num+1)++" pattern of function bindings", attribute _lhsIparentTree, "pattern") ]
{-# INLINE rule2119 #-}
rule2119 = \ ((_lefthandsideIenvironment) :: PatternAssumptions) _parentTree ->
\name -> variableConstraint "variable" (nameToUHA_Expr name)
[ FolkloreConstraint
, makeUnifier name "function binding" _lefthandsideIenvironment _parentTree
]
{-# INLINE rule2120 #-}
rule2120 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_FB _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule2121 #-}
rule2121 = \ ((_lefthandsideIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) _localInfo ((_righthandsideIinfoTree) :: InfoTree) ->
node _lhsIparentTree _localInfo (_lefthandsideIinfoTrees ++ [_righthandsideIinfoTree])
{-# INLINE rule2122 #-}
rule2122 = \ _parentTree ->
_parentTree
{-# INLINE rule2123 #-}
rule2123 = \ ((_lefthandsideIpatVarNames) :: Names) ((_lhsInamesInScope) :: Names) ((_righthandsideIunboundNames) :: Names) ->
changeOfScope _lefthandsideIpatVarNames _righthandsideIunboundNames _lhsInamesInScope
{-# INLINE rule2124 #-}
rule2124 = \ _unboundNames ->
_unboundNames
{-# INLINE rule2125 #-}
rule2125 = \ ((_lefthandsideIself) :: LeftHandSide) ->
UnreachablePatternLHS _lefthandsideIself
{-# INLINE rule2126 #-}
rule2126 = \ ((_lefthandsideIelements) :: [PatternElement] ) ((_righthandsideIfallthrough) :: Bool) ->
(_lefthandsideIelements, _righthandsideIfallthrough)
{-# INLINE rule2127 #-}
rule2127 = \ ((_righthandsideIcollectInstances) :: [(Name, Instance)]) ->
_righthandsideIcollectInstances
{-# INLINE rule2128 #-}
rule2128 = \ ((_lefthandsideIself) :: LeftHandSide) ((_rangeIself) :: Range) ((_righthandsideIself) :: RightHandSide) ->
FunctionBinding_FunctionBinding _rangeIself _lefthandsideIself _righthandsideIself
{-# INLINE rule2129 #-}
rule2129 = \ _self ->
_self
{-# INLINE rule2130 #-}
rule2130 = \ ((_lefthandsideIargcount) :: Int) ->
_lefthandsideIargcount
{-# INLINE rule2131 #-}
rule2131 = \ ((_righthandsideIbetaUnique) :: Int) ->
_righthandsideIbetaUnique
{-# INLINE rule2132 #-}
rule2132 = \ ((_righthandsideIcollectErrors) :: TypeErrors) ->
_righthandsideIcollectErrors
{-# INLINE rule2133 #-}
rule2133 = \ ((_righthandsideIcollectWarnings) :: Warnings) ->
_righthandsideIcollectWarnings
{-# INLINE rule2134 #-}
rule2134 = \ _constraints ->
_constraints
{-# INLINE rule2135 #-}
rule2135 = \ ((_righthandsideIcounter) :: Int) ->
_righthandsideIcounter
{-# INLINE rule2136 #-}
rule2136 = \ ((_righthandsideIdictionaryEnvironment) :: DictionaryEnvironment) ->
_righthandsideIdictionaryEnvironment
{-# INLINE rule2137 #-}
rule2137 = \ ((_righthandsideImatchIO) :: IO ()) ->
_righthandsideImatchIO
{-# INLINE rule2138 #-}
rule2138 = \ ((_lefthandsideIname) :: Name) ->
_lefthandsideIname
{-# INLINE rule2139 #-}
rule2139 = \ ((_lefthandsideInumberOfPatterns) :: Int) ->
_lefthandsideInumberOfPatterns
{-# INLINE rule2140 #-}
rule2140 = \ ((_righthandsideIpatternMatchWarnings) :: [Warning]) ->
_righthandsideIpatternMatchWarnings
{-# INLINE rule2141 #-}
rule2141 = \ ((_righthandsideIuniqueChunk) :: Int) ->
_righthandsideIuniqueChunk
{-# INLINE rule2142 #-}
rule2142 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2143 #-}
rule2143 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2144 #-}
rule2144 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2145 #-}
rule2145 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2146 #-}
rule2146 = \ _namesInScope ->
_namesInScope
{-# INLINE rule2147 #-}
rule2147 = \ _parentTree ->
_parentTree
{-# INLINE rule2148 #-}
rule2148 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2149 #-}
rule2149 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule2150 #-}
rule2150 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule2151 #-}
rule2151 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule2152 #-}
rule2152 = \ ((_lhsIbetaRight) :: Tp) ->
_lhsIbetaRight
{-# INLINE rule2153 #-}
rule2153 = \ ((_lefthandsideIbetaUnique) :: Int) ->
_lefthandsideIbetaUnique
{-# INLINE rule2154 #-}
rule2154 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule2155 #-}
rule2155 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2156 #-}
rule2156 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2157 #-}
rule2157 = \ ((_lefthandsideIcounter) :: Int) ->
_lefthandsideIcounter
{-# INLINE rule2158 #-}
rule2158 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule2159 #-}
rule2159 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2160 #-}
rule2160 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2161 #-}
rule2161 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2162 #-}
rule2162 = \ _namesInScope ->
_namesInScope
{-# INLINE rule2163 #-}
rule2163 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule2164 #-}
rule2164 = \ _parentTree ->
_parentTree
{-# INLINE rule2165 #-}
rule2165 = \ ((_lefthandsideIpatternMatchWarnings) :: [Warning]) ->
_lefthandsideIpatternMatchWarnings
{-# INLINE rule2166 #-}
rule2166 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule2167 #-}
rule2167 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule2168 #-}
rule2168 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
-- FunctionBindings --------------------------------------------
-- wrapper
data Inh_FunctionBindings = Inh_FunctionBindings { allPatterns_Inh_FunctionBindings :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_FunctionBindings :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_FunctionBindings :: (Predicates), betaRight_Inh_FunctionBindings :: (Tp), betaUnique_Inh_FunctionBindings :: (Int), betasLeft_Inh_FunctionBindings :: (Tps), classEnvironment_Inh_FunctionBindings :: (ClassEnvironment), collectErrors_Inh_FunctionBindings :: (TypeErrors), collectWarnings_Inh_FunctionBindings :: (Warnings), counter_Inh_FunctionBindings :: (Int), currentChunk_Inh_FunctionBindings :: (Int), dictionaryEnvironment_Inh_FunctionBindings :: (DictionaryEnvironment), importEnvironment_Inh_FunctionBindings :: (ImportEnvironment), matchIO_Inh_FunctionBindings :: (IO ()), monos_Inh_FunctionBindings :: (Monos), namesInScope_Inh_FunctionBindings :: (Names), orderedTypeSynonyms_Inh_FunctionBindings :: (OrderedTypeSynonyms), parentTree_Inh_FunctionBindings :: (InfoTree), patternMatchWarnings_Inh_FunctionBindings :: ([Warning]), substitution_Inh_FunctionBindings :: (FixpointSubstitution), typeschemeMap_Inh_FunctionBindings :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_FunctionBindings :: (Int) }
data Syn_FunctionBindings = Syn_FunctionBindings { argcount_Syn_FunctionBindings :: (Int), assumptions_Syn_FunctionBindings :: (Assumptions), betaUnique_Syn_FunctionBindings :: (Int), collectErrors_Syn_FunctionBindings :: (TypeErrors), collectInstances_Syn_FunctionBindings :: ([(Name, Instance)]), collectWarnings_Syn_FunctionBindings :: (Warnings), constraintslist_Syn_FunctionBindings :: (ConstraintSets), counter_Syn_FunctionBindings :: (Int), dictionaryEnvironment_Syn_FunctionBindings :: (DictionaryEnvironment), elementss_Syn_FunctionBindings :: ([([PatternElement], Bool)]), infoTrees_Syn_FunctionBindings :: (InfoTrees), matchIO_Syn_FunctionBindings :: (IO ()), name_Syn_FunctionBindings :: (Name), numberOfPatterns_Syn_FunctionBindings :: (Int), patternMatchWarnings_Syn_FunctionBindings :: ([Warning]), self_Syn_FunctionBindings :: (FunctionBindings), unboundNames_Syn_FunctionBindings :: (Names), uniqueChunk_Syn_FunctionBindings :: (Int), unrwars_Syn_FunctionBindings :: ([Warning]) }
{-# INLINABLE wrap_FunctionBindings #-}
wrap_FunctionBindings :: T_FunctionBindings -> Inh_FunctionBindings -> (Syn_FunctionBindings )
wrap_FunctionBindings (T_FunctionBindings act) (Inh_FunctionBindings _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_FunctionBindings_vIn58 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
(T_FunctionBindings_vOut58 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars) <- return (inv_FunctionBindings_s59 sem arg)
return (Syn_FunctionBindings _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars)
)
-- cata
{-# NOINLINE sem_FunctionBindings #-}
sem_FunctionBindings :: FunctionBindings -> T_FunctionBindings
sem_FunctionBindings list = Prelude.foldr sem_FunctionBindings_Cons sem_FunctionBindings_Nil (Prelude.map sem_FunctionBinding list)
-- semantic domain
newtype T_FunctionBindings = T_FunctionBindings {
attach_T_FunctionBindings :: Identity (T_FunctionBindings_s59 )
}
newtype T_FunctionBindings_s59 = C_FunctionBindings_s59 {
inv_FunctionBindings_s59 :: (T_FunctionBindings_v58 )
}
data T_FunctionBindings_s60 = C_FunctionBindings_s60
type T_FunctionBindings_v58 = (T_FunctionBindings_vIn58 ) -> (T_FunctionBindings_vOut58 )
data T_FunctionBindings_vIn58 = T_FunctionBindings_vIn58 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Int) (Tps) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_FunctionBindings_vOut58 = T_FunctionBindings_vOut58 (Int) (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSets) (Int) (DictionaryEnvironment) ([([PatternElement], Bool)]) (InfoTrees) (IO ()) (Name) (Int) ([Warning]) (FunctionBindings) (Names) (Int) ([Warning])
{-# NOINLINE sem_FunctionBindings_Cons #-}
sem_FunctionBindings_Cons :: T_FunctionBinding -> T_FunctionBindings -> T_FunctionBindings
sem_FunctionBindings_Cons arg_hd_ arg_tl_ = T_FunctionBindings (return st59) where
{-# NOINLINE st59 #-}
st59 = let
v58 :: T_FunctionBindings_v58
v58 = \ (T_FunctionBindings_vIn58 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_hdX56 = Control.Monad.Identity.runIdentity (attach_T_FunctionBinding (arg_hd_))
_tlX59 = Control.Monad.Identity.runIdentity (attach_T_FunctionBindings (arg_tl_))
(T_FunctionBinding_vOut55 _hdIargcount _hdIassumptions _hdIbetaUnique _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIconstraints _hdIcounter _hdIdictionaryEnvironment _hdIelements _hdIinfoTree _hdImatchIO _hdIname _hdInumberOfPatterns _hdIpatternMatchWarnings _hdIself _hdIunboundNames _hdIuniqueChunk _hdIunrwar) = inv_FunctionBinding_s56 _hdX56 (T_FunctionBinding_vIn55 _hdOallPatterns _hdOallTypeSchemes _hdOavailablePredicates _hdObetaRight _hdObetaUnique _hdObetasLeft _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeschemeMap _hdOuniqueChunk)
(T_FunctionBindings_vOut58 _tlIargcount _tlIassumptions _tlIbetaUnique _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIconstraintslist _tlIcounter _tlIdictionaryEnvironment _tlIelementss _tlIinfoTrees _tlImatchIO _tlIname _tlInumberOfPatterns _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk _tlIunrwars) = inv_FunctionBindings_s59 _tlX59 (T_FunctionBindings_vIn58 _tlOallPatterns _tlOallTypeSchemes _tlOavailablePredicates _tlObetaRight _tlObetaUnique _tlObetasLeft _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeschemeMap _tlOuniqueChunk)
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule2169 _hdIassumptions _tlIassumptions
_lhsOnumberOfPatterns :: Int
_lhsOnumberOfPatterns = rule2170 _hdInumberOfPatterns
_lhsOname :: Name
_lhsOname = rule2171 _hdIname
_lhsOconstraintslist :: ConstraintSets
_lhsOconstraintslist = rule2172 _hdIconstraints _tlIconstraintslist
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2173 _hdIinfoTree _tlIinfoTrees
_lhsOelementss :: [([PatternElement], Bool)]
_lhsOelementss = rule2174 _hdIelements _tlIelementss
_lhsOunrwars :: [Warning]
_lhsOunrwars = rule2175 _hdIunrwar _tlIunrwars
_lhsOargcount :: Int
_lhsOargcount = rule2176 _hdIargcount
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2177 _hdIcollectInstances _tlIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2178 _hdIunboundNames _tlIunboundNames
_self = rule2179 _hdIself _tlIself
_lhsOself :: FunctionBindings
_lhsOself = rule2180 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2181 _tlIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2182 _tlIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2183 _tlIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule2184 _tlIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2185 _tlIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2186 _tlImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2187 _tlIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2188 _tlIuniqueChunk
_hdOallPatterns = rule2189 _lhsIallPatterns
_hdOallTypeSchemes = rule2190 _lhsIallTypeSchemes
_hdOavailablePredicates = rule2191 _lhsIavailablePredicates
_hdObetaRight = rule2192 _lhsIbetaRight
_hdObetaUnique = rule2193 _lhsIbetaUnique
_hdObetasLeft = rule2194 _lhsIbetasLeft
_hdOclassEnvironment = rule2195 _lhsIclassEnvironment
_hdOcollectErrors = rule2196 _lhsIcollectErrors
_hdOcollectWarnings = rule2197 _lhsIcollectWarnings
_hdOcounter = rule2198 _lhsIcounter
_hdOcurrentChunk = rule2199 _lhsIcurrentChunk
_hdOdictionaryEnvironment = rule2200 _lhsIdictionaryEnvironment
_hdOimportEnvironment = rule2201 _lhsIimportEnvironment
_hdOmatchIO = rule2202 _lhsImatchIO
_hdOmonos = rule2203 _lhsImonos
_hdOnamesInScope = rule2204 _lhsInamesInScope
_hdOorderedTypeSynonyms = rule2205 _lhsIorderedTypeSynonyms
_hdOparentTree = rule2206 _lhsIparentTree
_hdOpatternMatchWarnings = rule2207 _lhsIpatternMatchWarnings
_hdOsubstitution = rule2208 _lhsIsubstitution
_hdOtypeschemeMap = rule2209 _lhsItypeschemeMap
_hdOuniqueChunk = rule2210 _lhsIuniqueChunk
_tlOallPatterns = rule2211 _lhsIallPatterns
_tlOallTypeSchemes = rule2212 _lhsIallTypeSchemes
_tlOavailablePredicates = rule2213 _lhsIavailablePredicates
_tlObetaRight = rule2214 _lhsIbetaRight
_tlObetaUnique = rule2215 _hdIbetaUnique
_tlObetasLeft = rule2216 _lhsIbetasLeft
_tlOclassEnvironment = rule2217 _lhsIclassEnvironment
_tlOcollectErrors = rule2218 _hdIcollectErrors
_tlOcollectWarnings = rule2219 _hdIcollectWarnings
_tlOcounter = rule2220 _hdIcounter
_tlOcurrentChunk = rule2221 _lhsIcurrentChunk
_tlOdictionaryEnvironment = rule2222 _hdIdictionaryEnvironment
_tlOimportEnvironment = rule2223 _lhsIimportEnvironment
_tlOmatchIO = rule2224 _hdImatchIO
_tlOmonos = rule2225 _lhsImonos
_tlOnamesInScope = rule2226 _lhsInamesInScope
_tlOorderedTypeSynonyms = rule2227 _lhsIorderedTypeSynonyms
_tlOparentTree = rule2228 _lhsIparentTree
_tlOpatternMatchWarnings = rule2229 _hdIpatternMatchWarnings
_tlOsubstitution = rule2230 _lhsIsubstitution
_tlOtypeschemeMap = rule2231 _lhsItypeschemeMap
_tlOuniqueChunk = rule2232 _hdIuniqueChunk
__result_ = T_FunctionBindings_vOut58 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars
in __result_ )
in C_FunctionBindings_s59 v58
{-# INLINE rule2169 #-}
rule2169 = \ ((_hdIassumptions) :: Assumptions) ((_tlIassumptions) :: Assumptions) ->
_hdIassumptions `combine` _tlIassumptions
{-# INLINE rule2170 #-}
rule2170 = \ ((_hdInumberOfPatterns) :: Int) ->
_hdInumberOfPatterns
{-# INLINE rule2171 #-}
rule2171 = \ ((_hdIname) :: Name) ->
_hdIname
{-# INLINE rule2172 #-}
rule2172 = \ ((_hdIconstraints) :: ConstraintSet) ((_tlIconstraintslist) :: ConstraintSets) ->
_hdIconstraints : _tlIconstraintslist
{-# INLINE rule2173 #-}
rule2173 = \ ((_hdIinfoTree) :: InfoTree) ((_tlIinfoTrees) :: InfoTrees) ->
_hdIinfoTree : _tlIinfoTrees
{-# INLINE rule2174 #-}
rule2174 = \ ((_hdIelements) :: ([PatternElement], Bool) ) ((_tlIelementss) :: [([PatternElement], Bool)]) ->
_hdIelements : _tlIelementss
{-# INLINE rule2175 #-}
rule2175 = \ ((_hdIunrwar) :: Warning) ((_tlIunrwars) :: [Warning]) ->
_hdIunrwar : _tlIunrwars
{-# INLINE rule2176 #-}
rule2176 = \ ((_hdIargcount) :: Int) ->
_hdIargcount
{-# INLINE rule2177 #-}
rule2177 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
_hdIcollectInstances ++ _tlIcollectInstances
{-# INLINE rule2178 #-}
rule2178 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
_hdIunboundNames ++ _tlIunboundNames
{-# INLINE rule2179 #-}
rule2179 = \ ((_hdIself) :: FunctionBinding) ((_tlIself) :: FunctionBindings) ->
(:) _hdIself _tlIself
{-# INLINE rule2180 #-}
rule2180 = \ _self ->
_self
{-# INLINE rule2181 #-}
rule2181 = \ ((_tlIbetaUnique) :: Int) ->
_tlIbetaUnique
{-# INLINE rule2182 #-}
rule2182 = \ ((_tlIcollectErrors) :: TypeErrors) ->
_tlIcollectErrors
{-# INLINE rule2183 #-}
rule2183 = \ ((_tlIcollectWarnings) :: Warnings) ->
_tlIcollectWarnings
{-# INLINE rule2184 #-}
rule2184 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule2185 #-}
rule2185 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
_tlIdictionaryEnvironment
{-# INLINE rule2186 #-}
rule2186 = \ ((_tlImatchIO) :: IO ()) ->
_tlImatchIO
{-# INLINE rule2187 #-}
rule2187 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
_tlIpatternMatchWarnings
{-# INLINE rule2188 #-}
rule2188 = \ ((_tlIuniqueChunk) :: Int) ->
_tlIuniqueChunk
{-# INLINE rule2189 #-}
rule2189 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule2190 #-}
rule2190 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule2191 #-}
rule2191 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule2192 #-}
rule2192 = \ ((_lhsIbetaRight) :: Tp) ->
_lhsIbetaRight
{-# INLINE rule2193 #-}
rule2193 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2194 #-}
rule2194 = \ ((_lhsIbetasLeft) :: Tps) ->
_lhsIbetasLeft
{-# INLINE rule2195 #-}
rule2195 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule2196 #-}
rule2196 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2197 #-}
rule2197 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2198 #-}
rule2198 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2199 #-}
rule2199 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule2200 #-}
rule2200 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2201 #-}
rule2201 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2202 #-}
rule2202 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2203 #-}
rule2203 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2204 #-}
rule2204 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2205 #-}
rule2205 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule2206 #-}
rule2206 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2207 #-}
rule2207 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2208 #-}
rule2208 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule2209 #-}
rule2209 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule2210 #-}
rule2210 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule2211 #-}
rule2211 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule2212 #-}
rule2212 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule2213 #-}
rule2213 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule2214 #-}
rule2214 = \ ((_lhsIbetaRight) :: Tp) ->
_lhsIbetaRight
{-# INLINE rule2215 #-}
rule2215 = \ ((_hdIbetaUnique) :: Int) ->
_hdIbetaUnique
{-# INLINE rule2216 #-}
rule2216 = \ ((_lhsIbetasLeft) :: Tps) ->
_lhsIbetasLeft
{-# INLINE rule2217 #-}
rule2217 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule2218 #-}
rule2218 = \ ((_hdIcollectErrors) :: TypeErrors) ->
_hdIcollectErrors
{-# INLINE rule2219 #-}
rule2219 = \ ((_hdIcollectWarnings) :: Warnings) ->
_hdIcollectWarnings
{-# INLINE rule2220 #-}
rule2220 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule2221 #-}
rule2221 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule2222 #-}
rule2222 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
_hdIdictionaryEnvironment
{-# INLINE rule2223 #-}
rule2223 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2224 #-}
rule2224 = \ ((_hdImatchIO) :: IO ()) ->
_hdImatchIO
{-# INLINE rule2225 #-}
rule2225 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2226 #-}
rule2226 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2227 #-}
rule2227 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule2228 #-}
rule2228 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2229 #-}
rule2229 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
_hdIpatternMatchWarnings
{-# INLINE rule2230 #-}
rule2230 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule2231 #-}
rule2231 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule2232 #-}
rule2232 = \ ((_hdIuniqueChunk) :: Int) ->
_hdIuniqueChunk
{-# NOINLINE sem_FunctionBindings_Nil #-}
sem_FunctionBindings_Nil :: T_FunctionBindings
sem_FunctionBindings_Nil = T_FunctionBindings (return st59) where
{-# NOINLINE st59 #-}
st59 = let
v58 :: T_FunctionBindings_v58
v58 = \ (T_FunctionBindings_vIn58 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule2233 ()
_lhsOnumberOfPatterns :: Int
_lhsOnumberOfPatterns = rule2234 ()
_lhsOname :: Name
_lhsOname = rule2235 ()
_lhsOconstraintslist :: ConstraintSets
_lhsOconstraintslist = rule2236 ()
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2237 ()
_lhsOelementss :: [([PatternElement], Bool)]
_lhsOelementss = rule2238 ()
_lhsOunrwars :: [Warning]
_lhsOunrwars = rule2239 ()
_lhsOargcount :: Int
_lhsOargcount = rule2240 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2241 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2242 ()
_self = rule2243 ()
_lhsOself :: FunctionBindings
_lhsOself = rule2244 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2245 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2246 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2247 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule2248 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2249 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2250 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2251 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2252 _lhsIuniqueChunk
__result_ = T_FunctionBindings_vOut58 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars
in __result_ )
in C_FunctionBindings_s59 v58
{-# INLINE rule2233 #-}
rule2233 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule2234 #-}
rule2234 = \ (_ :: ()) ->
internalError "TypeInferencing.ag" "n/a" "FunctionBindings(1)"
{-# INLINE rule2235 #-}
rule2235 = \ (_ :: ()) ->
internalError "TypeInferencing.ag" "n/a" "FunctionBindings(2)"
{-# INLINE rule2236 #-}
rule2236 = \ (_ :: ()) ->
[]
{-# INLINE rule2237 #-}
rule2237 = \ (_ :: ()) ->
[]
{-# INLINE rule2238 #-}
rule2238 = \ (_ :: ()) ->
[]
{-# INLINE rule2239 #-}
rule2239 = \ (_ :: ()) ->
[]
{-# INLINE rule2240 #-}
rule2240 = \ (_ :: ()) ->
pmError "FunctionBindings_Nil.argcount" "?empty list of function bindings?"
{-# INLINE rule2241 #-}
rule2241 = \ (_ :: ()) ->
[]
{-# INLINE rule2242 #-}
rule2242 = \ (_ :: ()) ->
[]
{-# INLINE rule2243 #-}
rule2243 = \ (_ :: ()) ->
[]
{-# INLINE rule2244 #-}
rule2244 = \ _self ->
_self
{-# INLINE rule2245 #-}
rule2245 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2246 #-}
rule2246 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2247 #-}
rule2247 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2248 #-}
rule2248 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2249 #-}
rule2249 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2250 #-}
rule2250 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2251 #-}
rule2251 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2252 #-}
rule2252 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
-- GuardedExpression -------------------------------------------
-- wrapper
data Inh_GuardedExpression = Inh_GuardedExpression { allPatterns_Inh_GuardedExpression :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_GuardedExpression :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_GuardedExpression :: (Predicates), betaRight_Inh_GuardedExpression :: (Tp), betaUnique_Inh_GuardedExpression :: (Int), classEnvironment_Inh_GuardedExpression :: (ClassEnvironment), collectErrors_Inh_GuardedExpression :: (TypeErrors), collectWarnings_Inh_GuardedExpression :: (Warnings), counter_Inh_GuardedExpression :: (Int), currentChunk_Inh_GuardedExpression :: (Int), dictionaryEnvironment_Inh_GuardedExpression :: (DictionaryEnvironment), importEnvironment_Inh_GuardedExpression :: (ImportEnvironment), matchIO_Inh_GuardedExpression :: (IO ()), monos_Inh_GuardedExpression :: (Monos), namesInScope_Inh_GuardedExpression :: (Names), numberOfGuards_Inh_GuardedExpression :: (Int), orderedTypeSynonyms_Inh_GuardedExpression :: (OrderedTypeSynonyms), parentTree_Inh_GuardedExpression :: (InfoTree), patternMatchWarnings_Inh_GuardedExpression :: ([Warning]), substitution_Inh_GuardedExpression :: (FixpointSubstitution), typeschemeMap_Inh_GuardedExpression :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_GuardedExpression :: (Int), uniqueSecondRound_Inh_GuardedExpression :: (Int) }
data Syn_GuardedExpression = Syn_GuardedExpression { assumptions_Syn_GuardedExpression :: (Assumptions), betaUnique_Syn_GuardedExpression :: (Int), collectErrors_Syn_GuardedExpression :: (TypeErrors), collectInstances_Syn_GuardedExpression :: ([(Name, Instance)]), collectWarnings_Syn_GuardedExpression :: (Warnings), constraints_Syn_GuardedExpression :: (ConstraintSet), counter_Syn_GuardedExpression :: (Int), dictionaryEnvironment_Syn_GuardedExpression :: (DictionaryEnvironment), fallthrough_Syn_GuardedExpression :: (Bool), infoTrees_Syn_GuardedExpression :: (InfoTrees), matchIO_Syn_GuardedExpression :: (IO ()), patternMatchWarnings_Syn_GuardedExpression :: ([Warning]), range_Syn_GuardedExpression :: (Range), self_Syn_GuardedExpression :: (GuardedExpression), unboundNames_Syn_GuardedExpression :: (Names), uniqueChunk_Syn_GuardedExpression :: (Int), uniqueSecondRound_Syn_GuardedExpression :: (Int), unrwar_Syn_GuardedExpression :: (Warning) }
{-# INLINABLE wrap_GuardedExpression #-}
wrap_GuardedExpression :: T_GuardedExpression -> Inh_GuardedExpression -> (Syn_GuardedExpression )
wrap_GuardedExpression (T_GuardedExpression act) (Inh_GuardedExpression _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_GuardedExpression_vIn61 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound
(T_GuardedExpression_vOut61 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrange _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound _lhsOunrwar) <- return (inv_GuardedExpression_s62 sem arg)
return (Syn_GuardedExpression _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrange _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound _lhsOunrwar)
)
-- cata
{-# NOINLINE sem_GuardedExpression #-}
sem_GuardedExpression :: GuardedExpression -> T_GuardedExpression
sem_GuardedExpression ( GuardedExpression_GuardedExpression range_ guard_ expression_ ) = sem_GuardedExpression_GuardedExpression ( sem_Range range_ ) ( sem_Expression guard_ ) ( sem_Expression expression_ )
-- semantic domain
newtype T_GuardedExpression = T_GuardedExpression {
attach_T_GuardedExpression :: Identity (T_GuardedExpression_s62 )
}
newtype T_GuardedExpression_s62 = C_GuardedExpression_s62 {
inv_GuardedExpression_s62 :: (T_GuardedExpression_v61 )
}
data T_GuardedExpression_s63 = C_GuardedExpression_s63
type T_GuardedExpression_v61 = (T_GuardedExpression_vIn61 ) -> (T_GuardedExpression_vOut61 )
data T_GuardedExpression_vIn61 = T_GuardedExpression_vIn61 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (Int) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int) (Int)
data T_GuardedExpression_vOut61 = T_GuardedExpression_vOut61 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (Bool) (InfoTrees) (IO ()) ([Warning]) (Range) (GuardedExpression) (Names) (Int) (Int) (Warning)
{-# NOINLINE sem_GuardedExpression_GuardedExpression #-}
sem_GuardedExpression_GuardedExpression :: T_Range -> T_Expression -> T_Expression -> T_GuardedExpression
sem_GuardedExpression_GuardedExpression arg_range_ arg_guard_ arg_expression_ = T_GuardedExpression (return st62) where
{-# NOINLINE st62 #-}
st62 = let
v61 :: T_GuardedExpression_v61
v61 = \ (T_GuardedExpression_vIn61 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_guardX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_guard_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _guardIassumptions _guardIbeta _guardIbetaUnique _guardIcollectErrors _guardIcollectInstances _guardIcollectWarnings _guardIconstraints _guardIcounter _guardIdictionaryEnvironment _guardIinfoTree _guardImatchIO _guardImatches _guardIpatternMatchWarnings _guardIself _guardIunboundNames _guardIuniqueChunk _guardIuniqueSecondRound) = inv_Expression_s41 _guardX41 (T_Expression_vIn40 _guardOallPatterns _guardOallTypeSchemes _guardOavailablePredicates _guardObetaUnique _guardOclassEnvironment _guardOcollectErrors _guardOcollectWarnings _guardOcounter _guardOcurrentChunk _guardOdictionaryEnvironment _guardOimportEnvironment _guardOmatchIO _guardOmonos _guardOnamesInScope _guardOorderedTypeSynonyms _guardOparentTree _guardOpatternMatchWarnings _guardOsubstitution _guardOtryPatterns _guardOtypeschemeMap _guardOuniqueChunk _guardOuniqueSecondRound)
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2253 _expressionIconstraints _guardIconstraints _newconExpr _newconGuard
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule2254 _expressionIassumptions _guardIassumptions
_newconGuard = rule2255 _cinfoGuard _guardIbeta
_newconExpr = rule2256 _cinfoExpr _expressionIbeta _lhsIbetaRight
_cinfoGuard = rule2257 _guardIinfoTree
_cinfoExpr = rule2258 _expressionIinfoTree _lhsIbetaRight _lhsInumberOfGuards _lhsIparentTree
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2259 _expressionIinfoTree _guardIinfoTree
_guardOtryPatterns = rule2260 ()
_expressionOtryPatterns = rule2261 ()
_lhsOfallthrough :: Bool
_lhsOfallthrough = rule2262 _guardIself
_lhsOunrwar :: Warning
_lhsOunrwar = rule2263 _guardIself _rangeIself
_lhsOrange :: Range
_lhsOrange = rule2264 _rangeIself
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2265 _expressionIcollectInstances _guardIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2266 _expressionIunboundNames _guardIunboundNames
_self = rule2267 _expressionIself _guardIself _rangeIself
_lhsOself :: GuardedExpression
_lhsOself = rule2268 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2269 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2270 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2271 _expressionIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule2272 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2273 _expressionIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2274 _expressionImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2275 _expressionIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2276 _expressionIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule2277 _expressionIuniqueSecondRound
_guardOallPatterns = rule2278 _lhsIallPatterns
_guardOallTypeSchemes = rule2279 _lhsIallTypeSchemes
_guardOavailablePredicates = rule2280 _lhsIavailablePredicates
_guardObetaUnique = rule2281 _lhsIbetaUnique
_guardOclassEnvironment = rule2282 _lhsIclassEnvironment
_guardOcollectErrors = rule2283 _lhsIcollectErrors
_guardOcollectWarnings = rule2284 _lhsIcollectWarnings
_guardOcounter = rule2285 _lhsIcounter
_guardOcurrentChunk = rule2286 _lhsIcurrentChunk
_guardOdictionaryEnvironment = rule2287 _lhsIdictionaryEnvironment
_guardOimportEnvironment = rule2288 _lhsIimportEnvironment
_guardOmatchIO = rule2289 _lhsImatchIO
_guardOmonos = rule2290 _lhsImonos
_guardOnamesInScope = rule2291 _lhsInamesInScope
_guardOorderedTypeSynonyms = rule2292 _lhsIorderedTypeSynonyms
_guardOparentTree = rule2293 _lhsIparentTree
_guardOpatternMatchWarnings = rule2294 _lhsIpatternMatchWarnings
_guardOsubstitution = rule2295 _lhsIsubstitution
_guardOtypeschemeMap = rule2296 _lhsItypeschemeMap
_guardOuniqueChunk = rule2297 _lhsIuniqueChunk
_guardOuniqueSecondRound = rule2298 _lhsIuniqueSecondRound
_expressionOallPatterns = rule2299 _lhsIallPatterns
_expressionOallTypeSchemes = rule2300 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule2301 _lhsIavailablePredicates
_expressionObetaUnique = rule2302 _guardIbetaUnique
_expressionOclassEnvironment = rule2303 _lhsIclassEnvironment
_expressionOcollectErrors = rule2304 _guardIcollectErrors
_expressionOcollectWarnings = rule2305 _guardIcollectWarnings
_expressionOcounter = rule2306 _guardIcounter
_expressionOcurrentChunk = rule2307 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule2308 _guardIdictionaryEnvironment
_expressionOimportEnvironment = rule2309 _lhsIimportEnvironment
_expressionOmatchIO = rule2310 _guardImatchIO
_expressionOmonos = rule2311 _lhsImonos
_expressionOnamesInScope = rule2312 _lhsInamesInScope
_expressionOorderedTypeSynonyms = rule2313 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule2314 _lhsIparentTree
_expressionOpatternMatchWarnings = rule2315 _guardIpatternMatchWarnings
_expressionOsubstitution = rule2316 _lhsIsubstitution
_expressionOtypeschemeMap = rule2317 _lhsItypeschemeMap
_expressionOuniqueChunk = rule2318 _guardIuniqueChunk
_expressionOuniqueSecondRound = rule2319 _guardIuniqueSecondRound
__result_ = T_GuardedExpression_vOut61 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrange _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound _lhsOunrwar
in __result_ )
in C_GuardedExpression_s62 v61
{-# INLINE rule2253 #-}
rule2253 = \ ((_expressionIconstraints) :: ConstraintSet) ((_guardIconstraints) :: ConstraintSet) _newconExpr _newconGuard ->
Node [ _newconGuard .<. _guardIconstraints
, _newconExpr .<. _expressionIconstraints
]
{-# INLINE rule2254 #-}
rule2254 = \ ((_expressionIassumptions) :: Assumptions) ((_guardIassumptions) :: Assumptions) ->
_guardIassumptions `combine` _expressionIassumptions
{-# INLINE rule2255 #-}
rule2255 = \ _cinfoGuard ((_guardIbeta) :: Tp) ->
[ (_guardIbeta .==. boolType) _cinfoGuard ]
{-# INLINE rule2256 #-}
rule2256 = \ _cinfoExpr ((_expressionIbeta) :: Tp) ((_lhsIbetaRight) :: Tp) ->
[ (_expressionIbeta .==. _lhsIbetaRight) _cinfoExpr ]
{-# INLINE rule2257 #-}
rule2257 = \ ((_guardIinfoTree) :: InfoTree) ->
resultConstraint "guard" _guardIinfoTree
[]
{-# INLINE rule2258 #-}
rule2258 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIbetaRight) :: Tp) ((_lhsInumberOfGuards) :: Int) ((_lhsIparentTree) :: InfoTree) ->
resultConstraint "guarded expression" _expressionIinfoTree $
[ HasTrustFactor 10.0 | _lhsInumberOfGuards < 2 ] ++
[ Unifier (head (ftv _lhsIbetaRight)) ("right-hand sides", attribute (skip_UHA_FB_RHS _lhsIparentTree), "right-hand side") ]
{-# INLINE rule2259 #-}
rule2259 = \ ((_expressionIinfoTree) :: InfoTree) ((_guardIinfoTree) :: InfoTree) ->
[_guardIinfoTree, _expressionIinfoTree]
{-# INLINE rule2260 #-}
rule2260 = \ (_ :: ()) ->
[]
{-# INLINE rule2261 #-}
rule2261 = \ (_ :: ()) ->
[]
{-# INLINE rule2262 #-}
rule2262 = \ ((_guardIself) :: Expression) ->
case _guardIself
of Expression_Variable _ (Name_Identifier _ _ "otherwise") -> False
Expression_Constructor _ (Name_Identifier _ _ "True" ) -> False
_ -> True
{-# INLINE rule2263 #-}
rule2263 = \ ((_guardIself) :: Expression) ((_rangeIself) :: Range) ->
UnreachableGuard _rangeIself _guardIself
{-# INLINE rule2264 #-}
rule2264 = \ ((_rangeIself) :: Range) ->
_rangeIself
{-# INLINE rule2265 #-}
rule2265 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ((_guardIcollectInstances) :: [(Name, Instance)]) ->
_guardIcollectInstances ++ _expressionIcollectInstances
{-# INLINE rule2266 #-}
rule2266 = \ ((_expressionIunboundNames) :: Names) ((_guardIunboundNames) :: Names) ->
_guardIunboundNames ++ _expressionIunboundNames
{-# INLINE rule2267 #-}
rule2267 = \ ((_expressionIself) :: Expression) ((_guardIself) :: Expression) ((_rangeIself) :: Range) ->
GuardedExpression_GuardedExpression _rangeIself _guardIself _expressionIself
{-# INLINE rule2268 #-}
rule2268 = \ _self ->
_self
{-# INLINE rule2269 #-}
rule2269 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule2270 #-}
rule2270 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule2271 #-}
rule2271 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule2272 #-}
rule2272 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule2273 #-}
rule2273 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule2274 #-}
rule2274 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule2275 #-}
rule2275 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule2276 #-}
rule2276 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule2277 #-}
rule2277 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule2278 #-}
rule2278 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule2279 #-}
rule2279 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule2280 #-}
rule2280 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule2281 #-}
rule2281 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2282 #-}
rule2282 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule2283 #-}
rule2283 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2284 #-}
rule2284 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2285 #-}
rule2285 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2286 #-}
rule2286 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule2287 #-}
rule2287 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2288 #-}
rule2288 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2289 #-}
rule2289 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2290 #-}
rule2290 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2291 #-}
rule2291 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2292 #-}
rule2292 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule2293 #-}
rule2293 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2294 #-}
rule2294 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2295 #-}
rule2295 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule2296 #-}
rule2296 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule2297 #-}
rule2297 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule2298 #-}
rule2298 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule2299 #-}
rule2299 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule2300 #-}
rule2300 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule2301 #-}
rule2301 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule2302 #-}
rule2302 = \ ((_guardIbetaUnique) :: Int) ->
_guardIbetaUnique
{-# INLINE rule2303 #-}
rule2303 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule2304 #-}
rule2304 = \ ((_guardIcollectErrors) :: TypeErrors) ->
_guardIcollectErrors
{-# INLINE rule2305 #-}
rule2305 = \ ((_guardIcollectWarnings) :: Warnings) ->
_guardIcollectWarnings
{-# INLINE rule2306 #-}
rule2306 = \ ((_guardIcounter) :: Int) ->
_guardIcounter
{-# INLINE rule2307 #-}
rule2307 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule2308 #-}
rule2308 = \ ((_guardIdictionaryEnvironment) :: DictionaryEnvironment) ->
_guardIdictionaryEnvironment
{-# INLINE rule2309 #-}
rule2309 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2310 #-}
rule2310 = \ ((_guardImatchIO) :: IO ()) ->
_guardImatchIO
{-# INLINE rule2311 #-}
rule2311 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2312 #-}
rule2312 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2313 #-}
rule2313 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule2314 #-}
rule2314 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2315 #-}
rule2315 = \ ((_guardIpatternMatchWarnings) :: [Warning]) ->
_guardIpatternMatchWarnings
{-# INLINE rule2316 #-}
rule2316 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule2317 #-}
rule2317 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule2318 #-}
rule2318 = \ ((_guardIuniqueChunk) :: Int) ->
_guardIuniqueChunk
{-# INLINE rule2319 #-}
rule2319 = \ ((_guardIuniqueSecondRound) :: Int) ->
_guardIuniqueSecondRound
-- GuardedExpressions ------------------------------------------
-- wrapper
data Inh_GuardedExpressions = Inh_GuardedExpressions { allPatterns_Inh_GuardedExpressions :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_GuardedExpressions :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_GuardedExpressions :: (Predicates), betaRight_Inh_GuardedExpressions :: (Tp), betaUnique_Inh_GuardedExpressions :: (Int), classEnvironment_Inh_GuardedExpressions :: (ClassEnvironment), collectErrors_Inh_GuardedExpressions :: (TypeErrors), collectWarnings_Inh_GuardedExpressions :: (Warnings), counter_Inh_GuardedExpressions :: (Int), currentChunk_Inh_GuardedExpressions :: (Int), dictionaryEnvironment_Inh_GuardedExpressions :: (DictionaryEnvironment), importEnvironment_Inh_GuardedExpressions :: (ImportEnvironment), matchIO_Inh_GuardedExpressions :: (IO ()), monos_Inh_GuardedExpressions :: (Monos), namesInScope_Inh_GuardedExpressions :: (Names), numberOfGuards_Inh_GuardedExpressions :: (Int), open_Inh_GuardedExpressions :: (Bool), orderedTypeSynonyms_Inh_GuardedExpressions :: (OrderedTypeSynonyms), parentTree_Inh_GuardedExpressions :: (InfoTree), patternMatchWarnings_Inh_GuardedExpressions :: ([Warning]), substitution_Inh_GuardedExpressions :: (FixpointSubstitution), typeschemeMap_Inh_GuardedExpressions :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_GuardedExpressions :: (Int), uniqueSecondRound_Inh_GuardedExpressions :: (Int) }
data Syn_GuardedExpressions = Syn_GuardedExpressions { assumptions_Syn_GuardedExpressions :: (Assumptions), betaUnique_Syn_GuardedExpressions :: (Int), collectErrors_Syn_GuardedExpressions :: (TypeErrors), collectInstances_Syn_GuardedExpressions :: ([(Name, Instance)]), collectWarnings_Syn_GuardedExpressions :: (Warnings), constraintslist_Syn_GuardedExpressions :: (ConstraintSets), counter_Syn_GuardedExpressions :: (Int), dictionaryEnvironment_Syn_GuardedExpressions :: (DictionaryEnvironment), fallthrough_Syn_GuardedExpressions :: (Bool), infoTrees_Syn_GuardedExpressions :: (InfoTrees), matchIO_Syn_GuardedExpressions :: (IO ()), patternMatchWarnings_Syn_GuardedExpressions :: ([Warning]), self_Syn_GuardedExpressions :: (GuardedExpressions), unboundNames_Syn_GuardedExpressions :: (Names), uniqueChunk_Syn_GuardedExpressions :: (Int), uniqueSecondRound_Syn_GuardedExpressions :: (Int) }
{-# INLINABLE wrap_GuardedExpressions #-}
wrap_GuardedExpressions :: T_GuardedExpressions -> Inh_GuardedExpressions -> (Syn_GuardedExpressions )
wrap_GuardedExpressions (T_GuardedExpressions act) (Inh_GuardedExpressions _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIopen _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_GuardedExpressions_vIn64 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIopen _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound
(T_GuardedExpressions_vOut64 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_GuardedExpressions_s65 sem arg)
return (Syn_GuardedExpressions _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
)
-- cata
{-# NOINLINE sem_GuardedExpressions #-}
sem_GuardedExpressions :: GuardedExpressions -> T_GuardedExpressions
sem_GuardedExpressions list = Prelude.foldr sem_GuardedExpressions_Cons sem_GuardedExpressions_Nil (Prelude.map sem_GuardedExpression list)
-- semantic domain
newtype T_GuardedExpressions = T_GuardedExpressions {
attach_T_GuardedExpressions :: Identity (T_GuardedExpressions_s65 )
}
newtype T_GuardedExpressions_s65 = C_GuardedExpressions_s65 {
inv_GuardedExpressions_s65 :: (T_GuardedExpressions_v64 )
}
data T_GuardedExpressions_s66 = C_GuardedExpressions_s66
type T_GuardedExpressions_v64 = (T_GuardedExpressions_vIn64 ) -> (T_GuardedExpressions_vOut64 )
data T_GuardedExpressions_vIn64 = T_GuardedExpressions_vIn64 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (Int) (Bool) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int) (Int)
data T_GuardedExpressions_vOut64 = T_GuardedExpressions_vOut64 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSets) (Int) (DictionaryEnvironment) (Bool) (InfoTrees) (IO ()) ([Warning]) (GuardedExpressions) (Names) (Int) (Int)
{-# NOINLINE sem_GuardedExpressions_Cons #-}
sem_GuardedExpressions_Cons :: T_GuardedExpression -> T_GuardedExpressions -> T_GuardedExpressions
sem_GuardedExpressions_Cons arg_hd_ arg_tl_ = T_GuardedExpressions (return st65) where
{-# NOINLINE st65 #-}
st65 = let
v64 :: T_GuardedExpressions_v64
v64 = \ (T_GuardedExpressions_vIn64 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIopen _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_hdX62 = Control.Monad.Identity.runIdentity (attach_T_GuardedExpression (arg_hd_))
_tlX65 = Control.Monad.Identity.runIdentity (attach_T_GuardedExpressions (arg_tl_))
(T_GuardedExpression_vOut61 _hdIassumptions _hdIbetaUnique _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIconstraints _hdIcounter _hdIdictionaryEnvironment _hdIfallthrough _hdIinfoTrees _hdImatchIO _hdIpatternMatchWarnings _hdIrange _hdIself _hdIunboundNames _hdIuniqueChunk _hdIuniqueSecondRound _hdIunrwar) = inv_GuardedExpression_s62 _hdX62 (T_GuardedExpression_vIn61 _hdOallPatterns _hdOallTypeSchemes _hdOavailablePredicates _hdObetaRight _hdObetaUnique _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOnumberOfGuards _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeschemeMap _hdOuniqueChunk _hdOuniqueSecondRound)
(T_GuardedExpressions_vOut64 _tlIassumptions _tlIbetaUnique _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIconstraintslist _tlIcounter _tlIdictionaryEnvironment _tlIfallthrough _tlIinfoTrees _tlImatchIO _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk _tlIuniqueSecondRound) = inv_GuardedExpressions_s65 _tlX65 (T_GuardedExpressions_vIn64 _tlOallPatterns _tlOallTypeSchemes _tlOavailablePredicates _tlObetaRight _tlObetaUnique _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOnumberOfGuards _tlOopen _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeschemeMap _tlOuniqueChunk _tlOuniqueSecondRound)
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule2320 _hdIassumptions _tlIassumptions
_lhsOconstraintslist :: ConstraintSets
_lhsOconstraintslist = rule2321 _hdIconstraints _tlIconstraintslist
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2322 _hdIinfoTrees _tlIinfoTrees
_lhsOfallthrough :: Bool
_lhsOfallthrough = rule2323 _hdIfallthrough _tlIfallthrough
_tlOopen = rule2324 _hdIfallthrough _lhsIopen
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2325 _hdIunrwar _lhsIopen _tlIpatternMatchWarnings
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2326 _hdIcollectInstances _tlIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2327 _hdIunboundNames _tlIunboundNames
_self = rule2328 _hdIself _tlIself
_lhsOself :: GuardedExpressions
_lhsOself = rule2329 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2330 _tlIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2331 _tlIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2332 _tlIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule2333 _tlIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2334 _tlIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2335 _tlImatchIO
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2336 _tlIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule2337 _tlIuniqueSecondRound
_hdOallPatterns = rule2338 _lhsIallPatterns
_hdOallTypeSchemes = rule2339 _lhsIallTypeSchemes
_hdOavailablePredicates = rule2340 _lhsIavailablePredicates
_hdObetaRight = rule2341 _lhsIbetaRight
_hdObetaUnique = rule2342 _lhsIbetaUnique
_hdOclassEnvironment = rule2343 _lhsIclassEnvironment
_hdOcollectErrors = rule2344 _lhsIcollectErrors
_hdOcollectWarnings = rule2345 _lhsIcollectWarnings
_hdOcounter = rule2346 _lhsIcounter
_hdOcurrentChunk = rule2347 _lhsIcurrentChunk
_hdOdictionaryEnvironment = rule2348 _lhsIdictionaryEnvironment
_hdOimportEnvironment = rule2349 _lhsIimportEnvironment
_hdOmatchIO = rule2350 _lhsImatchIO
_hdOmonos = rule2351 _lhsImonos
_hdOnamesInScope = rule2352 _lhsInamesInScope
_hdOnumberOfGuards = rule2353 _lhsInumberOfGuards
_hdOorderedTypeSynonyms = rule2354 _lhsIorderedTypeSynonyms
_hdOparentTree = rule2355 _lhsIparentTree
_hdOpatternMatchWarnings = rule2356 _lhsIpatternMatchWarnings
_hdOsubstitution = rule2357 _lhsIsubstitution
_hdOtypeschemeMap = rule2358 _lhsItypeschemeMap
_hdOuniqueChunk = rule2359 _lhsIuniqueChunk
_hdOuniqueSecondRound = rule2360 _lhsIuniqueSecondRound
_tlOallPatterns = rule2361 _lhsIallPatterns
_tlOallTypeSchemes = rule2362 _lhsIallTypeSchemes
_tlOavailablePredicates = rule2363 _lhsIavailablePredicates
_tlObetaRight = rule2364 _lhsIbetaRight
_tlObetaUnique = rule2365 _hdIbetaUnique
_tlOclassEnvironment = rule2366 _lhsIclassEnvironment
_tlOcollectErrors = rule2367 _hdIcollectErrors
_tlOcollectWarnings = rule2368 _hdIcollectWarnings
_tlOcounter = rule2369 _hdIcounter
_tlOcurrentChunk = rule2370 _lhsIcurrentChunk
_tlOdictionaryEnvironment = rule2371 _hdIdictionaryEnvironment
_tlOimportEnvironment = rule2372 _lhsIimportEnvironment
_tlOmatchIO = rule2373 _hdImatchIO
_tlOmonos = rule2374 _lhsImonos
_tlOnamesInScope = rule2375 _lhsInamesInScope
_tlOnumberOfGuards = rule2376 _lhsInumberOfGuards
_tlOorderedTypeSynonyms = rule2377 _lhsIorderedTypeSynonyms
_tlOparentTree = rule2378 _lhsIparentTree
_tlOpatternMatchWarnings = rule2379 _hdIpatternMatchWarnings
_tlOsubstitution = rule2380 _lhsIsubstitution
_tlOtypeschemeMap = rule2381 _lhsItypeschemeMap
_tlOuniqueChunk = rule2382 _hdIuniqueChunk
_tlOuniqueSecondRound = rule2383 _hdIuniqueSecondRound
__result_ = T_GuardedExpressions_vOut64 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_GuardedExpressions_s65 v64
{-# INLINE rule2320 #-}
rule2320 = \ ((_hdIassumptions) :: Assumptions) ((_tlIassumptions) :: Assumptions) ->
_hdIassumptions `combine` _tlIassumptions
{-# INLINE rule2321 #-}
rule2321 = \ ((_hdIconstraints) :: ConstraintSet) ((_tlIconstraintslist) :: ConstraintSets) ->
_hdIconstraints : _tlIconstraintslist
{-# INLINE rule2322 #-}
rule2322 = \ ((_hdIinfoTrees) :: InfoTrees) ((_tlIinfoTrees) :: InfoTrees) ->
_hdIinfoTrees ++ _tlIinfoTrees
{-# INLINE rule2323 #-}
rule2323 = \ ((_hdIfallthrough) :: Bool) ((_tlIfallthrough) :: Bool) ->
_hdIfallthrough && _tlIfallthrough
{-# INLINE rule2324 #-}
rule2324 = \ ((_hdIfallthrough) :: Bool) ((_lhsIopen) :: Bool) ->
_hdIfallthrough && _lhsIopen
{-# INLINE rule2325 #-}
rule2325 = \ ((_hdIunrwar) :: Warning) ((_lhsIopen) :: Bool) ((_tlIpatternMatchWarnings) :: [Warning]) ->
(if not _lhsIopen then [_hdIunrwar] else [])
++ _tlIpatternMatchWarnings
{-# INLINE rule2326 #-}
rule2326 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
_hdIcollectInstances ++ _tlIcollectInstances
{-# INLINE rule2327 #-}
rule2327 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
_hdIunboundNames ++ _tlIunboundNames
{-# INLINE rule2328 #-}
rule2328 = \ ((_hdIself) :: GuardedExpression) ((_tlIself) :: GuardedExpressions) ->
(:) _hdIself _tlIself
{-# INLINE rule2329 #-}
rule2329 = \ _self ->
_self
{-# INLINE rule2330 #-}
rule2330 = \ ((_tlIbetaUnique) :: Int) ->
_tlIbetaUnique
{-# INLINE rule2331 #-}
rule2331 = \ ((_tlIcollectErrors) :: TypeErrors) ->
_tlIcollectErrors
{-# INLINE rule2332 #-}
rule2332 = \ ((_tlIcollectWarnings) :: Warnings) ->
_tlIcollectWarnings
{-# INLINE rule2333 #-}
rule2333 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule2334 #-}
rule2334 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
_tlIdictionaryEnvironment
{-# INLINE rule2335 #-}
rule2335 = \ ((_tlImatchIO) :: IO ()) ->
_tlImatchIO
{-# INLINE rule2336 #-}
rule2336 = \ ((_tlIuniqueChunk) :: Int) ->
_tlIuniqueChunk
{-# INLINE rule2337 #-}
rule2337 = \ ((_tlIuniqueSecondRound) :: Int) ->
_tlIuniqueSecondRound
{-# INLINE rule2338 #-}
rule2338 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule2339 #-}
rule2339 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule2340 #-}
rule2340 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule2341 #-}
rule2341 = \ ((_lhsIbetaRight) :: Tp) ->
_lhsIbetaRight
{-# INLINE rule2342 #-}
rule2342 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2343 #-}
rule2343 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule2344 #-}
rule2344 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2345 #-}
rule2345 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2346 #-}
rule2346 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2347 #-}
rule2347 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule2348 #-}
rule2348 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2349 #-}
rule2349 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2350 #-}
rule2350 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2351 #-}
rule2351 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2352 #-}
rule2352 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2353 #-}
rule2353 = \ ((_lhsInumberOfGuards) :: Int) ->
_lhsInumberOfGuards
{-# INLINE rule2354 #-}
rule2354 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule2355 #-}
rule2355 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2356 #-}
rule2356 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2357 #-}
rule2357 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule2358 #-}
rule2358 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule2359 #-}
rule2359 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule2360 #-}
rule2360 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule2361 #-}
rule2361 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule2362 #-}
rule2362 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule2363 #-}
rule2363 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule2364 #-}
rule2364 = \ ((_lhsIbetaRight) :: Tp) ->
_lhsIbetaRight
{-# INLINE rule2365 #-}
rule2365 = \ ((_hdIbetaUnique) :: Int) ->
_hdIbetaUnique
{-# INLINE rule2366 #-}
rule2366 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule2367 #-}
rule2367 = \ ((_hdIcollectErrors) :: TypeErrors) ->
_hdIcollectErrors
{-# INLINE rule2368 #-}
rule2368 = \ ((_hdIcollectWarnings) :: Warnings) ->
_hdIcollectWarnings
{-# INLINE rule2369 #-}
rule2369 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule2370 #-}
rule2370 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule2371 #-}
rule2371 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
_hdIdictionaryEnvironment
{-# INLINE rule2372 #-}
rule2372 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2373 #-}
rule2373 = \ ((_hdImatchIO) :: IO ()) ->
_hdImatchIO
{-# INLINE rule2374 #-}
rule2374 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2375 #-}
rule2375 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2376 #-}
rule2376 = \ ((_lhsInumberOfGuards) :: Int) ->
_lhsInumberOfGuards
{-# INLINE rule2377 #-}
rule2377 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule2378 #-}
rule2378 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2379 #-}
rule2379 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
_hdIpatternMatchWarnings
{-# INLINE rule2380 #-}
rule2380 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule2381 #-}
rule2381 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule2382 #-}
rule2382 = \ ((_hdIuniqueChunk) :: Int) ->
_hdIuniqueChunk
{-# INLINE rule2383 #-}
rule2383 = \ ((_hdIuniqueSecondRound) :: Int) ->
_hdIuniqueSecondRound
{-# NOINLINE sem_GuardedExpressions_Nil #-}
sem_GuardedExpressions_Nil :: T_GuardedExpressions
sem_GuardedExpressions_Nil = T_GuardedExpressions (return st65) where
{-# NOINLINE st65 #-}
st65 = let
v64 :: T_GuardedExpressions_v64
v64 = \ (T_GuardedExpressions_vIn64 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIopen _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule2384 ()
_lhsOconstraintslist :: ConstraintSets
_lhsOconstraintslist = rule2385 ()
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2386 ()
_lhsOfallthrough :: Bool
_lhsOfallthrough = rule2387 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2388 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2389 ()
_self = rule2390 ()
_lhsOself :: GuardedExpressions
_lhsOself = rule2391 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2392 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2393 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2394 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule2395 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2396 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2397 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2398 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2399 _lhsIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule2400 _lhsIuniqueSecondRound
__result_ = T_GuardedExpressions_vOut64 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_GuardedExpressions_s65 v64
{-# INLINE rule2384 #-}
rule2384 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule2385 #-}
rule2385 = \ (_ :: ()) ->
[]
{-# INLINE rule2386 #-}
rule2386 = \ (_ :: ()) ->
[]
{-# INLINE rule2387 #-}
rule2387 = \ (_ :: ()) ->
True
{-# INLINE rule2388 #-}
rule2388 = \ (_ :: ()) ->
[]
{-# INLINE rule2389 #-}
rule2389 = \ (_ :: ()) ->
[]
{-# INLINE rule2390 #-}
rule2390 = \ (_ :: ()) ->
[]
{-# INLINE rule2391 #-}
rule2391 = \ _self ->
_self
{-# INLINE rule2392 #-}
rule2392 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2393 #-}
rule2393 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2394 #-}
rule2394 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2395 #-}
rule2395 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2396 #-}
rule2396 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2397 #-}
rule2397 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2398 #-}
rule2398 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2399 #-}
rule2399 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule2400 #-}
rule2400 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
-- Import ------------------------------------------------------
-- wrapper
data Inh_Import = Inh_Import { }
data Syn_Import = Syn_Import { self_Syn_Import :: (Import) }
{-# INLINABLE wrap_Import #-}
wrap_Import :: T_Import -> Inh_Import -> (Syn_Import )
wrap_Import (T_Import act) (Inh_Import ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Import_vIn67
(T_Import_vOut67 _lhsOself) <- return (inv_Import_s68 sem arg)
return (Syn_Import _lhsOself)
)
-- cata
{-# NOINLINE sem_Import #-}
sem_Import :: Import -> T_Import
sem_Import ( Import_Variable range_ name_ ) = sem_Import_Variable ( sem_Range range_ ) ( sem_Name name_ )
sem_Import ( Import_TypeOrClass range_ name_ names_ ) = sem_Import_TypeOrClass ( sem_Range range_ ) ( sem_Name name_ ) ( sem_MaybeNames names_ )
sem_Import ( Import_TypeOrClassComplete range_ name_ ) = sem_Import_TypeOrClassComplete ( sem_Range range_ ) ( sem_Name name_ )
-- semantic domain
newtype T_Import = T_Import {
attach_T_Import :: Identity (T_Import_s68 )
}
newtype T_Import_s68 = C_Import_s68 {
inv_Import_s68 :: (T_Import_v67 )
}
data T_Import_s69 = C_Import_s69
type T_Import_v67 = (T_Import_vIn67 ) -> (T_Import_vOut67 )
data T_Import_vIn67 = T_Import_vIn67
data T_Import_vOut67 = T_Import_vOut67 (Import)
{-# NOINLINE sem_Import_Variable #-}
sem_Import_Variable :: T_Range -> T_Name -> T_Import
sem_Import_Variable arg_range_ arg_name_ = T_Import (return st68) where
{-# NOINLINE st68 #-}
st68 = let
v67 :: T_Import_v67
v67 = \ (T_Import_vIn67 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
_self = rule2401 _nameIself _rangeIself
_lhsOself :: Import
_lhsOself = rule2402 _self
__result_ = T_Import_vOut67 _lhsOself
in __result_ )
in C_Import_s68 v67
{-# INLINE rule2401 #-}
rule2401 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
Import_Variable _rangeIself _nameIself
{-# INLINE rule2402 #-}
rule2402 = \ _self ->
_self
{-# NOINLINE sem_Import_TypeOrClass #-}
sem_Import_TypeOrClass :: T_Range -> T_Name -> T_MaybeNames -> T_Import
sem_Import_TypeOrClass arg_range_ arg_name_ arg_names_ = T_Import (return st68) where
{-# NOINLINE st68 #-}
st68 = let
v67 :: T_Import_v67
v67 = \ (T_Import_vIn67 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_namesX107 = Control.Monad.Identity.runIdentity (attach_T_MaybeNames (arg_names_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_MaybeNames_vOut106 _namesIself) = inv_MaybeNames_s107 _namesX107 (T_MaybeNames_vIn106 )
_self = rule2403 _nameIself _namesIself _rangeIself
_lhsOself :: Import
_lhsOself = rule2404 _self
__result_ = T_Import_vOut67 _lhsOself
in __result_ )
in C_Import_s68 v67
{-# INLINE rule2403 #-}
rule2403 = \ ((_nameIself) :: Name) ((_namesIself) :: MaybeNames) ((_rangeIself) :: Range) ->
Import_TypeOrClass _rangeIself _nameIself _namesIself
{-# INLINE rule2404 #-}
rule2404 = \ _self ->
_self
{-# NOINLINE sem_Import_TypeOrClassComplete #-}
sem_Import_TypeOrClassComplete :: T_Range -> T_Name -> T_Import
sem_Import_TypeOrClassComplete arg_range_ arg_name_ = T_Import (return st68) where
{-# NOINLINE st68 #-}
st68 = let
v67 :: T_Import_v67
v67 = \ (T_Import_vIn67 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
_self = rule2405 _nameIself _rangeIself
_lhsOself :: Import
_lhsOself = rule2406 _self
__result_ = T_Import_vOut67 _lhsOself
in __result_ )
in C_Import_s68 v67
{-# INLINE rule2405 #-}
rule2405 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
Import_TypeOrClassComplete _rangeIself _nameIself
{-# INLINE rule2406 #-}
rule2406 = \ _self ->
_self
-- ImportDeclaration -------------------------------------------
-- wrapper
data Inh_ImportDeclaration = Inh_ImportDeclaration { }
data Syn_ImportDeclaration = Syn_ImportDeclaration { self_Syn_ImportDeclaration :: (ImportDeclaration) }
{-# INLINABLE wrap_ImportDeclaration #-}
wrap_ImportDeclaration :: T_ImportDeclaration -> Inh_ImportDeclaration -> (Syn_ImportDeclaration )
wrap_ImportDeclaration (T_ImportDeclaration act) (Inh_ImportDeclaration ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_ImportDeclaration_vIn70
(T_ImportDeclaration_vOut70 _lhsOself) <- return (inv_ImportDeclaration_s71 sem arg)
return (Syn_ImportDeclaration _lhsOself)
)
-- cata
{-# NOINLINE sem_ImportDeclaration #-}
sem_ImportDeclaration :: ImportDeclaration -> T_ImportDeclaration
sem_ImportDeclaration ( ImportDeclaration_Import range_ qualified_ name_ asname_ importspecification_ ) = sem_ImportDeclaration_Import ( sem_Range range_ ) qualified_ ( sem_Name name_ ) ( sem_MaybeName asname_ ) ( sem_MaybeImportSpecification importspecification_ )
sem_ImportDeclaration ( ImportDeclaration_Empty range_ ) = sem_ImportDeclaration_Empty ( sem_Range range_ )
-- semantic domain
newtype T_ImportDeclaration = T_ImportDeclaration {
attach_T_ImportDeclaration :: Identity (T_ImportDeclaration_s71 )
}
newtype T_ImportDeclaration_s71 = C_ImportDeclaration_s71 {
inv_ImportDeclaration_s71 :: (T_ImportDeclaration_v70 )
}
data T_ImportDeclaration_s72 = C_ImportDeclaration_s72
type T_ImportDeclaration_v70 = (T_ImportDeclaration_vIn70 ) -> (T_ImportDeclaration_vOut70 )
data T_ImportDeclaration_vIn70 = T_ImportDeclaration_vIn70
data T_ImportDeclaration_vOut70 = T_ImportDeclaration_vOut70 (ImportDeclaration)
{-# NOINLINE sem_ImportDeclaration_Import #-}
sem_ImportDeclaration_Import :: T_Range -> (Bool) -> T_Name -> T_MaybeName -> T_MaybeImportSpecification -> T_ImportDeclaration
sem_ImportDeclaration_Import arg_range_ arg_qualified_ arg_name_ arg_asname_ arg_importspecification_ = T_ImportDeclaration (return st71) where
{-# NOINLINE st71 #-}
st71 = let
v70 :: T_ImportDeclaration_v70
v70 = \ (T_ImportDeclaration_vIn70 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_asnameX104 = Control.Monad.Identity.runIdentity (attach_T_MaybeName (arg_asname_))
_importspecificationX98 = Control.Monad.Identity.runIdentity (attach_T_MaybeImportSpecification (arg_importspecification_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_MaybeName_vOut103 _asnameIself) = inv_MaybeName_s104 _asnameX104 (T_MaybeName_vIn103 )
(T_MaybeImportSpecification_vOut97 _importspecificationIself) = inv_MaybeImportSpecification_s98 _importspecificationX98 (T_MaybeImportSpecification_vIn97 )
_self = rule2407 _asnameIself _importspecificationIself _nameIself _rangeIself arg_qualified_
_lhsOself :: ImportDeclaration
_lhsOself = rule2408 _self
__result_ = T_ImportDeclaration_vOut70 _lhsOself
in __result_ )
in C_ImportDeclaration_s71 v70
{-# INLINE rule2407 #-}
rule2407 = \ ((_asnameIself) :: MaybeName) ((_importspecificationIself) :: MaybeImportSpecification) ((_nameIself) :: Name) ((_rangeIself) :: Range) qualified_ ->
ImportDeclaration_Import _rangeIself qualified_ _nameIself _asnameIself _importspecificationIself
{-# INLINE rule2408 #-}
rule2408 = \ _self ->
_self
{-# NOINLINE sem_ImportDeclaration_Empty #-}
sem_ImportDeclaration_Empty :: T_Range -> T_ImportDeclaration
sem_ImportDeclaration_Empty arg_range_ = T_ImportDeclaration (return st71) where
{-# NOINLINE st71 #-}
st71 = let
v70 :: T_ImportDeclaration_v70
v70 = \ (T_ImportDeclaration_vIn70 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_self = rule2409 _rangeIself
_lhsOself :: ImportDeclaration
_lhsOself = rule2410 _self
__result_ = T_ImportDeclaration_vOut70 _lhsOself
in __result_ )
in C_ImportDeclaration_s71 v70
{-# INLINE rule2409 #-}
rule2409 = \ ((_rangeIself) :: Range) ->
ImportDeclaration_Empty _rangeIself
{-# INLINE rule2410 #-}
rule2410 = \ _self ->
_self
-- ImportDeclarations ------------------------------------------
-- wrapper
data Inh_ImportDeclarations = Inh_ImportDeclarations { }
data Syn_ImportDeclarations = Syn_ImportDeclarations { self_Syn_ImportDeclarations :: (ImportDeclarations) }
{-# INLINABLE wrap_ImportDeclarations #-}
wrap_ImportDeclarations :: T_ImportDeclarations -> Inh_ImportDeclarations -> (Syn_ImportDeclarations )
wrap_ImportDeclarations (T_ImportDeclarations act) (Inh_ImportDeclarations ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_ImportDeclarations_vIn73
(T_ImportDeclarations_vOut73 _lhsOself) <- return (inv_ImportDeclarations_s74 sem arg)
return (Syn_ImportDeclarations _lhsOself)
)
-- cata
{-# NOINLINE sem_ImportDeclarations #-}
sem_ImportDeclarations :: ImportDeclarations -> T_ImportDeclarations
sem_ImportDeclarations list = Prelude.foldr sem_ImportDeclarations_Cons sem_ImportDeclarations_Nil (Prelude.map sem_ImportDeclaration list)
-- semantic domain
newtype T_ImportDeclarations = T_ImportDeclarations {
attach_T_ImportDeclarations :: Identity (T_ImportDeclarations_s74 )
}
newtype T_ImportDeclarations_s74 = C_ImportDeclarations_s74 {
inv_ImportDeclarations_s74 :: (T_ImportDeclarations_v73 )
}
data T_ImportDeclarations_s75 = C_ImportDeclarations_s75
type T_ImportDeclarations_v73 = (T_ImportDeclarations_vIn73 ) -> (T_ImportDeclarations_vOut73 )
data T_ImportDeclarations_vIn73 = T_ImportDeclarations_vIn73
data T_ImportDeclarations_vOut73 = T_ImportDeclarations_vOut73 (ImportDeclarations)
{-# NOINLINE sem_ImportDeclarations_Cons #-}
sem_ImportDeclarations_Cons :: T_ImportDeclaration -> T_ImportDeclarations -> T_ImportDeclarations
sem_ImportDeclarations_Cons arg_hd_ arg_tl_ = T_ImportDeclarations (return st74) where
{-# NOINLINE st74 #-}
st74 = let
v73 :: T_ImportDeclarations_v73
v73 = \ (T_ImportDeclarations_vIn73 ) -> ( let
_hdX71 = Control.Monad.Identity.runIdentity (attach_T_ImportDeclaration (arg_hd_))
_tlX74 = Control.Monad.Identity.runIdentity (attach_T_ImportDeclarations (arg_tl_))
(T_ImportDeclaration_vOut70 _hdIself) = inv_ImportDeclaration_s71 _hdX71 (T_ImportDeclaration_vIn70 )
(T_ImportDeclarations_vOut73 _tlIself) = inv_ImportDeclarations_s74 _tlX74 (T_ImportDeclarations_vIn73 )
_self = rule2411 _hdIself _tlIself
_lhsOself :: ImportDeclarations
_lhsOself = rule2412 _self
__result_ = T_ImportDeclarations_vOut73 _lhsOself
in __result_ )
in C_ImportDeclarations_s74 v73
{-# INLINE rule2411 #-}
rule2411 = \ ((_hdIself) :: ImportDeclaration) ((_tlIself) :: ImportDeclarations) ->
(:) _hdIself _tlIself
{-# INLINE rule2412 #-}
rule2412 = \ _self ->
_self
{-# NOINLINE sem_ImportDeclarations_Nil #-}
sem_ImportDeclarations_Nil :: T_ImportDeclarations
sem_ImportDeclarations_Nil = T_ImportDeclarations (return st74) where
{-# NOINLINE st74 #-}
st74 = let
v73 :: T_ImportDeclarations_v73
v73 = \ (T_ImportDeclarations_vIn73 ) -> ( let
_self = rule2413 ()
_lhsOself :: ImportDeclarations
_lhsOself = rule2414 _self
__result_ = T_ImportDeclarations_vOut73 _lhsOself
in __result_ )
in C_ImportDeclarations_s74 v73
{-# INLINE rule2413 #-}
rule2413 = \ (_ :: ()) ->
[]
{-# INLINE rule2414 #-}
rule2414 = \ _self ->
_self
-- ImportSpecification -----------------------------------------
-- wrapper
data Inh_ImportSpecification = Inh_ImportSpecification { }
data Syn_ImportSpecification = Syn_ImportSpecification { self_Syn_ImportSpecification :: (ImportSpecification) }
{-# INLINABLE wrap_ImportSpecification #-}
wrap_ImportSpecification :: T_ImportSpecification -> Inh_ImportSpecification -> (Syn_ImportSpecification )
wrap_ImportSpecification (T_ImportSpecification act) (Inh_ImportSpecification ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_ImportSpecification_vIn76
(T_ImportSpecification_vOut76 _lhsOself) <- return (inv_ImportSpecification_s77 sem arg)
return (Syn_ImportSpecification _lhsOself)
)
-- cata
{-# INLINE sem_ImportSpecification #-}
sem_ImportSpecification :: ImportSpecification -> T_ImportSpecification
sem_ImportSpecification ( ImportSpecification_Import range_ hiding_ imports_ ) = sem_ImportSpecification_Import ( sem_Range range_ ) hiding_ ( sem_Imports imports_ )
-- semantic domain
newtype T_ImportSpecification = T_ImportSpecification {
attach_T_ImportSpecification :: Identity (T_ImportSpecification_s77 )
}
newtype T_ImportSpecification_s77 = C_ImportSpecification_s77 {
inv_ImportSpecification_s77 :: (T_ImportSpecification_v76 )
}
data T_ImportSpecification_s78 = C_ImportSpecification_s78
type T_ImportSpecification_v76 = (T_ImportSpecification_vIn76 ) -> (T_ImportSpecification_vOut76 )
data T_ImportSpecification_vIn76 = T_ImportSpecification_vIn76
data T_ImportSpecification_vOut76 = T_ImportSpecification_vOut76 (ImportSpecification)
{-# NOINLINE sem_ImportSpecification_Import #-}
sem_ImportSpecification_Import :: T_Range -> (Bool) -> T_Imports -> T_ImportSpecification
sem_ImportSpecification_Import arg_range_ arg_hiding_ arg_imports_ = T_ImportSpecification (return st77) where
{-# NOINLINE st77 #-}
st77 = let
v76 :: T_ImportSpecification_v76
v76 = \ (T_ImportSpecification_vIn76 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_importsX80 = Control.Monad.Identity.runIdentity (attach_T_Imports (arg_imports_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Imports_vOut79 _importsIself) = inv_Imports_s80 _importsX80 (T_Imports_vIn79 )
_self = rule2415 _importsIself _rangeIself arg_hiding_
_lhsOself :: ImportSpecification
_lhsOself = rule2416 _self
__result_ = T_ImportSpecification_vOut76 _lhsOself
in __result_ )
in C_ImportSpecification_s77 v76
{-# INLINE rule2415 #-}
rule2415 = \ ((_importsIself) :: Imports) ((_rangeIself) :: Range) hiding_ ->
ImportSpecification_Import _rangeIself hiding_ _importsIself
{-# INLINE rule2416 #-}
rule2416 = \ _self ->
_self
-- Imports -----------------------------------------------------
-- wrapper
data Inh_Imports = Inh_Imports { }
data Syn_Imports = Syn_Imports { self_Syn_Imports :: (Imports) }
{-# INLINABLE wrap_Imports #-}
wrap_Imports :: T_Imports -> Inh_Imports -> (Syn_Imports )
wrap_Imports (T_Imports act) (Inh_Imports ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Imports_vIn79
(T_Imports_vOut79 _lhsOself) <- return (inv_Imports_s80 sem arg)
return (Syn_Imports _lhsOself)
)
-- cata
{-# NOINLINE sem_Imports #-}
sem_Imports :: Imports -> T_Imports
sem_Imports list = Prelude.foldr sem_Imports_Cons sem_Imports_Nil (Prelude.map sem_Import list)
-- semantic domain
newtype T_Imports = T_Imports {
attach_T_Imports :: Identity (T_Imports_s80 )
}
newtype T_Imports_s80 = C_Imports_s80 {
inv_Imports_s80 :: (T_Imports_v79 )
}
data T_Imports_s81 = C_Imports_s81
type T_Imports_v79 = (T_Imports_vIn79 ) -> (T_Imports_vOut79 )
data T_Imports_vIn79 = T_Imports_vIn79
data T_Imports_vOut79 = T_Imports_vOut79 (Imports)
{-# NOINLINE sem_Imports_Cons #-}
sem_Imports_Cons :: T_Import -> T_Imports -> T_Imports
sem_Imports_Cons arg_hd_ arg_tl_ = T_Imports (return st80) where
{-# NOINLINE st80 #-}
st80 = let
v79 :: T_Imports_v79
v79 = \ (T_Imports_vIn79 ) -> ( let
_hdX68 = Control.Monad.Identity.runIdentity (attach_T_Import (arg_hd_))
_tlX80 = Control.Monad.Identity.runIdentity (attach_T_Imports (arg_tl_))
(T_Import_vOut67 _hdIself) = inv_Import_s68 _hdX68 (T_Import_vIn67 )
(T_Imports_vOut79 _tlIself) = inv_Imports_s80 _tlX80 (T_Imports_vIn79 )
_self = rule2417 _hdIself _tlIself
_lhsOself :: Imports
_lhsOself = rule2418 _self
__result_ = T_Imports_vOut79 _lhsOself
in __result_ )
in C_Imports_s80 v79
{-# INLINE rule2417 #-}
rule2417 = \ ((_hdIself) :: Import) ((_tlIself) :: Imports) ->
(:) _hdIself _tlIself
{-# INLINE rule2418 #-}
rule2418 = \ _self ->
_self
{-# NOINLINE sem_Imports_Nil #-}
sem_Imports_Nil :: T_Imports
sem_Imports_Nil = T_Imports (return st80) where
{-# NOINLINE st80 #-}
st80 = let
v79 :: T_Imports_v79
v79 = \ (T_Imports_vIn79 ) -> ( let
_self = rule2419 ()
_lhsOself :: Imports
_lhsOself = rule2420 _self
__result_ = T_Imports_vOut79 _lhsOself
in __result_ )
in C_Imports_s80 v79
{-# INLINE rule2419 #-}
rule2419 = \ (_ :: ()) ->
[]
{-# INLINE rule2420 #-}
rule2420 = \ _self ->
_self
-- LeftHandSide ------------------------------------------------
-- wrapper
data Inh_LeftHandSide = Inh_LeftHandSide { betaUnique_Inh_LeftHandSide :: (Int), counter_Inh_LeftHandSide :: (Int), importEnvironment_Inh_LeftHandSide :: (ImportEnvironment), monos_Inh_LeftHandSide :: (Monos), namesInScope_Inh_LeftHandSide :: (Names), parentTree_Inh_LeftHandSide :: (InfoTree), patternMatchWarnings_Inh_LeftHandSide :: ([Warning]) }
data Syn_LeftHandSide = Syn_LeftHandSide { argcount_Syn_LeftHandSide :: (Int), betaUnique_Syn_LeftHandSide :: (Int), betas_Syn_LeftHandSide :: (Tps), constraints_Syn_LeftHandSide :: (ConstraintSet), counter_Syn_LeftHandSide :: (Int), elements_Syn_LeftHandSide :: ( [PatternElement] ), environment_Syn_LeftHandSide :: (PatternAssumptions), infoTrees_Syn_LeftHandSide :: (InfoTrees), name_Syn_LeftHandSide :: (Name), numberOfPatterns_Syn_LeftHandSide :: (Int), patVarNames_Syn_LeftHandSide :: (Names), patternMatchWarnings_Syn_LeftHandSide :: ([Warning]), self_Syn_LeftHandSide :: (LeftHandSide), unboundNames_Syn_LeftHandSide :: (Names) }
{-# INLINABLE wrap_LeftHandSide #-}
wrap_LeftHandSide :: T_LeftHandSide -> Inh_LeftHandSide -> (Syn_LeftHandSide )
wrap_LeftHandSide (T_LeftHandSide act) (Inh_LeftHandSide _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_LeftHandSide_vIn82 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings
(T_LeftHandSide_vOut82 _lhsOargcount _lhsObetaUnique _lhsObetas _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTrees _lhsOname _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames) <- return (inv_LeftHandSide_s83 sem arg)
return (Syn_LeftHandSide _lhsOargcount _lhsObetaUnique _lhsObetas _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTrees _lhsOname _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames)
)
-- cata
{-# NOINLINE sem_LeftHandSide #-}
sem_LeftHandSide :: LeftHandSide -> T_LeftHandSide
sem_LeftHandSide ( LeftHandSide_Function range_ name_ patterns_ ) = sem_LeftHandSide_Function ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Patterns patterns_ )
sem_LeftHandSide ( LeftHandSide_Infix range_ leftPattern_ operator_ rightPattern_ ) = sem_LeftHandSide_Infix ( sem_Range range_ ) ( sem_Pattern leftPattern_ ) ( sem_Name operator_ ) ( sem_Pattern rightPattern_ )
sem_LeftHandSide ( LeftHandSide_Parenthesized range_ lefthandside_ patterns_ ) = sem_LeftHandSide_Parenthesized ( sem_Range range_ ) ( sem_LeftHandSide lefthandside_ ) ( sem_Patterns patterns_ )
-- semantic domain
newtype T_LeftHandSide = T_LeftHandSide {
attach_T_LeftHandSide :: Identity (T_LeftHandSide_s83 )
}
newtype T_LeftHandSide_s83 = C_LeftHandSide_s83 {
inv_LeftHandSide_s83 :: (T_LeftHandSide_v82 )
}
data T_LeftHandSide_s84 = C_LeftHandSide_s84
type T_LeftHandSide_v82 = (T_LeftHandSide_vIn82 ) -> (T_LeftHandSide_vOut82 )
data T_LeftHandSide_vIn82 = T_LeftHandSide_vIn82 (Int) (Int) (ImportEnvironment) (Monos) (Names) (InfoTree) ([Warning])
data T_LeftHandSide_vOut82 = T_LeftHandSide_vOut82 (Int) (Int) (Tps) (ConstraintSet) (Int) ( [PatternElement] ) (PatternAssumptions) (InfoTrees) (Name) (Int) (Names) ([Warning]) (LeftHandSide) (Names)
{-# NOINLINE sem_LeftHandSide_Function #-}
sem_LeftHandSide_Function :: T_Range -> T_Name -> T_Patterns -> T_LeftHandSide
sem_LeftHandSide_Function arg_range_ arg_name_ arg_patterns_ = T_LeftHandSide (return st83) where
{-# NOINLINE st83 #-}
st83 = let
v82 :: T_LeftHandSide_v82
v82 = \ (T_LeftHandSide_vIn82 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_patternsX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_patterns_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_Patterns_vOut121 _patternsIbetaUnique _patternsIbetas _patternsIconstraintslist _patternsIcounter _patternsIelementss _patternsIenvironment _patternsIinfoTrees _patternsInumberOfPatterns _patternsIpatVarNames _patternsIpatternMatchWarnings _patternsIself _patternsIunboundNames) = inv_Patterns_s122 _patternsX122 (T_Patterns_vIn121 _patternsObetaUnique _patternsOcounter _patternsOimportEnvironment _patternsOmonos _patternsOnamesInScope _patternsOparentTree _patternsOpatternMatchWarnings)
_lhsOname :: Name
_lhsOname = rule2421 _nameIself
_constraints = rule2422 _patternsIconstraintslist
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2423 _patternsIinfoTrees
_lhsOelements :: [PatternElement]
_lhsOelements = rule2424 _patternsIelementss
_lhsOargcount :: Int
_lhsOargcount = rule2425 _patternsIself
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2426 _patternsIpatVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2427 _patternsIunboundNames
_self = rule2428 _nameIself _patternsIself _rangeIself
_lhsOself :: LeftHandSide
_lhsOself = rule2429 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2430 _patternsIbetaUnique
_lhsObetas :: Tps
_lhsObetas = rule2431 _patternsIbetas
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2432 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2433 _patternsIcounter
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2434 _patternsIenvironment
_lhsOnumberOfPatterns :: Int
_lhsOnumberOfPatterns = rule2435 _patternsInumberOfPatterns
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2436 _patternsIpatternMatchWarnings
_patternsObetaUnique = rule2437 _lhsIbetaUnique
_patternsOcounter = rule2438 _lhsIcounter
_patternsOimportEnvironment = rule2439 _lhsIimportEnvironment
_patternsOmonos = rule2440 _lhsImonos
_patternsOnamesInScope = rule2441 _lhsInamesInScope
_patternsOparentTree = rule2442 _lhsIparentTree
_patternsOpatternMatchWarnings = rule2443 _lhsIpatternMatchWarnings
__result_ = T_LeftHandSide_vOut82 _lhsOargcount _lhsObetaUnique _lhsObetas _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTrees _lhsOname _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_LeftHandSide_s83 v82
{-# INLINE rule2421 #-}
rule2421 = \ ((_nameIself) :: Name) ->
_nameIself
{-# INLINE rule2422 #-}
rule2422 = \ ((_patternsIconstraintslist) :: ConstraintSets) ->
Node _patternsIconstraintslist
{-# INLINE rule2423 #-}
rule2423 = \ ((_patternsIinfoTrees) :: InfoTrees) ->
_patternsIinfoTrees
{-# INLINE rule2424 #-}
rule2424 = \ ((_patternsIelementss) :: [ [PatternElement] ]) ->
concat _patternsIelementss
{-# INLINE rule2425 #-}
rule2425 = \ ((_patternsIself) :: Patterns) ->
length _patternsIself
{-# INLINE rule2426 #-}
rule2426 = \ ((_patternsIpatVarNames) :: Names) ->
_patternsIpatVarNames
{-# INLINE rule2427 #-}
rule2427 = \ ((_patternsIunboundNames) :: Names) ->
_patternsIunboundNames
{-# INLINE rule2428 #-}
rule2428 = \ ((_nameIself) :: Name) ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
LeftHandSide_Function _rangeIself _nameIself _patternsIself
{-# INLINE rule2429 #-}
rule2429 = \ _self ->
_self
{-# INLINE rule2430 #-}
rule2430 = \ ((_patternsIbetaUnique) :: Int) ->
_patternsIbetaUnique
{-# INLINE rule2431 #-}
rule2431 = \ ((_patternsIbetas) :: Tps) ->
_patternsIbetas
{-# INLINE rule2432 #-}
rule2432 = \ _constraints ->
_constraints
{-# INLINE rule2433 #-}
rule2433 = \ ((_patternsIcounter) :: Int) ->
_patternsIcounter
{-# INLINE rule2434 #-}
rule2434 = \ ((_patternsIenvironment) :: PatternAssumptions) ->
_patternsIenvironment
{-# INLINE rule2435 #-}
rule2435 = \ ((_patternsInumberOfPatterns) :: Int) ->
_patternsInumberOfPatterns
{-# INLINE rule2436 #-}
rule2436 = \ ((_patternsIpatternMatchWarnings) :: [Warning]) ->
_patternsIpatternMatchWarnings
{-# INLINE rule2437 #-}
rule2437 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2438 #-}
rule2438 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2439 #-}
rule2439 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2440 #-}
rule2440 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2441 #-}
rule2441 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2442 #-}
rule2442 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2443 #-}
rule2443 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_LeftHandSide_Infix #-}
sem_LeftHandSide_Infix :: T_Range -> T_Pattern -> T_Name -> T_Pattern -> T_LeftHandSide
sem_LeftHandSide_Infix arg_range_ arg_leftPattern_ arg_operator_ arg_rightPattern_ = T_LeftHandSide (return st83) where
{-# NOINLINE st83 #-}
st83 = let
v82 :: T_LeftHandSide_v82
v82 = \ (T_LeftHandSide_vIn82 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_leftPatternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_leftPattern_))
_operatorX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_operator_))
_rightPatternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_rightPattern_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Pattern_vOut118 _leftPatternIbeta _leftPatternIbetaUnique _leftPatternIconstraints _leftPatternIcounter _leftPatternIelements _leftPatternIenvironment _leftPatternIinfoTree _leftPatternIpatVarNames _leftPatternIpatternMatchWarnings _leftPatternIself _leftPatternIunboundNames) = inv_Pattern_s119 _leftPatternX119 (T_Pattern_vIn118 _leftPatternObetaUnique _leftPatternOcounter _leftPatternOimportEnvironment _leftPatternOmonos _leftPatternOnamesInScope _leftPatternOparentTree _leftPatternOpatternMatchWarnings)
(T_Name_vOut112 _operatorIself) = inv_Name_s113 _operatorX113 (T_Name_vIn112 )
(T_Pattern_vOut118 _rightPatternIbeta _rightPatternIbetaUnique _rightPatternIconstraints _rightPatternIcounter _rightPatternIelements _rightPatternIenvironment _rightPatternIinfoTree _rightPatternIpatVarNames _rightPatternIpatternMatchWarnings _rightPatternIself _rightPatternIunboundNames) = inv_Pattern_s119 _rightPatternX119 (T_Pattern_vIn118 _rightPatternObetaUnique _rightPatternOcounter _rightPatternOimportEnvironment _rightPatternOmonos _rightPatternOnamesInScope _rightPatternOparentTree _rightPatternOpatternMatchWarnings)
_lhsOnumberOfPatterns :: Int
_lhsOnumberOfPatterns = rule2444 ()
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2445 _leftPatternIenvironment _rightPatternIenvironment
_lhsObetas :: Tps
_lhsObetas = rule2446 _leftPatternIbeta _rightPatternIbeta
_lhsOname :: Name
_lhsOname = rule2447 _operatorIself
_constraints = rule2448 _leftPatternIconstraints _rightPatternIconstraints
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2449 _leftPatternIinfoTree _rightPatternIinfoTree
_lhsOelements :: [PatternElement]
_lhsOelements = rule2450 _leftPatternIelements _rightPatternIelements
_lhsOargcount :: Int
_lhsOargcount = rule2451 ()
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2452 _leftPatternIpatVarNames _rightPatternIpatVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2453 _leftPatternIunboundNames _rightPatternIunboundNames
_self = rule2454 _leftPatternIself _operatorIself _rangeIself _rightPatternIself
_lhsOself :: LeftHandSide
_lhsOself = rule2455 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2456 _rightPatternIbetaUnique
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2457 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2458 _rightPatternIcounter
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2459 _rightPatternIpatternMatchWarnings
_leftPatternObetaUnique = rule2460 _lhsIbetaUnique
_leftPatternOcounter = rule2461 _lhsIcounter
_leftPatternOimportEnvironment = rule2462 _lhsIimportEnvironment
_leftPatternOmonos = rule2463 _lhsImonos
_leftPatternOnamesInScope = rule2464 _lhsInamesInScope
_leftPatternOparentTree = rule2465 _lhsIparentTree
_leftPatternOpatternMatchWarnings = rule2466 _lhsIpatternMatchWarnings
_rightPatternObetaUnique = rule2467 _leftPatternIbetaUnique
_rightPatternOcounter = rule2468 _leftPatternIcounter
_rightPatternOimportEnvironment = rule2469 _lhsIimportEnvironment
_rightPatternOmonos = rule2470 _lhsImonos
_rightPatternOnamesInScope = rule2471 _lhsInamesInScope
_rightPatternOparentTree = rule2472 _lhsIparentTree
_rightPatternOpatternMatchWarnings = rule2473 _leftPatternIpatternMatchWarnings
__result_ = T_LeftHandSide_vOut82 _lhsOargcount _lhsObetaUnique _lhsObetas _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTrees _lhsOname _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_LeftHandSide_s83 v82
{-# INLINE rule2444 #-}
rule2444 = \ (_ :: ()) ->
2
{-# INLINE rule2445 #-}
rule2445 = \ ((_leftPatternIenvironment) :: PatternAssumptions) ((_rightPatternIenvironment) :: PatternAssumptions) ->
_leftPatternIenvironment `M.union` _rightPatternIenvironment
{-# INLINE rule2446 #-}
rule2446 = \ ((_leftPatternIbeta) :: Tp) ((_rightPatternIbeta) :: Tp) ->
[_leftPatternIbeta,_rightPatternIbeta]
{-# INLINE rule2447 #-}
rule2447 = \ ((_operatorIself) :: Name) ->
_operatorIself
{-# INLINE rule2448 #-}
rule2448 = \ ((_leftPatternIconstraints) :: ConstraintSet) ((_rightPatternIconstraints) :: ConstraintSet) ->
Node [ _leftPatternIconstraints
, _rightPatternIconstraints
]
{-# INLINE rule2449 #-}
rule2449 = \ ((_leftPatternIinfoTree) :: InfoTree) ((_rightPatternIinfoTree) :: InfoTree) ->
[_leftPatternIinfoTree, _rightPatternIinfoTree]
{-# INLINE rule2450 #-}
rule2450 = \ ((_leftPatternIelements) :: [PatternElement] ) ((_rightPatternIelements) :: [PatternElement] ) ->
_leftPatternIelements ++ _rightPatternIelements
{-# INLINE rule2451 #-}
rule2451 = \ (_ :: ()) ->
2
{-# INLINE rule2452 #-}
rule2452 = \ ((_leftPatternIpatVarNames) :: Names) ((_rightPatternIpatVarNames) :: Names) ->
_leftPatternIpatVarNames ++ _rightPatternIpatVarNames
{-# INLINE rule2453 #-}
rule2453 = \ ((_leftPatternIunboundNames) :: Names) ((_rightPatternIunboundNames) :: Names) ->
_leftPatternIunboundNames ++ _rightPatternIunboundNames
{-# INLINE rule2454 #-}
rule2454 = \ ((_leftPatternIself) :: Pattern) ((_operatorIself) :: Name) ((_rangeIself) :: Range) ((_rightPatternIself) :: Pattern) ->
LeftHandSide_Infix _rangeIself _leftPatternIself _operatorIself _rightPatternIself
{-# INLINE rule2455 #-}
rule2455 = \ _self ->
_self
{-# INLINE rule2456 #-}
rule2456 = \ ((_rightPatternIbetaUnique) :: Int) ->
_rightPatternIbetaUnique
{-# INLINE rule2457 #-}
rule2457 = \ _constraints ->
_constraints
{-# INLINE rule2458 #-}
rule2458 = \ ((_rightPatternIcounter) :: Int) ->
_rightPatternIcounter
{-# INLINE rule2459 #-}
rule2459 = \ ((_rightPatternIpatternMatchWarnings) :: [Warning]) ->
_rightPatternIpatternMatchWarnings
{-# INLINE rule2460 #-}
rule2460 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2461 #-}
rule2461 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2462 #-}
rule2462 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2463 #-}
rule2463 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2464 #-}
rule2464 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2465 #-}
rule2465 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2466 #-}
rule2466 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2467 #-}
rule2467 = \ ((_leftPatternIbetaUnique) :: Int) ->
_leftPatternIbetaUnique
{-# INLINE rule2468 #-}
rule2468 = \ ((_leftPatternIcounter) :: Int) ->
_leftPatternIcounter
{-# INLINE rule2469 #-}
rule2469 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2470 #-}
rule2470 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2471 #-}
rule2471 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2472 #-}
rule2472 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2473 #-}
rule2473 = \ ((_leftPatternIpatternMatchWarnings) :: [Warning]) ->
_leftPatternIpatternMatchWarnings
{-# NOINLINE sem_LeftHandSide_Parenthesized #-}
sem_LeftHandSide_Parenthesized :: T_Range -> T_LeftHandSide -> T_Patterns -> T_LeftHandSide
sem_LeftHandSide_Parenthesized arg_range_ arg_lefthandside_ arg_patterns_ = T_LeftHandSide (return st83) where
{-# NOINLINE st83 #-}
st83 = let
v82 :: T_LeftHandSide_v82
v82 = \ (T_LeftHandSide_vIn82 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_lefthandsideX83 = Control.Monad.Identity.runIdentity (attach_T_LeftHandSide (arg_lefthandside_))
_patternsX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_patterns_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_LeftHandSide_vOut82 _lefthandsideIargcount _lefthandsideIbetaUnique _lefthandsideIbetas _lefthandsideIconstraints _lefthandsideIcounter _lefthandsideIelements _lefthandsideIenvironment _lefthandsideIinfoTrees _lefthandsideIname _lefthandsideInumberOfPatterns _lefthandsideIpatVarNames _lefthandsideIpatternMatchWarnings _lefthandsideIself _lefthandsideIunboundNames) = inv_LeftHandSide_s83 _lefthandsideX83 (T_LeftHandSide_vIn82 _lefthandsideObetaUnique _lefthandsideOcounter _lefthandsideOimportEnvironment _lefthandsideOmonos _lefthandsideOnamesInScope _lefthandsideOparentTree _lefthandsideOpatternMatchWarnings)
(T_Patterns_vOut121 _patternsIbetaUnique _patternsIbetas _patternsIconstraintslist _patternsIcounter _patternsIelementss _patternsIenvironment _patternsIinfoTrees _patternsInumberOfPatterns _patternsIpatVarNames _patternsIpatternMatchWarnings _patternsIself _patternsIunboundNames) = inv_Patterns_s122 _patternsX122 (T_Patterns_vIn121 _patternsObetaUnique _patternsOcounter _patternsOimportEnvironment _patternsOmonos _patternsOnamesInScope _patternsOparentTree _patternsOpatternMatchWarnings)
_lhsOnumberOfPatterns :: Int
_lhsOnumberOfPatterns = rule2474 _lefthandsideInumberOfPatterns _patternsInumberOfPatterns
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2475 _lefthandsideIenvironment _patternsIenvironment
_lhsObetas :: Tps
_lhsObetas = rule2476 _lefthandsideIbetas _patternsIbetas
_constraints = rule2477 _lefthandsideIconstraints _patternsIconstraintslist
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2478 _lefthandsideIinfoTrees _patternsIinfoTrees
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2479 _lefthandsideIpatVarNames _patternsIpatVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2480 _lefthandsideIunboundNames _patternsIunboundNames
_self = rule2481 _lefthandsideIself _patternsIself _rangeIself
_lhsOself :: LeftHandSide
_lhsOself = rule2482 _self
_lhsOargcount :: Int
_lhsOargcount = rule2483 _lefthandsideIargcount
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2484 _patternsIbetaUnique
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2485 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2486 _patternsIcounter
_lhsOelements :: [PatternElement]
_lhsOelements = rule2487 _lefthandsideIelements
_lhsOname :: Name
_lhsOname = rule2488 _lefthandsideIname
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2489 _patternsIpatternMatchWarnings
_lefthandsideObetaUnique = rule2490 _lhsIbetaUnique
_lefthandsideOcounter = rule2491 _lhsIcounter
_lefthandsideOimportEnvironment = rule2492 _lhsIimportEnvironment
_lefthandsideOmonos = rule2493 _lhsImonos
_lefthandsideOnamesInScope = rule2494 _lhsInamesInScope
_lefthandsideOparentTree = rule2495 _lhsIparentTree
_lefthandsideOpatternMatchWarnings = rule2496 _lhsIpatternMatchWarnings
_patternsObetaUnique = rule2497 _lefthandsideIbetaUnique
_patternsOcounter = rule2498 _lefthandsideIcounter
_patternsOimportEnvironment = rule2499 _lhsIimportEnvironment
_patternsOmonos = rule2500 _lhsImonos
_patternsOnamesInScope = rule2501 _lhsInamesInScope
_patternsOparentTree = rule2502 _lhsIparentTree
_patternsOpatternMatchWarnings = rule2503 _lefthandsideIpatternMatchWarnings
__result_ = T_LeftHandSide_vOut82 _lhsOargcount _lhsObetaUnique _lhsObetas _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTrees _lhsOname _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_LeftHandSide_s83 v82
{-# INLINE rule2474 #-}
rule2474 = \ ((_lefthandsideInumberOfPatterns) :: Int) ((_patternsInumberOfPatterns) :: Int) ->
_lefthandsideInumberOfPatterns + _patternsInumberOfPatterns
{-# INLINE rule2475 #-}
rule2475 = \ ((_lefthandsideIenvironment) :: PatternAssumptions) ((_patternsIenvironment) :: PatternAssumptions) ->
_lefthandsideIenvironment `M.union` _patternsIenvironment
{-# INLINE rule2476 #-}
rule2476 = \ ((_lefthandsideIbetas) :: Tps) ((_patternsIbetas) :: Tps) ->
_lefthandsideIbetas ++ _patternsIbetas
{-# INLINE rule2477 #-}
rule2477 = \ ((_lefthandsideIconstraints) :: ConstraintSet) ((_patternsIconstraintslist) :: ConstraintSets) ->
Node ( _lefthandsideIconstraints : _patternsIconstraintslist )
{-# INLINE rule2478 #-}
rule2478 = \ ((_lefthandsideIinfoTrees) :: InfoTrees) ((_patternsIinfoTrees) :: InfoTrees) ->
_lefthandsideIinfoTrees ++ _patternsIinfoTrees
{-# INLINE rule2479 #-}
rule2479 = \ ((_lefthandsideIpatVarNames) :: Names) ((_patternsIpatVarNames) :: Names) ->
_lefthandsideIpatVarNames ++ _patternsIpatVarNames
{-# INLINE rule2480 #-}
rule2480 = \ ((_lefthandsideIunboundNames) :: Names) ((_patternsIunboundNames) :: Names) ->
_lefthandsideIunboundNames ++ _patternsIunboundNames
{-# INLINE rule2481 #-}
rule2481 = \ ((_lefthandsideIself) :: LeftHandSide) ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
LeftHandSide_Parenthesized _rangeIself _lefthandsideIself _patternsIself
{-# INLINE rule2482 #-}
rule2482 = \ _self ->
_self
{-# INLINE rule2483 #-}
rule2483 = \ ((_lefthandsideIargcount) :: Int) ->
_lefthandsideIargcount
{-# INLINE rule2484 #-}
rule2484 = \ ((_patternsIbetaUnique) :: Int) ->
_patternsIbetaUnique
{-# INLINE rule2485 #-}
rule2485 = \ _constraints ->
_constraints
{-# INLINE rule2486 #-}
rule2486 = \ ((_patternsIcounter) :: Int) ->
_patternsIcounter
{-# INLINE rule2487 #-}
rule2487 = \ ((_lefthandsideIelements) :: [PatternElement] ) ->
_lefthandsideIelements
{-# INLINE rule2488 #-}
rule2488 = \ ((_lefthandsideIname) :: Name) ->
_lefthandsideIname
{-# INLINE rule2489 #-}
rule2489 = \ ((_patternsIpatternMatchWarnings) :: [Warning]) ->
_patternsIpatternMatchWarnings
{-# INLINE rule2490 #-}
rule2490 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2491 #-}
rule2491 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2492 #-}
rule2492 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2493 #-}
rule2493 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2494 #-}
rule2494 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2495 #-}
rule2495 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2496 #-}
rule2496 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2497 #-}
rule2497 = \ ((_lefthandsideIbetaUnique) :: Int) ->
_lefthandsideIbetaUnique
{-# INLINE rule2498 #-}
rule2498 = \ ((_lefthandsideIcounter) :: Int) ->
_lefthandsideIcounter
{-# INLINE rule2499 #-}
rule2499 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2500 #-}
rule2500 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2501 #-}
rule2501 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2502 #-}
rule2502 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2503 #-}
rule2503 = \ ((_lefthandsideIpatternMatchWarnings) :: [Warning]) ->
_lefthandsideIpatternMatchWarnings
-- Literal -----------------------------------------------------
-- wrapper
data Inh_Literal = Inh_Literal { }
data Syn_Literal = Syn_Literal { elements_Syn_Literal :: ( [PatternElement] ), literalType_Syn_Literal :: (Tp), self_Syn_Literal :: (Literal) }
{-# INLINABLE wrap_Literal #-}
wrap_Literal :: T_Literal -> Inh_Literal -> (Syn_Literal )
wrap_Literal (T_Literal act) (Inh_Literal ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Literal_vIn85
(T_Literal_vOut85 _lhsOelements _lhsOliteralType _lhsOself) <- return (inv_Literal_s86 sem arg)
return (Syn_Literal _lhsOelements _lhsOliteralType _lhsOself)
)
-- cata
{-# NOINLINE sem_Literal #-}
sem_Literal :: Literal -> T_Literal
sem_Literal ( Literal_Int range_ value_ ) = sem_Literal_Int ( sem_Range range_ ) value_
sem_Literal ( Literal_Char range_ value_ ) = sem_Literal_Char ( sem_Range range_ ) value_
sem_Literal ( Literal_Float range_ value_ ) = sem_Literal_Float ( sem_Range range_ ) value_
sem_Literal ( Literal_String range_ value_ ) = sem_Literal_String ( sem_Range range_ ) value_
-- semantic domain
newtype T_Literal = T_Literal {
attach_T_Literal :: Identity (T_Literal_s86 )
}
newtype T_Literal_s86 = C_Literal_s86 {
inv_Literal_s86 :: (T_Literal_v85 )
}
data T_Literal_s87 = C_Literal_s87
type T_Literal_v85 = (T_Literal_vIn85 ) -> (T_Literal_vOut85 )
data T_Literal_vIn85 = T_Literal_vIn85
data T_Literal_vOut85 = T_Literal_vOut85 ( [PatternElement] ) (Tp) (Literal)
{-# NOINLINE sem_Literal_Int #-}
sem_Literal_Int :: T_Range -> (String) -> T_Literal
sem_Literal_Int arg_range_ arg_value_ = T_Literal (return st86) where
{-# NOINLINE st86 #-}
st86 = let
v85 :: T_Literal_v85
v85 = \ (T_Literal_vIn85 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_lhsOliteralType :: Tp
_lhsOliteralType = rule2504 ()
_lhsOelements :: [PatternElement]
_lhsOelements = rule2505 arg_value_
_self = rule2506 _rangeIself arg_value_
_lhsOself :: Literal
_lhsOself = rule2507 _self
__result_ = T_Literal_vOut85 _lhsOelements _lhsOliteralType _lhsOself
in __result_ )
in C_Literal_s86 v85
{-# INLINE rule2504 #-}
rule2504 = \ (_ :: ()) ->
intType
{-# INLINE rule2505 #-}
rule2505 = \ value_ ->
[InfiniteElement value_]
{-# INLINE rule2506 #-}
rule2506 = \ ((_rangeIself) :: Range) value_ ->
Literal_Int _rangeIself value_
{-# INLINE rule2507 #-}
rule2507 = \ _self ->
_self
{-# NOINLINE sem_Literal_Char #-}
sem_Literal_Char :: T_Range -> (String) -> T_Literal
sem_Literal_Char arg_range_ arg_value_ = T_Literal (return st86) where
{-# NOINLINE st86 #-}
st86 = let
v85 :: T_Literal_v85
v85 = \ (T_Literal_vIn85 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_lhsOliteralType :: Tp
_lhsOliteralType = rule2508 ()
_lhsOelements :: [PatternElement]
_lhsOelements = rule2509 arg_value_
_self = rule2510 _rangeIself arg_value_
_lhsOself :: Literal
_lhsOself = rule2511 _self
__result_ = T_Literal_vOut85 _lhsOelements _lhsOliteralType _lhsOself
in __result_ )
in C_Literal_s86 v85
{-# INLINE rule2508 #-}
rule2508 = \ (_ :: ()) ->
charType
{-# INLINE rule2509 #-}
rule2509 = \ value_ ->
[InfiniteElement value_]
{-# INLINE rule2510 #-}
rule2510 = \ ((_rangeIself) :: Range) value_ ->
Literal_Char _rangeIself value_
{-# INLINE rule2511 #-}
rule2511 = \ _self ->
_self
{-# NOINLINE sem_Literal_Float #-}
sem_Literal_Float :: T_Range -> (String) -> T_Literal
sem_Literal_Float arg_range_ arg_value_ = T_Literal (return st86) where
{-# NOINLINE st86 #-}
st86 = let
v85 :: T_Literal_v85
v85 = \ (T_Literal_vIn85 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_lhsOliteralType :: Tp
_lhsOliteralType = rule2512 ()
_lhsOelements :: [PatternElement]
_lhsOelements = rule2513 arg_value_
_self = rule2514 _rangeIself arg_value_
_lhsOself :: Literal
_lhsOself = rule2515 _self
__result_ = T_Literal_vOut85 _lhsOelements _lhsOliteralType _lhsOself
in __result_ )
in C_Literal_s86 v85
{-# INLINE rule2512 #-}
rule2512 = \ (_ :: ()) ->
floatType
{-# INLINE rule2513 #-}
rule2513 = \ value_ ->
[InfiniteElement value_]
{-# INLINE rule2514 #-}
rule2514 = \ ((_rangeIself) :: Range) value_ ->
Literal_Float _rangeIself value_
{-# INLINE rule2515 #-}
rule2515 = \ _self ->
_self
{-# NOINLINE sem_Literal_String #-}
sem_Literal_String :: T_Range -> (String) -> T_Literal
sem_Literal_String arg_range_ arg_value_ = T_Literal (return st86) where
{-# NOINLINE st86 #-}
st86 = let
v85 :: T_Literal_v85
v85 = \ (T_Literal_vIn85 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_lhsOliteralType :: Tp
_lhsOliteralType = rule2516 ()
_lhsOelements :: [PatternElement]
_lhsOelements = rule2517 arg_value_
_self = rule2518 _rangeIself arg_value_
_lhsOself :: Literal
_lhsOself = rule2519 _self
__result_ = T_Literal_vOut85 _lhsOelements _lhsOliteralType _lhsOself
in __result_ )
in C_Literal_s86 v85
{-# INLINE rule2516 #-}
rule2516 = \ (_ :: ()) ->
stringType
{-# INLINE rule2517 #-}
rule2517 = \ value_ ->
stringPat value_
{-# INLINE rule2518 #-}
rule2518 = \ ((_rangeIself) :: Range) value_ ->
Literal_String _rangeIself value_
{-# INLINE rule2519 #-}
rule2519 = \ _self ->
_self
-- MaybeDeclarations -------------------------------------------
-- wrapper
data Inh_MaybeDeclarations = Inh_MaybeDeclarations { allPatterns_Inh_MaybeDeclarations :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_MaybeDeclarations :: (M.Map NameWithRange TpScheme), assumptions_Inh_MaybeDeclarations :: (Assumptions), availablePredicates_Inh_MaybeDeclarations :: (Predicates), betaUnique_Inh_MaybeDeclarations :: (Int), classEnvironment_Inh_MaybeDeclarations :: (ClassEnvironment), collectErrors_Inh_MaybeDeclarations :: (TypeErrors), collectWarnings_Inh_MaybeDeclarations :: (Warnings), constraints_Inh_MaybeDeclarations :: (ConstraintSet), counter_Inh_MaybeDeclarations :: (Int), currentChunk_Inh_MaybeDeclarations :: (Int), dictionaryEnvironment_Inh_MaybeDeclarations :: (DictionaryEnvironment), importEnvironment_Inh_MaybeDeclarations :: (ImportEnvironment), matchIO_Inh_MaybeDeclarations :: (IO ()), monos_Inh_MaybeDeclarations :: (Monos), namesInScope_Inh_MaybeDeclarations :: (Names), orderedTypeSynonyms_Inh_MaybeDeclarations :: (OrderedTypeSynonyms), parentTree_Inh_MaybeDeclarations :: (InfoTree), patternMatchWarnings_Inh_MaybeDeclarations :: ([Warning]), substitution_Inh_MaybeDeclarations :: (FixpointSubstitution), typeschemeMap_Inh_MaybeDeclarations :: (M.Map Int (Scheme Predicates)), unboundNames_Inh_MaybeDeclarations :: (Names), uniqueChunk_Inh_MaybeDeclarations :: (Int) }
data Syn_MaybeDeclarations = Syn_MaybeDeclarations { assumptions_Syn_MaybeDeclarations :: (Assumptions), betaUnique_Syn_MaybeDeclarations :: (Int), collectErrors_Syn_MaybeDeclarations :: (TypeErrors), collectInstances_Syn_MaybeDeclarations :: ([(Name, Instance)]), collectWarnings_Syn_MaybeDeclarations :: (Warnings), constraints_Syn_MaybeDeclarations :: (ConstraintSet), counter_Syn_MaybeDeclarations :: (Int), dictionaryEnvironment_Syn_MaybeDeclarations :: (DictionaryEnvironment), infoTrees_Syn_MaybeDeclarations :: (InfoTrees), localTypes_Syn_MaybeDeclarations :: (M.Map NameWithRange TpScheme), matchIO_Syn_MaybeDeclarations :: (IO ()), namesInScope_Syn_MaybeDeclarations :: (Names), patternMatchWarnings_Syn_MaybeDeclarations :: ([Warning]), self_Syn_MaybeDeclarations :: (MaybeDeclarations), unboundNames_Syn_MaybeDeclarations :: (Names), uniqueChunk_Syn_MaybeDeclarations :: (Int) }
{-# INLINABLE wrap_MaybeDeclarations #-}
wrap_MaybeDeclarations :: T_MaybeDeclarations -> Inh_MaybeDeclarations -> (Syn_MaybeDeclarations )
wrap_MaybeDeclarations (T_MaybeDeclarations act) (Inh_MaybeDeclarations _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_MaybeDeclarations_vIn88 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk
(T_MaybeDeclarations_vOut88 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOlocalTypes _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_MaybeDeclarations_s89 sem arg)
return (Syn_MaybeDeclarations _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOlocalTypes _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk)
)
-- cata
{-# NOINLINE sem_MaybeDeclarations #-}
sem_MaybeDeclarations :: MaybeDeclarations -> T_MaybeDeclarations
sem_MaybeDeclarations ( MaybeDeclarations_Nothing ) = sem_MaybeDeclarations_Nothing
sem_MaybeDeclarations ( MaybeDeclarations_Just declarations_ ) = sem_MaybeDeclarations_Just ( sem_Declarations declarations_ )
-- semantic domain
newtype T_MaybeDeclarations = T_MaybeDeclarations {
attach_T_MaybeDeclarations :: Identity (T_MaybeDeclarations_s89 )
}
newtype T_MaybeDeclarations_s89 = C_MaybeDeclarations_s89 {
inv_MaybeDeclarations_s89 :: (T_MaybeDeclarations_v88 )
}
data T_MaybeDeclarations_s90 = C_MaybeDeclarations_s90
type T_MaybeDeclarations_v88 = (T_MaybeDeclarations_vIn88 ) -> (T_MaybeDeclarations_vOut88 )
data T_MaybeDeclarations_vIn88 = T_MaybeDeclarations_vIn88 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Assumptions) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (ConstraintSet) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Names) (Int)
data T_MaybeDeclarations_vOut88 = T_MaybeDeclarations_vOut88 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (InfoTrees) (M.Map NameWithRange TpScheme) (IO ()) (Names) ([Warning]) (MaybeDeclarations) (Names) (Int)
{-# NOINLINE sem_MaybeDeclarations_Nothing #-}
sem_MaybeDeclarations_Nothing :: T_MaybeDeclarations
sem_MaybeDeclarations_Nothing = T_MaybeDeclarations (return st89) where
{-# NOINLINE st89 #-}
st89 = let
v88 :: T_MaybeDeclarations_v88
v88 = \ (T_MaybeDeclarations_vIn88 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk) -> ( let
_lhsOlocalTypes :: M.Map NameWithRange TpScheme
_lhsOlocalTypes = rule2520 ()
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2521 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2522 ()
_self = rule2523 ()
_lhsOself :: MaybeDeclarations
_lhsOself = rule2524 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule2525 _lhsIassumptions
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2526 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2527 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2528 _lhsIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2529 _lhsIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule2530 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2531 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2532 _lhsImatchIO
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule2533 _lhsInamesInScope
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2534 _lhsIpatternMatchWarnings
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2535 _lhsIunboundNames
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2536 _lhsIuniqueChunk
__result_ = T_MaybeDeclarations_vOut88 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOlocalTypes _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_MaybeDeclarations_s89 v88
{-# INLINE rule2520 #-}
rule2520 = \ (_ :: ()) ->
M.empty
{-# INLINE rule2521 #-}
rule2521 = \ (_ :: ()) ->
[]
{-# INLINE rule2522 #-}
rule2522 = \ (_ :: ()) ->
[]
{-# INLINE rule2523 #-}
rule2523 = \ (_ :: ()) ->
MaybeDeclarations_Nothing
{-# INLINE rule2524 #-}
rule2524 = \ _self ->
_self
{-# INLINE rule2525 #-}
rule2525 = \ ((_lhsIassumptions) :: Assumptions) ->
_lhsIassumptions
{-# INLINE rule2526 #-}
rule2526 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2527 #-}
rule2527 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2528 #-}
rule2528 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2529 #-}
rule2529 = \ ((_lhsIconstraints) :: ConstraintSet) ->
_lhsIconstraints
{-# INLINE rule2530 #-}
rule2530 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2531 #-}
rule2531 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2532 #-}
rule2532 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2533 #-}
rule2533 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2534 #-}
rule2534 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2535 #-}
rule2535 = \ ((_lhsIunboundNames) :: Names) ->
_lhsIunboundNames
{-# INLINE rule2536 #-}
rule2536 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_MaybeDeclarations_Just #-}
sem_MaybeDeclarations_Just :: T_Declarations -> T_MaybeDeclarations
sem_MaybeDeclarations_Just arg_declarations_ = T_MaybeDeclarations (return st89) where
{-# NOINLINE st89 #-}
st89 = let
v88 :: T_MaybeDeclarations_v88
v88 = \ (T_MaybeDeclarations_vIn88 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk) -> ( let
_declarationsX32 = Control.Monad.Identity.runIdentity (attach_T_Declarations (arg_declarations_))
(T_Declarations_vOut31 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsIcollectErrors _declarationsIcollectInstances _declarationsIcollectWarnings _declarationsIcounter _declarationsIdeclVarNames _declarationsIdictionaryEnvironment _declarationsIinfoTrees _declarationsImatchIO _declarationsIpatternMatchWarnings _declarationsIrestrictedNames _declarationsIself _declarationsIsimplePatNames _declarationsItypeSignatures _declarationsIunboundNames _declarationsIuniqueChunk) = inv_Declarations_s32 _declarationsX32 (T_Declarations_vIn31 _declarationsOallPatterns _declarationsOallTypeSchemes _declarationsOavailablePredicates _declarationsObetaUnique _declarationsObindingGroups _declarationsOclassEnvironment _declarationsOcollectErrors _declarationsOcollectWarnings _declarationsOcounter _declarationsOcurrentChunk _declarationsOdictionaryEnvironment _declarationsOimportEnvironment _declarationsOinheritedBDG _declarationsOmatchIO _declarationsOmonos _declarationsOnamesInScope _declarationsOorderedTypeSynonyms _declarationsOparentTree _declarationsOpatternMatchWarnings _declarationsOsubstitution _declarationsOtypeSignatures _declarationsOtypeschemeMap _declarationsOuniqueChunk)
_declarationsObindingGroups = rule2537 ()
_lhsOassumptions :: Assumptions
_lhsOconstraints :: ConstraintSet
_lhsObetaUnique :: Int
(_lhsOassumptions,_lhsOconstraints,_inheritedBDG,_chunkNr,_lhsObetaUnique,_implicitsFM) = rule2538 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsItypeSignatures _declarationsIuniqueChunk _lhsIassumptions _lhsIconstraints _lhsIcurrentChunk _lhsImonos
_inferredTypes = rule2539 _implicitsFM _lhsItypeschemeMap
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2540 _declarationsIcollectWarnings _declarationsIsimplePatNames _inferredTypes
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2541 _declarationsIcollectErrors _declarationsIrestrictedNames _inferredTypes
_lhsOlocalTypes :: M.Map NameWithRange TpScheme
_lhsOlocalTypes = rule2542 _declarationsIbindingGroups _declarationsItypeSignatures _inferredTypes
_declarationsOtypeSignatures = rule2543 ()
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2544 _chunkNr
_declInfo = rule2545 _declarationsIself _lhsImonos
_theNode = rule2546 _declInfo _declarationsIinfoTrees _lhsIparentTree
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2547 _theNode
_declarationsOparentTree = rule2548 _theNode
(_collectTypeConstructors,_collectValueConstructors,_collectTypeSynonyms,_collectConstructorEnv,_derivedFunctions,_operatorFixities) = rule2549 ()
(_namesInScope,_unboundNames,_scopeInfo) = rule2550 _declarationsIdeclVarNames _declarationsIunboundNames _lhsInamesInScope _lhsIunboundNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2551 _unboundNames
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2552 _declarationsIcollectInstances
_self = rule2553 _declarationsIself
_lhsOself :: MaybeDeclarations
_lhsOself = rule2554 _self
_lhsOcounter :: Int
_lhsOcounter = rule2555 _declarationsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2556 _declarationsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2557 _declarationsImatchIO
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule2558 _namesInScope
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2559 _declarationsIpatternMatchWarnings
_declarationsOallPatterns = rule2560 _lhsIallPatterns
_declarationsOallTypeSchemes = rule2561 _lhsIallTypeSchemes
_declarationsOavailablePredicates = rule2562 _lhsIavailablePredicates
_declarationsObetaUnique = rule2563 _lhsIbetaUnique
_declarationsOclassEnvironment = rule2564 _lhsIclassEnvironment
_declarationsOcollectErrors = rule2565 _lhsIcollectErrors
_declarationsOcollectWarnings = rule2566 _lhsIcollectWarnings
_declarationsOcounter = rule2567 _lhsIcounter
_declarationsOcurrentChunk = rule2568 _lhsIcurrentChunk
_declarationsOdictionaryEnvironment = rule2569 _lhsIdictionaryEnvironment
_declarationsOimportEnvironment = rule2570 _lhsIimportEnvironment
_declarationsOinheritedBDG = rule2571 _inheritedBDG
_declarationsOmatchIO = rule2572 _lhsImatchIO
_declarationsOmonos = rule2573 _lhsImonos
_declarationsOnamesInScope = rule2574 _namesInScope
_declarationsOorderedTypeSynonyms = rule2575 _lhsIorderedTypeSynonyms
_declarationsOpatternMatchWarnings = rule2576 _lhsIpatternMatchWarnings
_declarationsOsubstitution = rule2577 _lhsIsubstitution
_declarationsOtypeschemeMap = rule2578 _lhsItypeschemeMap
_declarationsOuniqueChunk = rule2579 _lhsIuniqueChunk
__result_ = T_MaybeDeclarations_vOut88 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOlocalTypes _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_MaybeDeclarations_s89 v88
{-# INLINE rule2537 #-}
rule2537 = \ (_ :: ()) ->
[]
{-# INLINE rule2538 #-}
rule2538 = \ ((_declarationsIbetaUnique) :: Int) ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) ((_declarationsIuniqueChunk) :: Int) ((_lhsIassumptions) :: Assumptions) ((_lhsIconstraints) :: ConstraintSet) ((_lhsIcurrentChunk) :: Int) ((_lhsImonos) :: Monos) ->
let inputBDG = (False, _lhsIcurrentChunk, _declarationsIuniqueChunk, _lhsImonos, _declarationsItypeSignatures, mybdggroup, _declarationsIbetaUnique)
mybdggroup = Just (_lhsIassumptions, [_lhsIconstraints])
in performBindingGroup inputBDG _declarationsIbindingGroups
{-# INLINE rule2539 #-}
rule2539 = \ _implicitsFM ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
findInferredTypes _lhsItypeschemeMap _implicitsFM
{-# INLINE rule2540 #-}
rule2540 = \ ((_declarationsIcollectWarnings) :: Warnings) ((_declarationsIsimplePatNames) :: Names) _inferredTypes ->
missingTypeSignature False _declarationsIsimplePatNames _inferredTypes
++ _declarationsIcollectWarnings
{-# INLINE rule2541 #-}
rule2541 = \ ((_declarationsIcollectErrors) :: TypeErrors) ((_declarationsIrestrictedNames) :: Names) _inferredTypes ->
restrictedNameErrors _inferredTypes _declarationsIrestrictedNames
++ _declarationsIcollectErrors
{-# INLINE rule2542 #-}
rule2542 = \ ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) _inferredTypes ->
makeLocalTypeEnv (_declarationsItypeSignatures `M.union` _inferredTypes) _declarationsIbindingGroups
{-# INLINE rule2543 #-}
rule2543 = \ (_ :: ()) ->
M.empty
{-# INLINE rule2544 #-}
rule2544 = \ _chunkNr ->
_chunkNr
{-# INLINE rule2545 #-}
rule2545 = \ ((_declarationsIself) :: Declarations) ((_lhsImonos) :: Monos) ->
LocalInfo { self = UHA_Decls _declarationsIself
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule2546 #-}
rule2546 = \ _declInfo ((_declarationsIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) ->
node _lhsIparentTree _declInfo _declarationsIinfoTrees
{-# INLINE rule2547 #-}
rule2547 = \ _theNode ->
[_theNode]
{-# INLINE rule2548 #-}
rule2548 = \ _theNode ->
_theNode
{-# INLINE rule2549 #-}
rule2549 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "toplevel MaybeDeclaration"
{-# INLINE rule2550 #-}
rule2550 = \ ((_declarationsIdeclVarNames) :: Names) ((_declarationsIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ((_lhsIunboundNames) :: Names) ->
changeOfScope _declarationsIdeclVarNames (_declarationsIunboundNames ++ _lhsIunboundNames) _lhsInamesInScope
{-# INLINE rule2551 #-}
rule2551 = \ _unboundNames ->
_unboundNames
{-# INLINE rule2552 #-}
rule2552 = \ ((_declarationsIcollectInstances) :: [(Name, Instance)]) ->
_declarationsIcollectInstances
{-# INLINE rule2553 #-}
rule2553 = \ ((_declarationsIself) :: Declarations) ->
MaybeDeclarations_Just _declarationsIself
{-# INLINE rule2554 #-}
rule2554 = \ _self ->
_self
{-# INLINE rule2555 #-}
rule2555 = \ ((_declarationsIcounter) :: Int) ->
_declarationsIcounter
{-# INLINE rule2556 #-}
rule2556 = \ ((_declarationsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_declarationsIdictionaryEnvironment
{-# INLINE rule2557 #-}
rule2557 = \ ((_declarationsImatchIO) :: IO ()) ->
_declarationsImatchIO
{-# INLINE rule2558 #-}
rule2558 = \ _namesInScope ->
_namesInScope
{-# INLINE rule2559 #-}
rule2559 = \ ((_declarationsIpatternMatchWarnings) :: [Warning]) ->
_declarationsIpatternMatchWarnings
{-# INLINE rule2560 #-}
rule2560 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule2561 #-}
rule2561 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule2562 #-}
rule2562 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule2563 #-}
rule2563 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2564 #-}
rule2564 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule2565 #-}
rule2565 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2566 #-}
rule2566 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2567 #-}
rule2567 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2568 #-}
rule2568 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule2569 #-}
rule2569 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2570 #-}
rule2570 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2571 #-}
rule2571 = \ _inheritedBDG ->
_inheritedBDG
{-# INLINE rule2572 #-}
rule2572 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2573 #-}
rule2573 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2574 #-}
rule2574 = \ _namesInScope ->
_namesInScope
{-# INLINE rule2575 #-}
rule2575 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule2576 #-}
rule2576 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2577 #-}
rule2577 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule2578 #-}
rule2578 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule2579 #-}
rule2579 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
-- MaybeExports ------------------------------------------------
-- wrapper
data Inh_MaybeExports = Inh_MaybeExports { }
data Syn_MaybeExports = Syn_MaybeExports { self_Syn_MaybeExports :: (MaybeExports) }
{-# INLINABLE wrap_MaybeExports #-}
wrap_MaybeExports :: T_MaybeExports -> Inh_MaybeExports -> (Syn_MaybeExports )
wrap_MaybeExports (T_MaybeExports act) (Inh_MaybeExports ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_MaybeExports_vIn91
(T_MaybeExports_vOut91 _lhsOself) <- return (inv_MaybeExports_s92 sem arg)
return (Syn_MaybeExports _lhsOself)
)
-- cata
{-# NOINLINE sem_MaybeExports #-}
sem_MaybeExports :: MaybeExports -> T_MaybeExports
sem_MaybeExports ( MaybeExports_Nothing ) = sem_MaybeExports_Nothing
sem_MaybeExports ( MaybeExports_Just exports_ ) = sem_MaybeExports_Just ( sem_Exports exports_ )
-- semantic domain
newtype T_MaybeExports = T_MaybeExports {
attach_T_MaybeExports :: Identity (T_MaybeExports_s92 )
}
newtype T_MaybeExports_s92 = C_MaybeExports_s92 {
inv_MaybeExports_s92 :: (T_MaybeExports_v91 )
}
data T_MaybeExports_s93 = C_MaybeExports_s93
type T_MaybeExports_v91 = (T_MaybeExports_vIn91 ) -> (T_MaybeExports_vOut91 )
data T_MaybeExports_vIn91 = T_MaybeExports_vIn91
data T_MaybeExports_vOut91 = T_MaybeExports_vOut91 (MaybeExports)
{-# NOINLINE sem_MaybeExports_Nothing #-}
sem_MaybeExports_Nothing :: T_MaybeExports
sem_MaybeExports_Nothing = T_MaybeExports (return st92) where
{-# NOINLINE st92 #-}
st92 = let
v91 :: T_MaybeExports_v91
v91 = \ (T_MaybeExports_vIn91 ) -> ( let
_self = rule2580 ()
_lhsOself :: MaybeExports
_lhsOself = rule2581 _self
__result_ = T_MaybeExports_vOut91 _lhsOself
in __result_ )
in C_MaybeExports_s92 v91
{-# INLINE rule2580 #-}
rule2580 = \ (_ :: ()) ->
MaybeExports_Nothing
{-# INLINE rule2581 #-}
rule2581 = \ _self ->
_self
{-# NOINLINE sem_MaybeExports_Just #-}
sem_MaybeExports_Just :: T_Exports -> T_MaybeExports
sem_MaybeExports_Just arg_exports_ = T_MaybeExports (return st92) where
{-# NOINLINE st92 #-}
st92 = let
v91 :: T_MaybeExports_v91
v91 = \ (T_MaybeExports_vIn91 ) -> ( let
_exportsX38 = Control.Monad.Identity.runIdentity (attach_T_Exports (arg_exports_))
(T_Exports_vOut37 _exportsIself) = inv_Exports_s38 _exportsX38 (T_Exports_vIn37 )
_self = rule2582 _exportsIself
_lhsOself :: MaybeExports
_lhsOself = rule2583 _self
__result_ = T_MaybeExports_vOut91 _lhsOself
in __result_ )
in C_MaybeExports_s92 v91
{-# INLINE rule2582 #-}
rule2582 = \ ((_exportsIself) :: Exports) ->
MaybeExports_Just _exportsIself
{-# INLINE rule2583 #-}
rule2583 = \ _self ->
_self
-- MaybeExpression ---------------------------------------------
-- wrapper
data Inh_MaybeExpression = Inh_MaybeExpression { allPatterns_Inh_MaybeExpression :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_MaybeExpression :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_MaybeExpression :: (Predicates), betaUnique_Inh_MaybeExpression :: (Int), classEnvironment_Inh_MaybeExpression :: (ClassEnvironment), collectErrors_Inh_MaybeExpression :: (TypeErrors), collectWarnings_Inh_MaybeExpression :: (Warnings), counter_Inh_MaybeExpression :: (Int), currentChunk_Inh_MaybeExpression :: (Int), dictionaryEnvironment_Inh_MaybeExpression :: (DictionaryEnvironment), importEnvironment_Inh_MaybeExpression :: (ImportEnvironment), matchIO_Inh_MaybeExpression :: (IO ()), monos_Inh_MaybeExpression :: (Monos), namesInScope_Inh_MaybeExpression :: (Names), orderedTypeSynonyms_Inh_MaybeExpression :: (OrderedTypeSynonyms), parentTree_Inh_MaybeExpression :: (InfoTree), patternMatchWarnings_Inh_MaybeExpression :: ([Warning]), substitution_Inh_MaybeExpression :: (FixpointSubstitution), tryPatterns_Inh_MaybeExpression :: ([(MaybeExpression, [String])]), typeschemeMap_Inh_MaybeExpression :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_MaybeExpression :: (Int), uniqueSecondRound_Inh_MaybeExpression :: (Int) }
data Syn_MaybeExpression = Syn_MaybeExpression { assumptions_Syn_MaybeExpression :: (Assumptions), beta_Syn_MaybeExpression :: (Tp), betaUnique_Syn_MaybeExpression :: (Int), collectErrors_Syn_MaybeExpression :: (TypeErrors), collectInstances_Syn_MaybeExpression :: ([(Name, Instance)]), collectWarnings_Syn_MaybeExpression :: (Warnings), constraints_Syn_MaybeExpression :: (ConstraintSet), counter_Syn_MaybeExpression :: (Int), dictionaryEnvironment_Syn_MaybeExpression :: (DictionaryEnvironment), infoTrees_Syn_MaybeExpression :: (InfoTrees), matchIO_Syn_MaybeExpression :: (IO ()), matches_Syn_MaybeExpression :: ([Maybe MetaVariableTable]), patternMatchWarnings_Syn_MaybeExpression :: ([Warning]), section_Syn_MaybeExpression :: (Bool), self_Syn_MaybeExpression :: (MaybeExpression), unboundNames_Syn_MaybeExpression :: (Names), uniqueChunk_Syn_MaybeExpression :: (Int), uniqueSecondRound_Syn_MaybeExpression :: (Int) }
{-# INLINABLE wrap_MaybeExpression #-}
wrap_MaybeExpression :: T_MaybeExpression -> Inh_MaybeExpression -> (Syn_MaybeExpression )
wrap_MaybeExpression (T_MaybeExpression act) (Inh_MaybeExpression _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_MaybeExpression_vIn94 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound
(T_MaybeExpression_vOut94 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOsection _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_MaybeExpression_s95 sem arg)
return (Syn_MaybeExpression _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOsection _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
)
-- cata
{-# NOINLINE sem_MaybeExpression #-}
sem_MaybeExpression :: MaybeExpression -> T_MaybeExpression
sem_MaybeExpression ( MaybeExpression_Nothing ) = sem_MaybeExpression_Nothing
sem_MaybeExpression ( MaybeExpression_Just expression_ ) = sem_MaybeExpression_Just ( sem_Expression expression_ )
-- semantic domain
newtype T_MaybeExpression = T_MaybeExpression {
attach_T_MaybeExpression :: Identity (T_MaybeExpression_s95 )
}
newtype T_MaybeExpression_s95 = C_MaybeExpression_s95 {
inv_MaybeExpression_s95 :: (T_MaybeExpression_v94 )
}
data T_MaybeExpression_s96 = C_MaybeExpression_s96
type T_MaybeExpression_v94 = (T_MaybeExpression_vIn94 ) -> (T_MaybeExpression_vOut94 )
data T_MaybeExpression_vIn94 = T_MaybeExpression_vIn94 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) ([(MaybeExpression, [String])]) (M.Map Int (Scheme Predicates)) (Int) (Int)
data T_MaybeExpression_vOut94 = T_MaybeExpression_vOut94 (Assumptions) (Tp) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (InfoTrees) (IO ()) ([Maybe MetaVariableTable]) ([Warning]) (Bool) (MaybeExpression) (Names) (Int) (Int)
{-# NOINLINE sem_MaybeExpression_Nothing #-}
sem_MaybeExpression_Nothing :: T_MaybeExpression
sem_MaybeExpression_Nothing = T_MaybeExpression (return st95) where
{-# NOINLINE st95 #-}
st95 = let
v94 :: T_MaybeExpression_v94
v94 = \ (T_MaybeExpression_vIn94 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_lhsOsection :: Bool
_lhsOsection = rule2584 ()
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2585 _lhsIbetaUnique
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule2586 ()
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2587 ()
_beta = rule2588 _lhsIbetaUnique
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2589 ()
_lhsOmatches :: [Maybe MetaVariableTable]
((),_lhsOmatches,_,_,_,_) = rule2590 _lhsItryPatterns
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2591 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2592 ()
_self = rule2593 ()
_lhsOself :: MaybeExpression
_lhsOself = rule2594 _self
_lhsObeta :: Tp
_lhsObeta = rule2595 _beta
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2596 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2597 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule2598 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2599 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2600 _lhsImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2601 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2602 _lhsIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule2603 _lhsIuniqueSecondRound
__result_ = T_MaybeExpression_vOut94 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOsection _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_MaybeExpression_s95 v94
{-# INLINE rule2584 #-}
rule2584 = \ (_ :: ()) ->
True
{-# INLINE rule2585 #-}
rule2585 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule2586 #-}
rule2586 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule2587 #-}
rule2587 = \ (_ :: ()) ->
emptyTree
{-# INLINE rule2588 #-}
rule2588 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule2589 #-}
rule2589 = \ (_ :: ()) ->
[]
{-# INLINE rule2590 #-}
rule2590 = \ ((_lhsItryPatterns) :: [(MaybeExpression, [String])]) ->
match0' match_MaybeExpression_Nothing _lhsItryPatterns [] []
{-# INLINE rule2591 #-}
rule2591 = \ (_ :: ()) ->
[]
{-# INLINE rule2592 #-}
rule2592 = \ (_ :: ()) ->
[]
{-# INLINE rule2593 #-}
rule2593 = \ (_ :: ()) ->
MaybeExpression_Nothing
{-# INLINE rule2594 #-}
rule2594 = \ _self ->
_self
{-# INLINE rule2595 #-}
rule2595 = \ _beta ->
_beta
{-# INLINE rule2596 #-}
rule2596 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2597 #-}
rule2597 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2598 #-}
rule2598 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2599 #-}
rule2599 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2600 #-}
rule2600 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2601 #-}
rule2601 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2602 #-}
rule2602 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule2603 #-}
rule2603 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_MaybeExpression_Just #-}
sem_MaybeExpression_Just :: T_Expression -> T_MaybeExpression
sem_MaybeExpression_Just arg_expression_ = T_MaybeExpression (return st95) where
{-# NOINLINE st95 #-}
st95 = let
v94 :: T_MaybeExpression_v94
v94 = \ (T_MaybeExpression_vIn94 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_lhsOsection :: Bool
_lhsOsection = rule2604 ()
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule2605 _expressionIinfoTree
_lhsOmatches :: [Maybe MetaVariableTable]
(_expressionOtryPatterns,_lhsOmatches,_,_,_,_) = rule2606 _expressionImatches _lhsItryPatterns
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule2607 _expressionIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2608 _expressionIunboundNames
_self = rule2609 _expressionIself
_lhsOself :: MaybeExpression
_lhsOself = rule2610 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule2611 _expressionIassumptions
_lhsObeta :: Tp
_lhsObeta = rule2612 _expressionIbeta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2613 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule2614 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule2615 _expressionIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2616 _expressionIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule2617 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2618 _expressionIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule2619 _expressionImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2620 _expressionIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule2621 _expressionIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule2622 _expressionIuniqueSecondRound
_expressionOallPatterns = rule2623 _lhsIallPatterns
_expressionOallTypeSchemes = rule2624 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule2625 _lhsIavailablePredicates
_expressionObetaUnique = rule2626 _lhsIbetaUnique
_expressionOclassEnvironment = rule2627 _lhsIclassEnvironment
_expressionOcollectErrors = rule2628 _lhsIcollectErrors
_expressionOcollectWarnings = rule2629 _lhsIcollectWarnings
_expressionOcounter = rule2630 _lhsIcounter
_expressionOcurrentChunk = rule2631 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule2632 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule2633 _lhsIimportEnvironment
_expressionOmatchIO = rule2634 _lhsImatchIO
_expressionOmonos = rule2635 _lhsImonos
_expressionOnamesInScope = rule2636 _lhsInamesInScope
_expressionOorderedTypeSynonyms = rule2637 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule2638 _lhsIparentTree
_expressionOpatternMatchWarnings = rule2639 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule2640 _lhsIsubstitution
_expressionOtypeschemeMap = rule2641 _lhsItypeschemeMap
_expressionOuniqueChunk = rule2642 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule2643 _lhsIuniqueSecondRound
__result_ = T_MaybeExpression_vOut94 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOsection _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_MaybeExpression_s95 v94
{-# INLINE rule2604 #-}
rule2604 = \ (_ :: ()) ->
False
{-# INLINE rule2605 #-}
rule2605 = \ ((_expressionIinfoTree) :: InfoTree) ->
[_expressionIinfoTree]
{-# INLINE rule2606 #-}
rule2606 = \ ((_expressionImatches) :: [Maybe MetaVariableTable]) ((_lhsItryPatterns) :: [(MaybeExpression, [String])]) ->
match1' match_MaybeExpression_Just _lhsItryPatterns [] [_expressionImatches]
{-# INLINE rule2607 #-}
rule2607 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances
{-# INLINE rule2608 #-}
rule2608 = \ ((_expressionIunboundNames) :: Names) ->
_expressionIunboundNames
{-# INLINE rule2609 #-}
rule2609 = \ ((_expressionIself) :: Expression) ->
MaybeExpression_Just _expressionIself
{-# INLINE rule2610 #-}
rule2610 = \ _self ->
_self
{-# INLINE rule2611 #-}
rule2611 = \ ((_expressionIassumptions) :: Assumptions) ->
_expressionIassumptions
{-# INLINE rule2612 #-}
rule2612 = \ ((_expressionIbeta) :: Tp) ->
_expressionIbeta
{-# INLINE rule2613 #-}
rule2613 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule2614 #-}
rule2614 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule2615 #-}
rule2615 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule2616 #-}
rule2616 = \ ((_expressionIconstraints) :: ConstraintSet) ->
_expressionIconstraints
{-# INLINE rule2617 #-}
rule2617 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule2618 #-}
rule2618 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule2619 #-}
rule2619 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule2620 #-}
rule2620 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule2621 #-}
rule2621 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule2622 #-}
rule2622 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule2623 #-}
rule2623 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule2624 #-}
rule2624 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule2625 #-}
rule2625 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule2626 #-}
rule2626 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2627 #-}
rule2627 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule2628 #-}
rule2628 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule2629 #-}
rule2629 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule2630 #-}
rule2630 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2631 #-}
rule2631 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule2632 #-}
rule2632 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule2633 #-}
rule2633 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2634 #-}
rule2634 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule2635 #-}
rule2635 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2636 #-}
rule2636 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2637 #-}
rule2637 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule2638 #-}
rule2638 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2639 #-}
rule2639 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2640 #-}
rule2640 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule2641 #-}
rule2641 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule2642 #-}
rule2642 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule2643 #-}
rule2643 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
-- MaybeImportSpecification ------------------------------------
-- wrapper
data Inh_MaybeImportSpecification = Inh_MaybeImportSpecification { }
data Syn_MaybeImportSpecification = Syn_MaybeImportSpecification { self_Syn_MaybeImportSpecification :: (MaybeImportSpecification) }
{-# INLINABLE wrap_MaybeImportSpecification #-}
wrap_MaybeImportSpecification :: T_MaybeImportSpecification -> Inh_MaybeImportSpecification -> (Syn_MaybeImportSpecification )
wrap_MaybeImportSpecification (T_MaybeImportSpecification act) (Inh_MaybeImportSpecification ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_MaybeImportSpecification_vIn97
(T_MaybeImportSpecification_vOut97 _lhsOself) <- return (inv_MaybeImportSpecification_s98 sem arg)
return (Syn_MaybeImportSpecification _lhsOself)
)
-- cata
{-# NOINLINE sem_MaybeImportSpecification #-}
sem_MaybeImportSpecification :: MaybeImportSpecification -> T_MaybeImportSpecification
sem_MaybeImportSpecification ( MaybeImportSpecification_Nothing ) = sem_MaybeImportSpecification_Nothing
sem_MaybeImportSpecification ( MaybeImportSpecification_Just importspecification_ ) = sem_MaybeImportSpecification_Just ( sem_ImportSpecification importspecification_ )
-- semantic domain
newtype T_MaybeImportSpecification = T_MaybeImportSpecification {
attach_T_MaybeImportSpecification :: Identity (T_MaybeImportSpecification_s98 )
}
newtype T_MaybeImportSpecification_s98 = C_MaybeImportSpecification_s98 {
inv_MaybeImportSpecification_s98 :: (T_MaybeImportSpecification_v97 )
}
data T_MaybeImportSpecification_s99 = C_MaybeImportSpecification_s99
type T_MaybeImportSpecification_v97 = (T_MaybeImportSpecification_vIn97 ) -> (T_MaybeImportSpecification_vOut97 )
data T_MaybeImportSpecification_vIn97 = T_MaybeImportSpecification_vIn97
data T_MaybeImportSpecification_vOut97 = T_MaybeImportSpecification_vOut97 (MaybeImportSpecification)
{-# NOINLINE sem_MaybeImportSpecification_Nothing #-}
sem_MaybeImportSpecification_Nothing :: T_MaybeImportSpecification
sem_MaybeImportSpecification_Nothing = T_MaybeImportSpecification (return st98) where
{-# NOINLINE st98 #-}
st98 = let
v97 :: T_MaybeImportSpecification_v97
v97 = \ (T_MaybeImportSpecification_vIn97 ) -> ( let
_self = rule2644 ()
_lhsOself :: MaybeImportSpecification
_lhsOself = rule2645 _self
__result_ = T_MaybeImportSpecification_vOut97 _lhsOself
in __result_ )
in C_MaybeImportSpecification_s98 v97
{-# INLINE rule2644 #-}
rule2644 = \ (_ :: ()) ->
MaybeImportSpecification_Nothing
{-# INLINE rule2645 #-}
rule2645 = \ _self ->
_self
{-# NOINLINE sem_MaybeImportSpecification_Just #-}
sem_MaybeImportSpecification_Just :: T_ImportSpecification -> T_MaybeImportSpecification
sem_MaybeImportSpecification_Just arg_importspecification_ = T_MaybeImportSpecification (return st98) where
{-# NOINLINE st98 #-}
st98 = let
v97 :: T_MaybeImportSpecification_v97
v97 = \ (T_MaybeImportSpecification_vIn97 ) -> ( let
_importspecificationX77 = Control.Monad.Identity.runIdentity (attach_T_ImportSpecification (arg_importspecification_))
(T_ImportSpecification_vOut76 _importspecificationIself) = inv_ImportSpecification_s77 _importspecificationX77 (T_ImportSpecification_vIn76 )
_self = rule2646 _importspecificationIself
_lhsOself :: MaybeImportSpecification
_lhsOself = rule2647 _self
__result_ = T_MaybeImportSpecification_vOut97 _lhsOself
in __result_ )
in C_MaybeImportSpecification_s98 v97
{-# INLINE rule2646 #-}
rule2646 = \ ((_importspecificationIself) :: ImportSpecification) ->
MaybeImportSpecification_Just _importspecificationIself
{-# INLINE rule2647 #-}
rule2647 = \ _self ->
_self
-- MaybeInt ----------------------------------------------------
-- wrapper
data Inh_MaybeInt = Inh_MaybeInt { }
data Syn_MaybeInt = Syn_MaybeInt { self_Syn_MaybeInt :: (MaybeInt) }
{-# INLINABLE wrap_MaybeInt #-}
wrap_MaybeInt :: T_MaybeInt -> Inh_MaybeInt -> (Syn_MaybeInt )
wrap_MaybeInt (T_MaybeInt act) (Inh_MaybeInt ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_MaybeInt_vIn100
(T_MaybeInt_vOut100 _lhsOself) <- return (inv_MaybeInt_s101 sem arg)
return (Syn_MaybeInt _lhsOself)
)
-- cata
{-# NOINLINE sem_MaybeInt #-}
sem_MaybeInt :: MaybeInt -> T_MaybeInt
sem_MaybeInt ( MaybeInt_Nothing ) = sem_MaybeInt_Nothing
sem_MaybeInt ( MaybeInt_Just int_ ) = sem_MaybeInt_Just int_
-- semantic domain
newtype T_MaybeInt = T_MaybeInt {
attach_T_MaybeInt :: Identity (T_MaybeInt_s101 )
}
newtype T_MaybeInt_s101 = C_MaybeInt_s101 {
inv_MaybeInt_s101 :: (T_MaybeInt_v100 )
}
data T_MaybeInt_s102 = C_MaybeInt_s102
type T_MaybeInt_v100 = (T_MaybeInt_vIn100 ) -> (T_MaybeInt_vOut100 )
data T_MaybeInt_vIn100 = T_MaybeInt_vIn100
data T_MaybeInt_vOut100 = T_MaybeInt_vOut100 (MaybeInt)
{-# NOINLINE sem_MaybeInt_Nothing #-}
sem_MaybeInt_Nothing :: T_MaybeInt
sem_MaybeInt_Nothing = T_MaybeInt (return st101) where
{-# NOINLINE st101 #-}
st101 = let
v100 :: T_MaybeInt_v100
v100 = \ (T_MaybeInt_vIn100 ) -> ( let
_self = rule2648 ()
_lhsOself :: MaybeInt
_lhsOself = rule2649 _self
__result_ = T_MaybeInt_vOut100 _lhsOself
in __result_ )
in C_MaybeInt_s101 v100
{-# INLINE rule2648 #-}
rule2648 = \ (_ :: ()) ->
MaybeInt_Nothing
{-# INLINE rule2649 #-}
rule2649 = \ _self ->
_self
{-# NOINLINE sem_MaybeInt_Just #-}
sem_MaybeInt_Just :: (Int) -> T_MaybeInt
sem_MaybeInt_Just arg_int_ = T_MaybeInt (return st101) where
{-# NOINLINE st101 #-}
st101 = let
v100 :: T_MaybeInt_v100
v100 = \ (T_MaybeInt_vIn100 ) -> ( let
_self = rule2650 arg_int_
_lhsOself :: MaybeInt
_lhsOself = rule2651 _self
__result_ = T_MaybeInt_vOut100 _lhsOself
in __result_ )
in C_MaybeInt_s101 v100
{-# INLINE rule2650 #-}
rule2650 = \ int_ ->
MaybeInt_Just int_
{-# INLINE rule2651 #-}
rule2651 = \ _self ->
_self
-- MaybeName ---------------------------------------------------
-- wrapper
data Inh_MaybeName = Inh_MaybeName { }
data Syn_MaybeName = Syn_MaybeName { self_Syn_MaybeName :: (MaybeName) }
{-# INLINABLE wrap_MaybeName #-}
wrap_MaybeName :: T_MaybeName -> Inh_MaybeName -> (Syn_MaybeName )
wrap_MaybeName (T_MaybeName act) (Inh_MaybeName ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_MaybeName_vIn103
(T_MaybeName_vOut103 _lhsOself) <- return (inv_MaybeName_s104 sem arg)
return (Syn_MaybeName _lhsOself)
)
-- cata
{-# NOINLINE sem_MaybeName #-}
sem_MaybeName :: MaybeName -> T_MaybeName
sem_MaybeName ( MaybeName_Nothing ) = sem_MaybeName_Nothing
sem_MaybeName ( MaybeName_Just name_ ) = sem_MaybeName_Just ( sem_Name name_ )
-- semantic domain
newtype T_MaybeName = T_MaybeName {
attach_T_MaybeName :: Identity (T_MaybeName_s104 )
}
newtype T_MaybeName_s104 = C_MaybeName_s104 {
inv_MaybeName_s104 :: (T_MaybeName_v103 )
}
data T_MaybeName_s105 = C_MaybeName_s105
type T_MaybeName_v103 = (T_MaybeName_vIn103 ) -> (T_MaybeName_vOut103 )
data T_MaybeName_vIn103 = T_MaybeName_vIn103
data T_MaybeName_vOut103 = T_MaybeName_vOut103 (MaybeName)
{-# NOINLINE sem_MaybeName_Nothing #-}
sem_MaybeName_Nothing :: T_MaybeName
sem_MaybeName_Nothing = T_MaybeName (return st104) where
{-# NOINLINE st104 #-}
st104 = let
v103 :: T_MaybeName_v103
v103 = \ (T_MaybeName_vIn103 ) -> ( let
_self = rule2652 ()
_lhsOself :: MaybeName
_lhsOself = rule2653 _self
__result_ = T_MaybeName_vOut103 _lhsOself
in __result_ )
in C_MaybeName_s104 v103
{-# INLINE rule2652 #-}
rule2652 = \ (_ :: ()) ->
MaybeName_Nothing
{-# INLINE rule2653 #-}
rule2653 = \ _self ->
_self
{-# NOINLINE sem_MaybeName_Just #-}
sem_MaybeName_Just :: T_Name -> T_MaybeName
sem_MaybeName_Just arg_name_ = T_MaybeName (return st104) where
{-# NOINLINE st104 #-}
st104 = let
v103 :: T_MaybeName_v103
v103 = \ (T_MaybeName_vIn103 ) -> ( let
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
_self = rule2654 _nameIself
_lhsOself :: MaybeName
_lhsOself = rule2655 _self
__result_ = T_MaybeName_vOut103 _lhsOself
in __result_ )
in C_MaybeName_s104 v103
{-# INLINE rule2654 #-}
rule2654 = \ ((_nameIself) :: Name) ->
MaybeName_Just _nameIself
{-# INLINE rule2655 #-}
rule2655 = \ _self ->
_self
-- MaybeNames --------------------------------------------------
-- wrapper
data Inh_MaybeNames = Inh_MaybeNames { }
data Syn_MaybeNames = Syn_MaybeNames { self_Syn_MaybeNames :: (MaybeNames) }
{-# INLINABLE wrap_MaybeNames #-}
wrap_MaybeNames :: T_MaybeNames -> Inh_MaybeNames -> (Syn_MaybeNames )
wrap_MaybeNames (T_MaybeNames act) (Inh_MaybeNames ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_MaybeNames_vIn106
(T_MaybeNames_vOut106 _lhsOself) <- return (inv_MaybeNames_s107 sem arg)
return (Syn_MaybeNames _lhsOself)
)
-- cata
{-# NOINLINE sem_MaybeNames #-}
sem_MaybeNames :: MaybeNames -> T_MaybeNames
sem_MaybeNames ( MaybeNames_Nothing ) = sem_MaybeNames_Nothing
sem_MaybeNames ( MaybeNames_Just names_ ) = sem_MaybeNames_Just ( sem_Names names_ )
-- semantic domain
newtype T_MaybeNames = T_MaybeNames {
attach_T_MaybeNames :: Identity (T_MaybeNames_s107 )
}
newtype T_MaybeNames_s107 = C_MaybeNames_s107 {
inv_MaybeNames_s107 :: (T_MaybeNames_v106 )
}
data T_MaybeNames_s108 = C_MaybeNames_s108
type T_MaybeNames_v106 = (T_MaybeNames_vIn106 ) -> (T_MaybeNames_vOut106 )
data T_MaybeNames_vIn106 = T_MaybeNames_vIn106
data T_MaybeNames_vOut106 = T_MaybeNames_vOut106 (MaybeNames)
{-# NOINLINE sem_MaybeNames_Nothing #-}
sem_MaybeNames_Nothing :: T_MaybeNames
sem_MaybeNames_Nothing = T_MaybeNames (return st107) where
{-# NOINLINE st107 #-}
st107 = let
v106 :: T_MaybeNames_v106
v106 = \ (T_MaybeNames_vIn106 ) -> ( let
_self = rule2656 ()
_lhsOself :: MaybeNames
_lhsOself = rule2657 _self
__result_ = T_MaybeNames_vOut106 _lhsOself
in __result_ )
in C_MaybeNames_s107 v106
{-# INLINE rule2656 #-}
rule2656 = \ (_ :: ()) ->
MaybeNames_Nothing
{-# INLINE rule2657 #-}
rule2657 = \ _self ->
_self
{-# NOINLINE sem_MaybeNames_Just #-}
sem_MaybeNames_Just :: T_Names -> T_MaybeNames
sem_MaybeNames_Just arg_names_ = T_MaybeNames (return st107) where
{-# NOINLINE st107 #-}
st107 = let
v106 :: T_MaybeNames_v106
v106 = \ (T_MaybeNames_vIn106 ) -> ( let
_namesX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_names_))
(T_Names_vOut115 _namesIself) = inv_Names_s116 _namesX116 (T_Names_vIn115 )
_self = rule2658 _namesIself
_lhsOself :: MaybeNames
_lhsOself = rule2659 _self
__result_ = T_MaybeNames_vOut106 _lhsOself
in __result_ )
in C_MaybeNames_s107 v106
{-# INLINE rule2658 #-}
rule2658 = \ ((_namesIself) :: Names) ->
MaybeNames_Just _namesIself
{-# INLINE rule2659 #-}
rule2659 = \ _self ->
_self
-- Module ------------------------------------------------------
-- wrapper
data Inh_Module = Inh_Module { importEnvironment_Inh_Module :: (ImportEnvironment), options_Inh_Module :: ([Option]) }
data Syn_Module = Syn_Module { assumptions_Syn_Module :: (Assumptions), dictionaryEnvironment_Syn_Module :: (DictionaryEnvironment), infoTree_Syn_Module :: (InfoTree), logEntries_Syn_Module :: (LogEntries), self_Syn_Module :: (Module), solveResult_Syn_Module :: (SolveResult ConstraintInfo), toplevelTypes_Syn_Module :: (TypeEnvironment), typeErrors_Syn_Module :: (TypeErrors), warnings_Syn_Module :: (Warnings) }
{-# INLINABLE wrap_Module #-}
wrap_Module :: T_Module -> Inh_Module -> (Syn_Module )
wrap_Module (T_Module act) (Inh_Module _lhsIimportEnvironment _lhsIoptions) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Module_vIn109 _lhsIimportEnvironment _lhsIoptions
(T_Module_vOut109 _lhsOassumptions _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOlogEntries _lhsOself _lhsOsolveResult _lhsOtoplevelTypes _lhsOtypeErrors _lhsOwarnings) <- return (inv_Module_s110 sem arg)
return (Syn_Module _lhsOassumptions _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOlogEntries _lhsOself _lhsOsolveResult _lhsOtoplevelTypes _lhsOtypeErrors _lhsOwarnings)
)
-- cata
{-# INLINE sem_Module #-}
sem_Module :: Module -> T_Module
sem_Module ( Module_Module range_ name_ exports_ body_ ) = sem_Module_Module ( sem_Range range_ ) ( sem_MaybeName name_ ) ( sem_MaybeExports exports_ ) ( sem_Body body_ )
-- semantic domain
newtype T_Module = T_Module {
attach_T_Module :: Identity (T_Module_s110 )
}
newtype T_Module_s110 = C_Module_s110 {
inv_Module_s110 :: (T_Module_v109 )
}
data T_Module_s111 = C_Module_s111
type T_Module_v109 = (T_Module_vIn109 ) -> (T_Module_vOut109 )
data T_Module_vIn109 = T_Module_vIn109 (ImportEnvironment) ([Option])
data T_Module_vOut109 = T_Module_vOut109 (Assumptions) (DictionaryEnvironment) (InfoTree) (LogEntries) (Module) (SolveResult ConstraintInfo) (TypeEnvironment) (TypeErrors) (Warnings)
{-# NOINLINE sem_Module_Module #-}
sem_Module_Module :: T_Range -> T_MaybeName -> T_MaybeExports -> T_Body -> T_Module
sem_Module_Module arg_range_ arg_name_ arg_exports_ arg_body_ = T_Module (return st110) where
{-# NOINLINE st110 #-}
st110 = let
v109 :: T_Module_v109
v109 = \ (T_Module_vIn109 _lhsIimportEnvironment _lhsIoptions) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX104 = Control.Monad.Identity.runIdentity (attach_T_MaybeName (arg_name_))
_exportsX92 = Control.Monad.Identity.runIdentity (attach_T_MaybeExports (arg_exports_))
_bodyX14 = Control.Monad.Identity.runIdentity (attach_T_Body (arg_body_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_MaybeName_vOut103 _nameIself) = inv_MaybeName_s104 _nameX104 (T_MaybeName_vIn103 )
(T_MaybeExports_vOut91 _exportsIself) = inv_MaybeExports_s92 _exportsX92 (T_MaybeExports_vIn91 )
(T_Body_vOut13 _bodyIassumptions _bodyIbetaUnique _bodyIcollectErrors _bodyIcollectInstances _bodyIcollectWarnings _bodyIconstraints _bodyIcounter _bodyIdeclVarNames _bodyIdictionaryEnvironment _bodyIinfoTree _bodyImatchIO _bodyIpatternMatchWarnings _bodyIself _bodyItoplevelTypes _bodyIunboundNames _bodyIuniqueChunk) = inv_Body_s14 _bodyX14 (T_Body_vIn13 _bodyOallPatterns _bodyOallTypeSchemes _bodyOavailablePredicates _bodyObetaUnique _bodyOclassEnvironment _bodyOcollectErrors _bodyOcollectWarnings _bodyOcounter _bodyOcurrentChunk _bodyOdictionaryEnvironment _bodyOimportEnvironment _bodyOmatchIO _bodyOmonos _bodyOnamesInScope _bodyOorderedTypeSynonyms _bodyOpatternMatchWarnings _bodyOsubstitution _bodyOtypeschemeMap _bodyOuniqueChunk)
_lhsOwarnings :: Warnings
_lhsOwarnings = rule2660 _bodyIpatternMatchWarnings _warnings
(SolveResult _betaUniqueAtTheEnd _substitution _typeschemeMap _ _solveErrors) = rule2661 _solveResult
(_solveResult,_logEntries) = rule2662 _bodyIbetaUnique _bodyIconstraints _classEnv _lhsIimportEnvironment _lhsIoptions _orderedTypeSynonyms
_orderedTypeSynonyms = rule2663 _lhsIimportEnvironment
_classEnv = rule2664 _bodyIcollectInstances _lhsIimportEnvironment
_typeErrors = rule2665 _bodyIcollectErrors _classEnv _lhsIoptions _orderedTypeSynonyms _solveErrors _substitution
_warnings = rule2666 _bodyIcollectWarnings
_assumptions = rule2667 _bodyIassumptions _substitution
_initialScope = rule2668 _lhsIimportEnvironment
_monos = rule2669 _monomorphics
_monomorphics = rule2670 _lhsIimportEnvironment
_bodyOtypeschemeMap = rule2671 _typeschemeMap
_bodyObetaUnique = rule2672 _monomorphics
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule2673 _bodyIdictionaryEnvironment _lhsIoptions
_bodyOdictionaryEnvironment = rule2674 ()
_bodyOclassEnvironment = rule2675 _classEnv
_bodyOavailablePredicates = rule2676 ()
_bodyOcollectWarnings = rule2677 ()
_bodyOcollectErrors = rule2678 ()
_bodyOallTypeSchemes = rule2679 _lhsIimportEnvironment
_bodyOcurrentChunk = rule2680 ()
_bodyOuniqueChunk = rule2681 ()
(_namesInScope,_unboundNames,_scopeInfo) = rule2682 _bodyIdeclVarNames _bodyIunboundNames _initialScope
_bodyOcounter = rule2683 ()
_bodyOmatchIO = rule2684 ()
_bodyOallPatterns = rule2685 _lhsIimportEnvironment
_bodyOpatternMatchWarnings = rule2686 ()
_self = rule2687 _bodyIself _exportsIself _nameIself _rangeIself
_lhsOself :: Module
_lhsOself = rule2688 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule2689 _assumptions
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2690 _bodyIinfoTree
_lhsOlogEntries :: LogEntries
_lhsOlogEntries = rule2691 _logEntries
_lhsOsolveResult :: SolveResult ConstraintInfo
_lhsOsolveResult = rule2692 _solveResult
_lhsOtoplevelTypes :: TypeEnvironment
_lhsOtoplevelTypes = rule2693 _bodyItoplevelTypes
_lhsOtypeErrors :: TypeErrors
_lhsOtypeErrors = rule2694 _typeErrors
_bodyOimportEnvironment = rule2695 _lhsIimportEnvironment
_bodyOmonos = rule2696 _monos
_bodyOnamesInScope = rule2697 _namesInScope
_bodyOorderedTypeSynonyms = rule2698 _orderedTypeSynonyms
_bodyOsubstitution = rule2699 _substitution
__result_ = T_Module_vOut109 _lhsOassumptions _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOlogEntries _lhsOself _lhsOsolveResult _lhsOtoplevelTypes _lhsOtypeErrors _lhsOwarnings
in __result_ )
in C_Module_s110 v109
{-# INLINE rule2660 #-}
rule2660 = \ ((_bodyIpatternMatchWarnings) :: [Warning]) _warnings ->
_warnings ++ _bodyIpatternMatchWarnings
{-# INLINE rule2661 #-}
rule2661 = \ _solveResult ->
_solveResult
{-# INLINE rule2662 #-}
rule2662 = \ ((_bodyIbetaUnique) :: Int) ((_bodyIconstraints) :: ConstraintSet) _classEnv ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIoptions) :: [Option]) _orderedTypeSynonyms ->
(selectConstraintSolver _lhsIoptions _lhsIimportEnvironment)
_classEnv
_orderedTypeSynonyms
_bodyIbetaUnique
_bodyIconstraints
{-# INLINE rule2663 #-}
rule2663 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
getOrderedTypeSynonyms _lhsIimportEnvironment
{-# INLINE rule2664 #-}
rule2664 = \ ((_bodyIcollectInstances) :: [(Name, Instance)]) ((_lhsIimportEnvironment) :: ImportEnvironment) ->
foldr (\(n, i) -> insertInstance (show n) i)
(createClassEnvironment _lhsIimportEnvironment)
_bodyIcollectInstances
{-# INLINE rule2665 #-}
rule2665 = \ ((_bodyIcollectErrors) :: TypeErrors) _classEnv ((_lhsIoptions) :: [Option]) _orderedTypeSynonyms _solveErrors _substitution ->
case makeTypeErrors _lhsIoptions _classEnv _orderedTypeSynonyms _substitution _solveErrors of
[] -> if NoOverloadingTypeCheck `elem` _lhsIoptions
then filter (\(TypeError _ ms _ _) -> not $ isInfixOf "Illegal overloaded type" $ show ms) _bodyIcollectErrors
else _bodyIcollectErrors
errs -> reverse errs
{-# INLINE rule2666 #-}
rule2666 = \ ((_bodyIcollectWarnings) :: Warnings) ->
_bodyIcollectWarnings
{-# INLINE rule2667 #-}
rule2667 = \ ((_bodyIassumptions) :: Assumptions) _substitution ->
let f xs = [ (n, _substitution |-> tp) | (n, tp) <- xs ]
in M.map f _bodyIassumptions
{-# INLINE rule2668 #-}
rule2668 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
M.keys (typeEnvironment _lhsIimportEnvironment)
{-# INLINE rule2669 #-}
rule2669 = \ _monomorphics ->
map TVar _monomorphics
{-# INLINE rule2670 #-}
rule2670 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
ftv ( (M.elems $ valueConstructors _lhsIimportEnvironment)
++ (M.elems $ typeEnvironment _lhsIimportEnvironment)
)
{-# INLINE rule2671 #-}
rule2671 = \ _typeschemeMap ->
M.fromList (M.assocs _typeschemeMap)
{-# INLINE rule2672 #-}
rule2672 = \ _monomorphics ->
if null _monomorphics
then 0
else maximum _monomorphics + 1
{-# INLINE rule2673 #-}
rule2673 = \ ((_bodyIdictionaryEnvironment) :: DictionaryEnvironment) ((_lhsIoptions) :: [Option]) ->
if Overloading `elem` _lhsIoptions
then _bodyIdictionaryEnvironment
else emptyDictionaryEnvironment
{-# INLINE rule2674 #-}
rule2674 = \ (_ :: ()) ->
emptyDictionaryEnvironment
{-# INLINE rule2675 #-}
rule2675 = \ _classEnv ->
_classEnv
{-# INLINE rule2676 #-}
rule2676 = \ (_ :: ()) ->
[]
{-# INLINE rule2677 #-}
rule2677 = \ (_ :: ()) ->
[]
{-# INLINE rule2678 #-}
rule2678 = \ (_ :: ()) ->
[]
{-# INLINE rule2679 #-}
rule2679 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
M.fromList [ (NameWithRange name, scheme) | (name, scheme) <- M.assocs (typeEnvironment _lhsIimportEnvironment) ]
{-# INLINE rule2680 #-}
rule2680 = \ (_ :: ()) ->
0
{-# INLINE rule2681 #-}
rule2681 = \ (_ :: ()) ->
1
{-# INLINE rule2682 #-}
rule2682 = \ ((_bodyIdeclVarNames) :: Names) ((_bodyIunboundNames) :: Names) _initialScope ->
changeOfScope (_initialScope ++ _bodyIdeclVarNames) _bodyIunboundNames []
{-# INLINE rule2683 #-}
rule2683 = \ (_ :: ()) ->
0
{-# INLINE rule2684 #-}
rule2684 = \ (_ :: ()) ->
return ()
{-# INLINE rule2685 #-}
rule2685 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
[ (matchInfo, typingStrategy)
| typingStrategy <- typingStrategies _lhsIimportEnvironment
, matchInfo <- matchInformation
_lhsIimportEnvironment
typingStrategy
]
{-# INLINE rule2686 #-}
rule2686 = \ (_ :: ()) ->
[]
{-# INLINE rule2687 #-}
rule2687 = \ ((_bodyIself) :: Body) ((_exportsIself) :: MaybeExports) ((_nameIself) :: MaybeName) ((_rangeIself) :: Range) ->
Module_Module _rangeIself _nameIself _exportsIself _bodyIself
{-# INLINE rule2688 #-}
rule2688 = \ _self ->
_self
{-# INLINE rule2689 #-}
rule2689 = \ _assumptions ->
_assumptions
{-# INLINE rule2690 #-}
rule2690 = \ ((_bodyIinfoTree) :: InfoTree) ->
_bodyIinfoTree
{-# INLINE rule2691 #-}
rule2691 = \ _logEntries ->
_logEntries
{-# INLINE rule2692 #-}
rule2692 = \ _solveResult ->
_solveResult
{-# INLINE rule2693 #-}
rule2693 = \ ((_bodyItoplevelTypes) :: TypeEnvironment) ->
_bodyItoplevelTypes
{-# INLINE rule2694 #-}
rule2694 = \ _typeErrors ->
_typeErrors
{-# INLINE rule2695 #-}
rule2695 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2696 #-}
rule2696 = \ _monos ->
_monos
{-# INLINE rule2697 #-}
rule2697 = \ _namesInScope ->
_namesInScope
{-# INLINE rule2698 #-}
rule2698 = \ _orderedTypeSynonyms ->
_orderedTypeSynonyms
{-# INLINE rule2699 #-}
rule2699 = \ _substitution ->
_substitution
-- Name --------------------------------------------------------
-- wrapper
data Inh_Name = Inh_Name { }
data Syn_Name = Syn_Name { self_Syn_Name :: (Name) }
{-# INLINABLE wrap_Name #-}
wrap_Name :: T_Name -> Inh_Name -> (Syn_Name )
wrap_Name (T_Name act) (Inh_Name ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Name_vIn112
(T_Name_vOut112 _lhsOself) <- return (inv_Name_s113 sem arg)
return (Syn_Name _lhsOself)
)
-- cata
{-# NOINLINE sem_Name #-}
sem_Name :: Name -> T_Name
sem_Name ( Name_Identifier range_ module_ name_ ) = sem_Name_Identifier ( sem_Range range_ ) ( sem_Strings module_ ) name_
sem_Name ( Name_Operator range_ module_ name_ ) = sem_Name_Operator ( sem_Range range_ ) ( sem_Strings module_ ) name_
sem_Name ( Name_Special range_ module_ name_ ) = sem_Name_Special ( sem_Range range_ ) ( sem_Strings module_ ) name_
-- semantic domain
newtype T_Name = T_Name {
attach_T_Name :: Identity (T_Name_s113 )
}
newtype T_Name_s113 = C_Name_s113 {
inv_Name_s113 :: (T_Name_v112 )
}
data T_Name_s114 = C_Name_s114
type T_Name_v112 = (T_Name_vIn112 ) -> (T_Name_vOut112 )
data T_Name_vIn112 = T_Name_vIn112
data T_Name_vOut112 = T_Name_vOut112 (Name)
{-# NOINLINE sem_Name_Identifier #-}
sem_Name_Identifier :: T_Range -> T_Strings -> (String) -> T_Name
sem_Name_Identifier arg_range_ arg_module_ arg_name_ = T_Name (return st113) where
{-# NOINLINE st113 #-}
st113 = let
v112 :: T_Name_v112
v112 = \ (T_Name_vIn112 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_moduleX161 = Control.Monad.Identity.runIdentity (attach_T_Strings (arg_module_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Strings_vOut160 _moduleIself) = inv_Strings_s161 _moduleX161 (T_Strings_vIn160 )
_self = rule2700 _moduleIself _rangeIself arg_name_
_lhsOself :: Name
_lhsOself = rule2701 _self
__result_ = T_Name_vOut112 _lhsOself
in __result_ )
in C_Name_s113 v112
{-# INLINE rule2700 #-}
rule2700 = \ ((_moduleIself) :: Strings) ((_rangeIself) :: Range) name_ ->
Name_Identifier _rangeIself _moduleIself name_
{-# INLINE rule2701 #-}
rule2701 = \ _self ->
_self
{-# NOINLINE sem_Name_Operator #-}
sem_Name_Operator :: T_Range -> T_Strings -> (String) -> T_Name
sem_Name_Operator arg_range_ arg_module_ arg_name_ = T_Name (return st113) where
{-# NOINLINE st113 #-}
st113 = let
v112 :: T_Name_v112
v112 = \ (T_Name_vIn112 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_moduleX161 = Control.Monad.Identity.runIdentity (attach_T_Strings (arg_module_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Strings_vOut160 _moduleIself) = inv_Strings_s161 _moduleX161 (T_Strings_vIn160 )
_self = rule2702 _moduleIself _rangeIself arg_name_
_lhsOself :: Name
_lhsOself = rule2703 _self
__result_ = T_Name_vOut112 _lhsOself
in __result_ )
in C_Name_s113 v112
{-# INLINE rule2702 #-}
rule2702 = \ ((_moduleIself) :: Strings) ((_rangeIself) :: Range) name_ ->
Name_Operator _rangeIself _moduleIself name_
{-# INLINE rule2703 #-}
rule2703 = \ _self ->
_self
{-# NOINLINE sem_Name_Special #-}
sem_Name_Special :: T_Range -> T_Strings -> (String) -> T_Name
sem_Name_Special arg_range_ arg_module_ arg_name_ = T_Name (return st113) where
{-# NOINLINE st113 #-}
st113 = let
v112 :: T_Name_v112
v112 = \ (T_Name_vIn112 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_moduleX161 = Control.Monad.Identity.runIdentity (attach_T_Strings (arg_module_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Strings_vOut160 _moduleIself) = inv_Strings_s161 _moduleX161 (T_Strings_vIn160 )
_self = rule2704 _moduleIself _rangeIself arg_name_
_lhsOself :: Name
_lhsOself = rule2705 _self
__result_ = T_Name_vOut112 _lhsOself
in __result_ )
in C_Name_s113 v112
{-# INLINE rule2704 #-}
rule2704 = \ ((_moduleIself) :: Strings) ((_rangeIself) :: Range) name_ ->
Name_Special _rangeIself _moduleIself name_
{-# INLINE rule2705 #-}
rule2705 = \ _self ->
_self
-- Names -------------------------------------------------------
-- wrapper
data Inh_Names = Inh_Names { }
data Syn_Names = Syn_Names { self_Syn_Names :: (Names) }
{-# INLINABLE wrap_Names #-}
wrap_Names :: T_Names -> Inh_Names -> (Syn_Names )
wrap_Names (T_Names act) (Inh_Names ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Names_vIn115
(T_Names_vOut115 _lhsOself) <- return (inv_Names_s116 sem arg)
return (Syn_Names _lhsOself)
)
-- cata
{-# NOINLINE sem_Names #-}
sem_Names :: Names -> T_Names
sem_Names list = Prelude.foldr sem_Names_Cons sem_Names_Nil (Prelude.map sem_Name list)
-- semantic domain
newtype T_Names = T_Names {
attach_T_Names :: Identity (T_Names_s116 )
}
newtype T_Names_s116 = C_Names_s116 {
inv_Names_s116 :: (T_Names_v115 )
}
data T_Names_s117 = C_Names_s117
type T_Names_v115 = (T_Names_vIn115 ) -> (T_Names_vOut115 )
data T_Names_vIn115 = T_Names_vIn115
data T_Names_vOut115 = T_Names_vOut115 (Names)
{-# NOINLINE sem_Names_Cons #-}
sem_Names_Cons :: T_Name -> T_Names -> T_Names
sem_Names_Cons arg_hd_ arg_tl_ = T_Names (return st116) where
{-# NOINLINE st116 #-}
st116 = let
v115 :: T_Names_v115
v115 = \ (T_Names_vIn115 ) -> ( let
_hdX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_hd_))
_tlX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_tl_))
(T_Name_vOut112 _hdIself) = inv_Name_s113 _hdX113 (T_Name_vIn112 )
(T_Names_vOut115 _tlIself) = inv_Names_s116 _tlX116 (T_Names_vIn115 )
_self = rule2706 _hdIself _tlIself
_lhsOself :: Names
_lhsOself = rule2707 _self
__result_ = T_Names_vOut115 _lhsOself
in __result_ )
in C_Names_s116 v115
{-# INLINE rule2706 #-}
rule2706 = \ ((_hdIself) :: Name) ((_tlIself) :: Names) ->
(:) _hdIself _tlIself
{-# INLINE rule2707 #-}
rule2707 = \ _self ->
_self
{-# NOINLINE sem_Names_Nil #-}
sem_Names_Nil :: T_Names
sem_Names_Nil = T_Names (return st116) where
{-# NOINLINE st116 #-}
st116 = let
v115 :: T_Names_v115
v115 = \ (T_Names_vIn115 ) -> ( let
_self = rule2708 ()
_lhsOself :: Names
_lhsOself = rule2709 _self
__result_ = T_Names_vOut115 _lhsOself
in __result_ )
in C_Names_s116 v115
{-# INLINE rule2708 #-}
rule2708 = \ (_ :: ()) ->
[]
{-# INLINE rule2709 #-}
rule2709 = \ _self ->
_self
-- Pattern -----------------------------------------------------
-- wrapper
data Inh_Pattern = Inh_Pattern { betaUnique_Inh_Pattern :: (Int), counter_Inh_Pattern :: (Int), importEnvironment_Inh_Pattern :: (ImportEnvironment), monos_Inh_Pattern :: (Monos), namesInScope_Inh_Pattern :: (Names), parentTree_Inh_Pattern :: (InfoTree), patternMatchWarnings_Inh_Pattern :: ([Warning]) }
data Syn_Pattern = Syn_Pattern { beta_Syn_Pattern :: (Tp), betaUnique_Syn_Pattern :: (Int), constraints_Syn_Pattern :: (ConstraintSet), counter_Syn_Pattern :: (Int), elements_Syn_Pattern :: ( [PatternElement] ), environment_Syn_Pattern :: (PatternAssumptions), infoTree_Syn_Pattern :: (InfoTree), patVarNames_Syn_Pattern :: (Names), patternMatchWarnings_Syn_Pattern :: ([Warning]), self_Syn_Pattern :: (Pattern), unboundNames_Syn_Pattern :: (Names) }
{-# INLINABLE wrap_Pattern #-}
wrap_Pattern :: T_Pattern -> Inh_Pattern -> (Syn_Pattern )
wrap_Pattern (T_Pattern act) (Inh_Pattern _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings
(T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames) <- return (inv_Pattern_s119 sem arg)
return (Syn_Pattern _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames)
)
-- cata
{-# NOINLINE sem_Pattern #-}
sem_Pattern :: Pattern -> T_Pattern
sem_Pattern ( Pattern_Hole range_ id_ ) = sem_Pattern_Hole ( sem_Range range_ ) id_
sem_Pattern ( Pattern_Literal range_ literal_ ) = sem_Pattern_Literal ( sem_Range range_ ) ( sem_Literal literal_ )
sem_Pattern ( Pattern_Variable range_ name_ ) = sem_Pattern_Variable ( sem_Range range_ ) ( sem_Name name_ )
sem_Pattern ( Pattern_Constructor range_ name_ patterns_ ) = sem_Pattern_Constructor ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Patterns patterns_ )
sem_Pattern ( Pattern_Parenthesized range_ pattern_ ) = sem_Pattern_Parenthesized ( sem_Range range_ ) ( sem_Pattern pattern_ )
sem_Pattern ( Pattern_InfixConstructor range_ leftPattern_ constructorOperator_ rightPattern_ ) = sem_Pattern_InfixConstructor ( sem_Range range_ ) ( sem_Pattern leftPattern_ ) ( sem_Name constructorOperator_ ) ( sem_Pattern rightPattern_ )
sem_Pattern ( Pattern_List range_ patterns_ ) = sem_Pattern_List ( sem_Range range_ ) ( sem_Patterns patterns_ )
sem_Pattern ( Pattern_Tuple range_ patterns_ ) = sem_Pattern_Tuple ( sem_Range range_ ) ( sem_Patterns patterns_ )
sem_Pattern ( Pattern_Record range_ name_ recordPatternBindings_ ) = sem_Pattern_Record ( sem_Range range_ ) ( sem_Name name_ ) ( sem_RecordPatternBindings recordPatternBindings_ )
sem_Pattern ( Pattern_Negate range_ literal_ ) = sem_Pattern_Negate ( sem_Range range_ ) ( sem_Literal literal_ )
sem_Pattern ( Pattern_As range_ name_ pattern_ ) = sem_Pattern_As ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Pattern pattern_ )
sem_Pattern ( Pattern_Wildcard range_ ) = sem_Pattern_Wildcard ( sem_Range range_ )
sem_Pattern ( Pattern_Irrefutable range_ pattern_ ) = sem_Pattern_Irrefutable ( sem_Range range_ ) ( sem_Pattern pattern_ )
sem_Pattern ( Pattern_Successor range_ name_ literal_ ) = sem_Pattern_Successor ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Literal literal_ )
sem_Pattern ( Pattern_NegateFloat range_ literal_ ) = sem_Pattern_NegateFloat ( sem_Range range_ ) ( sem_Literal literal_ )
-- semantic domain
newtype T_Pattern = T_Pattern {
attach_T_Pattern :: Identity (T_Pattern_s119 )
}
newtype T_Pattern_s119 = C_Pattern_s119 {
inv_Pattern_s119 :: (T_Pattern_v118 )
}
data T_Pattern_s120 = C_Pattern_s120
type T_Pattern_v118 = (T_Pattern_vIn118 ) -> (T_Pattern_vOut118 )
data T_Pattern_vIn118 = T_Pattern_vIn118 (Int) (Int) (ImportEnvironment) (Monos) (Names) (InfoTree) ([Warning])
data T_Pattern_vOut118 = T_Pattern_vOut118 (Tp) (Int) (ConstraintSet) (Int) ( [PatternElement] ) (PatternAssumptions) (InfoTree) (Names) ([Warning]) (Pattern) (Names)
{-# NOINLINE sem_Pattern_Hole #-}
sem_Pattern_Hole :: T_Range -> (Integer) -> T_Pattern
sem_Pattern_Hole arg_range_ arg_id_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2710 _lhsIbetaUnique
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2711 ()
_constraints = rule2712 ()
_beta = rule2713 _lhsIbetaUnique
_localInfo = rule2714 _beta _lhsImonos _self
_parentTree = rule2715 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2716 _parentTree
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2717 _i
_lhsOelements :: [PatternElement]
_lhsOelements = rule2718 ()
_lhsOcounter :: Int
_i :: Int
(_lhsOcounter,_i) = rule2719 _lhsIcounter
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2720 ()
_self = rule2721 _rangeIself arg_id_
_lhsOself :: Pattern
_lhsOself = rule2722 _self
_lhsObeta :: Tp
_lhsObeta = rule2723 _beta
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2724 _constraints
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2725 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2710 #-}
rule2710 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule2711 #-}
rule2711 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule2712 #-}
rule2712 = \ (_ :: ()) ->
emptyTree
{-# INLINE rule2713 #-}
rule2713 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule2714 #-}
rule2714 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Pat _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule2715 #-}
rule2715 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule2716 #-}
rule2716 = \ _parentTree ->
_parentTree
{-# INLINE rule2717 #-}
rule2717 = \ ((_i) :: Int) ->
[ Name_Special noRange [] ("hole" ++ show _i ) ]
{-# INLINE rule2718 #-}
rule2718 = \ (_ :: ()) ->
[FiniteElement hole]
{-# INLINE rule2719 #-}
rule2719 = \ ((_lhsIcounter) :: Int) ->
let __cont = _lhsIcounter in seq __cont ( case nextUnique __cont of { (__cont, i) -> (__cont,i)} )
{-# INLINE rule2720 #-}
rule2720 = \ (_ :: ()) ->
[]
{-# INLINE rule2721 #-}
rule2721 = \ ((_rangeIself) :: Range) id_ ->
Pattern_Hole _rangeIself id_
{-# INLINE rule2722 #-}
rule2722 = \ _self ->
_self
{-# INLINE rule2723 #-}
rule2723 = \ _beta ->
_beta
{-# INLINE rule2724 #-}
rule2724 = \ _constraints ->
_constraints
{-# INLINE rule2725 #-}
rule2725 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Literal #-}
sem_Pattern_Literal :: T_Range -> T_Literal -> T_Pattern
sem_Pattern_Literal arg_range_ arg_literal_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_literalX86 = Control.Monad.Identity.runIdentity (attach_T_Literal (arg_literal_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Literal_vOut85 _literalIelements _literalIliteralType _literalIself) = inv_Literal_s86 _literalX86 (T_Literal_vIn85 )
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2726 _lhsIbetaUnique
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2727 ()
_constraints = rule2728 _beta _cinfo _literalIliteralType
_beta = rule2729 _lhsIbetaUnique
_cinfo = rule2730 _parentTree
_localInfo = rule2731 _beta _lhsImonos _self
_parentTree = rule2732 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2733 _parentTree
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2734 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2735 ()
_self = rule2736 _literalIself _rangeIself
_lhsOself :: Pattern
_lhsOself = rule2737 _self
_lhsObeta :: Tp
_lhsObeta = rule2738 _beta
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2739 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2740 _lhsIcounter
_lhsOelements :: [PatternElement]
_lhsOelements = rule2741 _literalIelements
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2742 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2726 #-}
rule2726 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule2727 #-}
rule2727 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule2728 #-}
rule2728 = \ _beta _cinfo ((_literalIliteralType) :: Tp) ->
unitTree ((_literalIliteralType .==. _beta) _cinfo)
{-# INLINE rule2729 #-}
rule2729 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule2730 #-}
rule2730 = \ _parentTree ->
resultConstraint "literal pattern" _parentTree
[ FolkloreConstraint, HasTrustFactor 10.0 ]
{-# INLINE rule2731 #-}
rule2731 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Pat _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule2732 #-}
rule2732 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule2733 #-}
rule2733 = \ _parentTree ->
_parentTree
{-# INLINE rule2734 #-}
rule2734 = \ (_ :: ()) ->
[]
{-# INLINE rule2735 #-}
rule2735 = \ (_ :: ()) ->
[]
{-# INLINE rule2736 #-}
rule2736 = \ ((_literalIself) :: Literal) ((_rangeIself) :: Range) ->
Pattern_Literal _rangeIself _literalIself
{-# INLINE rule2737 #-}
rule2737 = \ _self ->
_self
{-# INLINE rule2738 #-}
rule2738 = \ _beta ->
_beta
{-# INLINE rule2739 #-}
rule2739 = \ _constraints ->
_constraints
{-# INLINE rule2740 #-}
rule2740 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2741 #-}
rule2741 = \ ((_literalIelements) :: [PatternElement] ) ->
_literalIelements
{-# INLINE rule2742 #-}
rule2742 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Variable #-}
sem_Pattern_Variable :: T_Range -> T_Name -> T_Pattern
sem_Pattern_Variable arg_range_ arg_name_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2743 _lhsIbetaUnique
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2744 _beta _nameIself
_constraints = rule2745 _lhsIbetaUnique
_beta = rule2746 _lhsIbetaUnique
_localInfo = rule2747 _beta _lhsImonos _self
_parentTree = rule2748 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2749 _parentTree
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2750 _nameIself
_lhsOelements :: [PatternElement]
_lhsOelements = rule2751 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2752 ()
_self = rule2753 _nameIself _rangeIself
_lhsOself :: Pattern
_lhsOself = rule2754 _self
_lhsObeta :: Tp
_lhsObeta = rule2755 _beta
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2756 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2757 _lhsIcounter
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2758 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2743 #-}
rule2743 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule2744 #-}
rule2744 = \ _beta ((_nameIself) :: Name) ->
M.singleton _nameIself _beta
{-# INLINE rule2745 #-}
rule2745 = \ ((_lhsIbetaUnique) :: Int) ->
Receive _lhsIbetaUnique
{-# INLINE rule2746 #-}
rule2746 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule2747 #-}
rule2747 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Pat _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule2748 #-}
rule2748 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule2749 #-}
rule2749 = \ _parentTree ->
_parentTree
{-# INLINE rule2750 #-}
rule2750 = \ ((_nameIself) :: Name) ->
[ _nameIself ]
{-# INLINE rule2751 #-}
rule2751 = \ (_ :: ()) ->
[WildcardElement]
{-# INLINE rule2752 #-}
rule2752 = \ (_ :: ()) ->
[]
{-# INLINE rule2753 #-}
rule2753 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
Pattern_Variable _rangeIself _nameIself
{-# INLINE rule2754 #-}
rule2754 = \ _self ->
_self
{-# INLINE rule2755 #-}
rule2755 = \ _beta ->
_beta
{-# INLINE rule2756 #-}
rule2756 = \ _constraints ->
_constraints
{-# INLINE rule2757 #-}
rule2757 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2758 #-}
rule2758 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Constructor #-}
sem_Pattern_Constructor :: T_Range -> T_Name -> T_Patterns -> T_Pattern
sem_Pattern_Constructor arg_range_ arg_name_ arg_patterns_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_patternsX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_patterns_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_Patterns_vOut121 _patternsIbetaUnique _patternsIbetas _patternsIconstraintslist _patternsIcounter _patternsIelementss _patternsIenvironment _patternsIinfoTrees _patternsInumberOfPatterns _patternsIpatVarNames _patternsIpatternMatchWarnings _patternsIself _patternsIunboundNames) = inv_Patterns_s122 _patternsX122 (T_Patterns_vIn121 _patternsObetaUnique _patternsOcounter _patternsOimportEnvironment _patternsOmonos _patternsOnamesInScope _patternsOparentTree _patternsOpatternMatchWarnings)
_patternsObetaUnique = rule2759 _lhsIbetaUnique
_constraints = rule2760 _conApply _conConstructor _patternsIconstraintslist
_beta = rule2761 _lhsIbetaUnique
_betaCon = rule2762 _lhsIbetaUnique
_conApply = rule2763 _beta _betaCon _cinfoApply _cinfoEmpty _patternsIbetas _patternsInumberOfPatterns
_conConstructor = rule2764 _betaCon _cinfoConstructor _lhsIimportEnvironment _nameIself
_cinfoConstructor = rule2765 _parentTree
_cinfoApply = rule2766 _localInfo _nameIself _parentTree _patternsIinfoTrees
_cinfoEmpty = rule2767 _parentTree
_localInfo = rule2768 _beta _lhsImonos _self
_parentTree = rule2769 _lhsIparentTree _localInfo _patternsIinfoTrees
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2770 _parentTree
_lhsOelements :: [PatternElement]
_lhsOelements = rule2771 _nameIself _patternsIelementss
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2772 _patternsIpatVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2773 _patternsIunboundNames
_self = rule2774 _nameIself _patternsIself _rangeIself
_lhsOself :: Pattern
_lhsOself = rule2775 _self
_lhsObeta :: Tp
_lhsObeta = rule2776 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2777 _patternsIbetaUnique
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2778 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2779 _patternsIcounter
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2780 _patternsIenvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2781 _patternsIpatternMatchWarnings
_patternsOcounter = rule2782 _lhsIcounter
_patternsOimportEnvironment = rule2783 _lhsIimportEnvironment
_patternsOmonos = rule2784 _lhsImonos
_patternsOnamesInScope = rule2785 _lhsInamesInScope
_patternsOparentTree = rule2786 _parentTree
_patternsOpatternMatchWarnings = rule2787 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2759 #-}
rule2759 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 2
{-# INLINE rule2760 #-}
rule2760 = \ _conApply _conConstructor ((_patternsIconstraintslist) :: ConstraintSets) ->
_conApply .>.
Node [ listTree _conConstructor
, Node _patternsIconstraintslist
]
{-# INLINE rule2761 #-}
rule2761 = \ ((_lhsIbetaUnique) :: Int) ->
TVar (_lhsIbetaUnique)
{-# INLINE rule2762 #-}
rule2762 = \ ((_lhsIbetaUnique) :: Int) ->
TVar (_lhsIbetaUnique + 1)
{-# INLINE rule2763 #-}
rule2763 = \ _beta _betaCon _cinfoApply _cinfoEmpty ((_patternsIbetas) :: Tps) ((_patternsInumberOfPatterns) :: Int) ->
[ (_betaCon .==. foldr (.->.) _beta _patternsIbetas)
(if _patternsInumberOfPatterns == 0 then _cinfoEmpty else _cinfoApply) ]
{-# INLINE rule2764 #-}
rule2764 = \ _betaCon _cinfoConstructor ((_lhsIimportEnvironment) :: ImportEnvironment) ((_nameIself) :: Name) ->
case M.lookup _nameIself (valueConstructors _lhsIimportEnvironment) of
Nothing -> []
Just ctp -> [ (_betaCon .::. ctp) _cinfoConstructor ]
{-# INLINE rule2765 #-}
rule2765 = \ _parentTree ->
resultConstraint "pattern constructor" _parentTree
[ FolkloreConstraint, HasTrustFactor 10.0 ]
{-# INLINE rule2766 #-}
rule2766 = \ _localInfo ((_nameIself) :: Name) _parentTree ((_patternsIinfoTrees) :: InfoTrees) ->
specialConstraint "pattern application" _parentTree
(self _localInfo, Just $ nameToUHA_Pat _nameIself)
[ ApplicationEdge False (map attribute _patternsIinfoTrees) ]
{-# INLINE rule2767 #-}
rule2767 = \ _parentTree ->
resultConstraint "pattern constructor" _parentTree
[ HasTrustFactor 10.0 ]
{-# INLINE rule2768 #-}
rule2768 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Pat _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule2769 #-}
rule2769 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternsIinfoTrees) :: InfoTrees) ->
node _lhsIparentTree _localInfo _patternsIinfoTrees
{-# INLINE rule2770 #-}
rule2770 = \ _parentTree ->
_parentTree
{-# INLINE rule2771 #-}
rule2771 = \ ((_nameIself) :: Name) ((_patternsIelementss) :: [ [PatternElement] ]) ->
FiniteElement (getNameName _nameIself) : concat _patternsIelementss
{-# INLINE rule2772 #-}
rule2772 = \ ((_patternsIpatVarNames) :: Names) ->
_patternsIpatVarNames
{-# INLINE rule2773 #-}
rule2773 = \ ((_patternsIunboundNames) :: Names) ->
_patternsIunboundNames
{-# INLINE rule2774 #-}
rule2774 = \ ((_nameIself) :: Name) ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
Pattern_Constructor _rangeIself _nameIself _patternsIself
{-# INLINE rule2775 #-}
rule2775 = \ _self ->
_self
{-# INLINE rule2776 #-}
rule2776 = \ _beta ->
_beta
{-# INLINE rule2777 #-}
rule2777 = \ ((_patternsIbetaUnique) :: Int) ->
_patternsIbetaUnique
{-# INLINE rule2778 #-}
rule2778 = \ _constraints ->
_constraints
{-# INLINE rule2779 #-}
rule2779 = \ ((_patternsIcounter) :: Int) ->
_patternsIcounter
{-# INLINE rule2780 #-}
rule2780 = \ ((_patternsIenvironment) :: PatternAssumptions) ->
_patternsIenvironment
{-# INLINE rule2781 #-}
rule2781 = \ ((_patternsIpatternMatchWarnings) :: [Warning]) ->
_patternsIpatternMatchWarnings
{-# INLINE rule2782 #-}
rule2782 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2783 #-}
rule2783 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2784 #-}
rule2784 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2785 #-}
rule2785 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2786 #-}
rule2786 = \ _parentTree ->
_parentTree
{-# INLINE rule2787 #-}
rule2787 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Parenthesized #-}
sem_Pattern_Parenthesized :: T_Range -> T_Pattern -> T_Pattern
sem_Pattern_Parenthesized arg_range_ arg_pattern_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2788 _patternIpatVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2789 _patternIunboundNames
_self = rule2790 _patternIself _rangeIself
_lhsOself :: Pattern
_lhsOself = rule2791 _self
_lhsObeta :: Tp
_lhsObeta = rule2792 _patternIbeta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2793 _patternIbetaUnique
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2794 _patternIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule2795 _patternIcounter
_lhsOelements :: [PatternElement]
_lhsOelements = rule2796 _patternIelements
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2797 _patternIenvironment
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2798 _patternIinfoTree
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2799 _patternIpatternMatchWarnings
_patternObetaUnique = rule2800 _lhsIbetaUnique
_patternOcounter = rule2801 _lhsIcounter
_patternOimportEnvironment = rule2802 _lhsIimportEnvironment
_patternOmonos = rule2803 _lhsImonos
_patternOnamesInScope = rule2804 _lhsInamesInScope
_patternOparentTree = rule2805 _lhsIparentTree
_patternOpatternMatchWarnings = rule2806 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2788 #-}
rule2788 = \ ((_patternIpatVarNames) :: Names) ->
_patternIpatVarNames
{-# INLINE rule2789 #-}
rule2789 = \ ((_patternIunboundNames) :: Names) ->
_patternIunboundNames
{-# INLINE rule2790 #-}
rule2790 = \ ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
Pattern_Parenthesized _rangeIself _patternIself
{-# INLINE rule2791 #-}
rule2791 = \ _self ->
_self
{-# INLINE rule2792 #-}
rule2792 = \ ((_patternIbeta) :: Tp) ->
_patternIbeta
{-# INLINE rule2793 #-}
rule2793 = \ ((_patternIbetaUnique) :: Int) ->
_patternIbetaUnique
{-# INLINE rule2794 #-}
rule2794 = \ ((_patternIconstraints) :: ConstraintSet) ->
_patternIconstraints
{-# INLINE rule2795 #-}
rule2795 = \ ((_patternIcounter) :: Int) ->
_patternIcounter
{-# INLINE rule2796 #-}
rule2796 = \ ((_patternIelements) :: [PatternElement] ) ->
_patternIelements
{-# INLINE rule2797 #-}
rule2797 = \ ((_patternIenvironment) :: PatternAssumptions) ->
_patternIenvironment
{-# INLINE rule2798 #-}
rule2798 = \ ((_patternIinfoTree) :: InfoTree) ->
_patternIinfoTree
{-# INLINE rule2799 #-}
rule2799 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
_patternIpatternMatchWarnings
{-# INLINE rule2800 #-}
rule2800 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2801 #-}
rule2801 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2802 #-}
rule2802 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2803 #-}
rule2803 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2804 #-}
rule2804 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2805 #-}
rule2805 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2806 #-}
rule2806 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_InfixConstructor #-}
sem_Pattern_InfixConstructor :: T_Range -> T_Pattern -> T_Name -> T_Pattern -> T_Pattern
sem_Pattern_InfixConstructor arg_range_ arg_leftPattern_ arg_constructorOperator_ arg_rightPattern_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_leftPatternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_leftPattern_))
_constructorOperatorX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_constructorOperator_))
_rightPatternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_rightPattern_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Pattern_vOut118 _leftPatternIbeta _leftPatternIbetaUnique _leftPatternIconstraints _leftPatternIcounter _leftPatternIelements _leftPatternIenvironment _leftPatternIinfoTree _leftPatternIpatVarNames _leftPatternIpatternMatchWarnings _leftPatternIself _leftPatternIunboundNames) = inv_Pattern_s119 _leftPatternX119 (T_Pattern_vIn118 _leftPatternObetaUnique _leftPatternOcounter _leftPatternOimportEnvironment _leftPatternOmonos _leftPatternOnamesInScope _leftPatternOparentTree _leftPatternOpatternMatchWarnings)
(T_Name_vOut112 _constructorOperatorIself) = inv_Name_s113 _constructorOperatorX113 (T_Name_vIn112 )
(T_Pattern_vOut118 _rightPatternIbeta _rightPatternIbetaUnique _rightPatternIconstraints _rightPatternIcounter _rightPatternIelements _rightPatternIenvironment _rightPatternIinfoTree _rightPatternIpatVarNames _rightPatternIpatternMatchWarnings _rightPatternIself _rightPatternIunboundNames) = inv_Pattern_s119 _rightPatternX119 (T_Pattern_vIn118 _rightPatternObetaUnique _rightPatternOcounter _rightPatternOimportEnvironment _rightPatternOmonos _rightPatternOnamesInScope _rightPatternOparentTree _rightPatternOpatternMatchWarnings)
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2807 _leftPatternIenvironment _rightPatternIenvironment
_leftPatternObetaUnique = rule2808 _lhsIbetaUnique
_constraints = rule2809 _conApply _conConstructor _leftPatternIconstraints _rightPatternIconstraints
_beta = rule2810 _lhsIbetaUnique
_betaCon = rule2811 _lhsIbetaUnique
_conApply = rule2812 _beta _betaCon _cinfoApply _leftPatternIbeta _rightPatternIbeta
_conConstructor = rule2813 _betaCon _cinfoConstructor _constructorOperatorIself _lhsIimportEnvironment
_cinfoConstructor = rule2814 _constructorOperatorIself
_cinfoApply = rule2815 _constructorOperatorIself _leftPatternIinfoTree _localInfo _parentTree _rightPatternIinfoTree
_localInfo = rule2816 _beta _lhsImonos _self
_parentTree = rule2817 _leftPatternIinfoTree _lhsIparentTree _localInfo _rightPatternIinfoTree
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2818 _parentTree
_lhsOelements :: [PatternElement]
_lhsOelements = rule2819 _constructorOperatorIself _leftPatternIelements _rightPatternIelements
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2820 _leftPatternIpatVarNames _rightPatternIpatVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2821 _leftPatternIunboundNames _rightPatternIunboundNames
_self = rule2822 _constructorOperatorIself _leftPatternIself _rangeIself _rightPatternIself
_lhsOself :: Pattern
_lhsOself = rule2823 _self
_lhsObeta :: Tp
_lhsObeta = rule2824 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2825 _rightPatternIbetaUnique
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2826 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2827 _rightPatternIcounter
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2828 _rightPatternIpatternMatchWarnings
_leftPatternOcounter = rule2829 _lhsIcounter
_leftPatternOimportEnvironment = rule2830 _lhsIimportEnvironment
_leftPatternOmonos = rule2831 _lhsImonos
_leftPatternOnamesInScope = rule2832 _lhsInamesInScope
_leftPatternOparentTree = rule2833 _parentTree
_leftPatternOpatternMatchWarnings = rule2834 _lhsIpatternMatchWarnings
_rightPatternObetaUnique = rule2835 _leftPatternIbetaUnique
_rightPatternOcounter = rule2836 _leftPatternIcounter
_rightPatternOimportEnvironment = rule2837 _lhsIimportEnvironment
_rightPatternOmonos = rule2838 _lhsImonos
_rightPatternOnamesInScope = rule2839 _lhsInamesInScope
_rightPatternOparentTree = rule2840 _parentTree
_rightPatternOpatternMatchWarnings = rule2841 _leftPatternIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2807 #-}
rule2807 = \ ((_leftPatternIenvironment) :: PatternAssumptions) ((_rightPatternIenvironment) :: PatternAssumptions) ->
_leftPatternIenvironment `M.union` _rightPatternIenvironment
{-# INLINE rule2808 #-}
rule2808 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 2
{-# INLINE rule2809 #-}
rule2809 = \ _conApply _conConstructor ((_leftPatternIconstraints) :: ConstraintSet) ((_rightPatternIconstraints) :: ConstraintSet) ->
_conApply .>.
Node [ listTree _conConstructor
, _leftPatternIconstraints
, _rightPatternIconstraints
]
{-# INLINE rule2810 #-}
rule2810 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule2811 #-}
rule2811 = \ ((_lhsIbetaUnique) :: Int) ->
TVar (_lhsIbetaUnique + 1)
{-# INLINE rule2812 #-}
rule2812 = \ _beta _betaCon _cinfoApply ((_leftPatternIbeta) :: Tp) ((_rightPatternIbeta) :: Tp) ->
[ (_betaCon .==. _leftPatternIbeta .->. _rightPatternIbeta .->. _beta) _cinfoApply ]
{-# INLINE rule2813 #-}
rule2813 = \ _betaCon _cinfoConstructor ((_constructorOperatorIself) :: Name) ((_lhsIimportEnvironment) :: ImportEnvironment) ->
case M.lookup _constructorOperatorIself (valueConstructors _lhsIimportEnvironment) of
Nothing -> []
Just ctp -> [ (_betaCon .::. ctp) _cinfoConstructor ]
{-# INLINE rule2814 #-}
rule2814 = \ ((_constructorOperatorIself) :: Name) ->
variableConstraint "pattern constructor" (nameToUHA_Pat _constructorOperatorIself)
[ FolkloreConstraint, HasTrustFactor 10.0 ]
{-# INLINE rule2815 #-}
rule2815 = \ ((_constructorOperatorIself) :: Name) ((_leftPatternIinfoTree) :: InfoTree) _localInfo _parentTree ((_rightPatternIinfoTree) :: InfoTree) ->
specialConstraint "infix pattern application" _parentTree
(self _localInfo, Just $ nameToUHA_Pat _constructorOperatorIself)
[ ApplicationEdge True (map attribute [_leftPatternIinfoTree, _rightPatternIinfoTree]) ]
{-# INLINE rule2816 #-}
rule2816 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Pat _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule2817 #-}
rule2817 = \ ((_leftPatternIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_rightPatternIinfoTree) :: InfoTree) ->
node _lhsIparentTree _localInfo [_leftPatternIinfoTree, _rightPatternIinfoTree]
{-# INLINE rule2818 #-}
rule2818 = \ _parentTree ->
_parentTree
{-# INLINE rule2819 #-}
rule2819 = \ ((_constructorOperatorIself) :: Name) ((_leftPatternIelements) :: [PatternElement] ) ((_rightPatternIelements) :: [PatternElement] ) ->
FiniteElement (getNameName _constructorOperatorIself) : _leftPatternIelements ++ _rightPatternIelements
{-# INLINE rule2820 #-}
rule2820 = \ ((_leftPatternIpatVarNames) :: Names) ((_rightPatternIpatVarNames) :: Names) ->
_leftPatternIpatVarNames ++ _rightPatternIpatVarNames
{-# INLINE rule2821 #-}
rule2821 = \ ((_leftPatternIunboundNames) :: Names) ((_rightPatternIunboundNames) :: Names) ->
_leftPatternIunboundNames ++ _rightPatternIunboundNames
{-# INLINE rule2822 #-}
rule2822 = \ ((_constructorOperatorIself) :: Name) ((_leftPatternIself) :: Pattern) ((_rangeIself) :: Range) ((_rightPatternIself) :: Pattern) ->
Pattern_InfixConstructor _rangeIself _leftPatternIself _constructorOperatorIself _rightPatternIself
{-# INLINE rule2823 #-}
rule2823 = \ _self ->
_self
{-# INLINE rule2824 #-}
rule2824 = \ _beta ->
_beta
{-# INLINE rule2825 #-}
rule2825 = \ ((_rightPatternIbetaUnique) :: Int) ->
_rightPatternIbetaUnique
{-# INLINE rule2826 #-}
rule2826 = \ _constraints ->
_constraints
{-# INLINE rule2827 #-}
rule2827 = \ ((_rightPatternIcounter) :: Int) ->
_rightPatternIcounter
{-# INLINE rule2828 #-}
rule2828 = \ ((_rightPatternIpatternMatchWarnings) :: [Warning]) ->
_rightPatternIpatternMatchWarnings
{-# INLINE rule2829 #-}
rule2829 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2830 #-}
rule2830 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2831 #-}
rule2831 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2832 #-}
rule2832 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2833 #-}
rule2833 = \ _parentTree ->
_parentTree
{-# INLINE rule2834 #-}
rule2834 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule2835 #-}
rule2835 = \ ((_leftPatternIbetaUnique) :: Int) ->
_leftPatternIbetaUnique
{-# INLINE rule2836 #-}
rule2836 = \ ((_leftPatternIcounter) :: Int) ->
_leftPatternIcounter
{-# INLINE rule2837 #-}
rule2837 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2838 #-}
rule2838 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2839 #-}
rule2839 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2840 #-}
rule2840 = \ _parentTree ->
_parentTree
{-# INLINE rule2841 #-}
rule2841 = \ ((_leftPatternIpatternMatchWarnings) :: [Warning]) ->
_leftPatternIpatternMatchWarnings
{-# NOINLINE sem_Pattern_List #-}
sem_Pattern_List :: T_Range -> T_Patterns -> T_Pattern
sem_Pattern_List arg_range_ arg_patterns_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_patternsX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_patterns_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Patterns_vOut121 _patternsIbetaUnique _patternsIbetas _patternsIconstraintslist _patternsIcounter _patternsIelementss _patternsIenvironment _patternsIinfoTrees _patternsInumberOfPatterns _patternsIpatVarNames _patternsIpatternMatchWarnings _patternsIself _patternsIunboundNames) = inv_Patterns_s122 _patternsX122 (T_Patterns_vIn121 _patternsObetaUnique _patternsOcounter _patternsOimportEnvironment _patternsOmonos _patternsOnamesInScope _patternsOparentTree _patternsOpatternMatchWarnings)
_patternsObetaUnique = rule2842 _lhsIbetaUnique
_constraints = rule2843 _newcon _patternsIbetas _patternsIconstraintslist _zipf
_beta = rule2844 _lhsIbetaUnique
_beta' = rule2845 _lhsIbetaUnique
_newcon = rule2846 _beta _beta' _cinfoResult
_zipf = rule2847 _beta' _cinfoElem
_cinfoElem = rule2848 _beta' _localInfo _parentTree _patternsIconstraintslist
_cinfoResult = rule2849 _parentTree
_localInfo = rule2850 _beta _lhsImonos _self
_parentTree = rule2851 _lhsIparentTree _localInfo _patternsIinfoTrees
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2852 _parentTree
_lhsOelements :: [PatternElement]
_lhsOelements = rule2853 _patternsIelementss
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2854 _patternsIpatVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2855 _patternsIunboundNames
_self = rule2856 _patternsIself _rangeIself
_lhsOself :: Pattern
_lhsOself = rule2857 _self
_lhsObeta :: Tp
_lhsObeta = rule2858 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2859 _patternsIbetaUnique
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2860 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2861 _patternsIcounter
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2862 _patternsIenvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2863 _patternsIpatternMatchWarnings
_patternsOcounter = rule2864 _lhsIcounter
_patternsOimportEnvironment = rule2865 _lhsIimportEnvironment
_patternsOmonos = rule2866 _lhsImonos
_patternsOnamesInScope = rule2867 _lhsInamesInScope
_patternsOparentTree = rule2868 _parentTree
_patternsOpatternMatchWarnings = rule2869 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2842 #-}
rule2842 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 2
{-# INLINE rule2843 #-}
rule2843 = \ _newcon ((_patternsIbetas) :: Tps) ((_patternsIconstraintslist) :: ConstraintSets) _zipf ->
_newcon .>.
Node (zipWith3 _zipf _patternsIbetas [0..] _patternsIconstraintslist)
{-# INLINE rule2844 #-}
rule2844 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule2845 #-}
rule2845 = \ ((_lhsIbetaUnique) :: Int) ->
TVar (_lhsIbetaUnique + 1)
{-# INLINE rule2846 #-}
rule2846 = \ _beta _beta' _cinfoResult ->
[ (listType _beta' .==. _beta) _cinfoResult ]
{-# INLINE rule2847 #-}
rule2847 = \ _beta' _cinfoElem ->
\tp elemNr ctree -> [ (tp .==. _beta') (_cinfoElem elemNr) ] .<. ctree
{-# INLINE rule2848 #-}
rule2848 = \ _beta' _localInfo _parentTree ((_patternsIconstraintslist) :: ConstraintSets) ->
\elemNr ->
childConstraint elemNr "element of pattern list" _parentTree $
[ HasTrustFactor 10.0 | length _patternsIconstraintslist < 2 ] ++
[ Unifier (head (ftv _beta')) ("pattern list", _localInfo, ordinal False (elemNr+1) ++ " element") ]
{-# INLINE rule2849 #-}
rule2849 = \ _parentTree ->
resultConstraint "pattern list" _parentTree
[ FolkloreConstraint ]
{-# INLINE rule2850 #-}
rule2850 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Pat _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule2851 #-}
rule2851 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternsIinfoTrees) :: InfoTrees) ->
node _lhsIparentTree _localInfo _patternsIinfoTrees
{-# INLINE rule2852 #-}
rule2852 = \ _parentTree ->
_parentTree
{-# INLINE rule2853 #-}
rule2853 = \ ((_patternsIelementss) :: [ [PatternElement] ]) ->
listPat _patternsIelementss
{-# INLINE rule2854 #-}
rule2854 = \ ((_patternsIpatVarNames) :: Names) ->
_patternsIpatVarNames
{-# INLINE rule2855 #-}
rule2855 = \ ((_patternsIunboundNames) :: Names) ->
_patternsIunboundNames
{-# INLINE rule2856 #-}
rule2856 = \ ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
Pattern_List _rangeIself _patternsIself
{-# INLINE rule2857 #-}
rule2857 = \ _self ->
_self
{-# INLINE rule2858 #-}
rule2858 = \ _beta ->
_beta
{-# INLINE rule2859 #-}
rule2859 = \ ((_patternsIbetaUnique) :: Int) ->
_patternsIbetaUnique
{-# INLINE rule2860 #-}
rule2860 = \ _constraints ->
_constraints
{-# INLINE rule2861 #-}
rule2861 = \ ((_patternsIcounter) :: Int) ->
_patternsIcounter
{-# INLINE rule2862 #-}
rule2862 = \ ((_patternsIenvironment) :: PatternAssumptions) ->
_patternsIenvironment
{-# INLINE rule2863 #-}
rule2863 = \ ((_patternsIpatternMatchWarnings) :: [Warning]) ->
_patternsIpatternMatchWarnings
{-# INLINE rule2864 #-}
rule2864 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2865 #-}
rule2865 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2866 #-}
rule2866 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2867 #-}
rule2867 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2868 #-}
rule2868 = \ _parentTree ->
_parentTree
{-# INLINE rule2869 #-}
rule2869 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Tuple #-}
sem_Pattern_Tuple :: T_Range -> T_Patterns -> T_Pattern
sem_Pattern_Tuple arg_range_ arg_patterns_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_patternsX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_patterns_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Patterns_vOut121 _patternsIbetaUnique _patternsIbetas _patternsIconstraintslist _patternsIcounter _patternsIelementss _patternsIenvironment _patternsIinfoTrees _patternsInumberOfPatterns _patternsIpatVarNames _patternsIpatternMatchWarnings _patternsIself _patternsIunboundNames) = inv_Patterns_s122 _patternsX122 (T_Patterns_vIn121 _patternsObetaUnique _patternsOcounter _patternsOimportEnvironment _patternsOmonos _patternsOnamesInScope _patternsOparentTree _patternsOpatternMatchWarnings)
_patternsObetaUnique = rule2870 _lhsIbetaUnique
_constraints = rule2871 _newcon _patternsIconstraintslist
_beta = rule2872 _lhsIbetaUnique
_newcon = rule2873 _beta _cinfo _patternsIbetas
_cinfo = rule2874 _parentTree
_localInfo = rule2875 _beta _lhsImonos _self
_parentTree = rule2876 _lhsIparentTree _localInfo _patternsIinfoTrees
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2877 _parentTree
_lhsOelements :: [PatternElement]
_lhsOelements = rule2878 _patternsIelementss _patternsIself
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2879 _patternsIpatVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2880 _patternsIunboundNames
_self = rule2881 _patternsIself _rangeIself
_lhsOself :: Pattern
_lhsOself = rule2882 _self
_lhsObeta :: Tp
_lhsObeta = rule2883 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2884 _patternsIbetaUnique
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2885 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2886 _patternsIcounter
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2887 _patternsIenvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2888 _patternsIpatternMatchWarnings
_patternsOcounter = rule2889 _lhsIcounter
_patternsOimportEnvironment = rule2890 _lhsIimportEnvironment
_patternsOmonos = rule2891 _lhsImonos
_patternsOnamesInScope = rule2892 _lhsInamesInScope
_patternsOparentTree = rule2893 _parentTree
_patternsOpatternMatchWarnings = rule2894 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2870 #-}
rule2870 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule2871 #-}
rule2871 = \ _newcon ((_patternsIconstraintslist) :: ConstraintSets) ->
_newcon .>. Node _patternsIconstraintslist
{-# INLINE rule2872 #-}
rule2872 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule2873 #-}
rule2873 = \ _beta _cinfo ((_patternsIbetas) :: Tps) ->
[ (tupleType _patternsIbetas .==. _beta) _cinfo ]
{-# INLINE rule2874 #-}
rule2874 = \ _parentTree ->
resultConstraint "pattern tuple" _parentTree
[ FolkloreConstraint ]
{-# INLINE rule2875 #-}
rule2875 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Pat _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule2876 #-}
rule2876 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternsIinfoTrees) :: InfoTrees) ->
node _lhsIparentTree _localInfo _patternsIinfoTrees
{-# INLINE rule2877 #-}
rule2877 = \ _parentTree ->
_parentTree
{-# INLINE rule2878 #-}
rule2878 = \ ((_patternsIelementss) :: [ [PatternElement] ]) ((_patternsIself) :: Patterns) ->
FiniteElement ("(" ++ replicate (length $ tail _patternsIself) ',' ++ ")") : concat _patternsIelementss
{-# INLINE rule2879 #-}
rule2879 = \ ((_patternsIpatVarNames) :: Names) ->
_patternsIpatVarNames
{-# INLINE rule2880 #-}
rule2880 = \ ((_patternsIunboundNames) :: Names) ->
_patternsIunboundNames
{-# INLINE rule2881 #-}
rule2881 = \ ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
Pattern_Tuple _rangeIself _patternsIself
{-# INLINE rule2882 #-}
rule2882 = \ _self ->
_self
{-# INLINE rule2883 #-}
rule2883 = \ _beta ->
_beta
{-# INLINE rule2884 #-}
rule2884 = \ ((_patternsIbetaUnique) :: Int) ->
_patternsIbetaUnique
{-# INLINE rule2885 #-}
rule2885 = \ _constraints ->
_constraints
{-# INLINE rule2886 #-}
rule2886 = \ ((_patternsIcounter) :: Int) ->
_patternsIcounter
{-# INLINE rule2887 #-}
rule2887 = \ ((_patternsIenvironment) :: PatternAssumptions) ->
_patternsIenvironment
{-# INLINE rule2888 #-}
rule2888 = \ ((_patternsIpatternMatchWarnings) :: [Warning]) ->
_patternsIpatternMatchWarnings
{-# INLINE rule2889 #-}
rule2889 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2890 #-}
rule2890 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2891 #-}
rule2891 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2892 #-}
rule2892 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2893 #-}
rule2893 = \ _parentTree ->
_parentTree
{-# INLINE rule2894 #-}
rule2894 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Record #-}
sem_Pattern_Record :: T_Range -> T_Name -> T_RecordPatternBindings -> T_Pattern
sem_Pattern_Record arg_range_ arg_name_ arg_recordPatternBindings_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_recordPatternBindingsX146 = Control.Monad.Identity.runIdentity (attach_T_RecordPatternBindings (arg_recordPatternBindings_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_RecordPatternBindings_vOut145 _recordPatternBindingsIcounter _recordPatternBindingsIpatternMatchWarnings _recordPatternBindingsIself _recordPatternBindingsIunboundNames) = inv_RecordPatternBindings_s146 _recordPatternBindingsX146 (T_RecordPatternBindings_vIn145 _recordPatternBindingsOcounter _recordPatternBindingsOnamesInScope _recordPatternBindingsOpatternMatchWarnings)
_infoTree = rule2895 ()
(_beta,_constraints,_environment) = rule2896 ()
_lhsOelements :: [PatternElement]
_lhsOelements = rule2897 ()
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2898 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2899 _recordPatternBindingsIunboundNames
_self = rule2900 _nameIself _rangeIself _recordPatternBindingsIself
_lhsOself :: Pattern
_lhsOself = rule2901 _self
_lhsObeta :: Tp
_lhsObeta = rule2902 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2903 _lhsIbetaUnique
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2904 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2905 _recordPatternBindingsIcounter
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2906 _environment
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2907 _infoTree
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2908 _recordPatternBindingsIpatternMatchWarnings
_recordPatternBindingsOcounter = rule2909 _lhsIcounter
_recordPatternBindingsOnamesInScope = rule2910 _lhsInamesInScope
_recordPatternBindingsOpatternMatchWarnings = rule2911 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2895 #-}
rule2895 = \ (_ :: ()) ->
globalInfoError
{-# INLINE rule2896 #-}
rule2896 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "Pattern.Record"
{-# INLINE rule2897 #-}
rule2897 = \ (_ :: ()) ->
pmError "Pattern_Record.elements" "Records are not supported"
{-# INLINE rule2898 #-}
rule2898 = \ (_ :: ()) ->
[]
{-# INLINE rule2899 #-}
rule2899 = \ ((_recordPatternBindingsIunboundNames) :: Names) ->
_recordPatternBindingsIunboundNames
{-# INLINE rule2900 #-}
rule2900 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ((_recordPatternBindingsIself) :: RecordPatternBindings) ->
Pattern_Record _rangeIself _nameIself _recordPatternBindingsIself
{-# INLINE rule2901 #-}
rule2901 = \ _self ->
_self
{-# INLINE rule2902 #-}
rule2902 = \ _beta ->
_beta
{-# INLINE rule2903 #-}
rule2903 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2904 #-}
rule2904 = \ _constraints ->
_constraints
{-# INLINE rule2905 #-}
rule2905 = \ ((_recordPatternBindingsIcounter) :: Int) ->
_recordPatternBindingsIcounter
{-# INLINE rule2906 #-}
rule2906 = \ _environment ->
_environment
{-# INLINE rule2907 #-}
rule2907 = \ _infoTree ->
_infoTree
{-# INLINE rule2908 #-}
rule2908 = \ ((_recordPatternBindingsIpatternMatchWarnings) :: [Warning]) ->
_recordPatternBindingsIpatternMatchWarnings
{-# INLINE rule2909 #-}
rule2909 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2910 #-}
rule2910 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2911 #-}
rule2911 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Negate #-}
sem_Pattern_Negate :: T_Range -> T_Literal -> T_Pattern
sem_Pattern_Negate arg_range_ arg_literal_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_literalX86 = Control.Monad.Identity.runIdentity (attach_T_Literal (arg_literal_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Literal_vOut85 _literalIelements _literalIliteralType _literalIself) = inv_Literal_s86 _literalX86 (T_Literal_vIn85 )
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2912 _lhsIbetaUnique
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2913 ()
_constraints = rule2914 _newcon
_beta = rule2915 _lhsIbetaUnique
_newcon = rule2916 _beta _cinfo _lhsIimportEnvironment _literalIliteralType
_cinfo = rule2917 _parentTree
_localInfo = rule2918 _beta _lhsImonos _self
_parentTree = rule2919 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2920 _parentTree
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2921 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2922 ()
_self = rule2923 _literalIself _rangeIself
_lhsOself :: Pattern
_lhsOself = rule2924 _self
_lhsObeta :: Tp
_lhsObeta = rule2925 _beta
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2926 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2927 _lhsIcounter
_lhsOelements :: [PatternElement]
_lhsOelements = rule2928 _literalIelements
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2929 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2912 #-}
rule2912 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule2913 #-}
rule2913 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule2914 #-}
rule2914 = \ _newcon ->
listTree _newcon
{-# INLINE rule2915 #-}
rule2915 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule2916 #-}
rule2916 = \ _beta _cinfo ((_lhsIimportEnvironment) :: ImportEnvironment) ((_literalIliteralType) :: Tp) ->
let standard = makeScheme [] [Predicate "Num" (TVar 0)] (TVar 0 .->. TVar 0)
tpscheme = M.findWithDefault standard (nameFromString "negate") (typeEnvironment _lhsIimportEnvironment)
in [ (_literalIliteralType .->. _beta .::. tpscheme) _cinfo]
{-# INLINE rule2917 #-}
rule2917 = \ _parentTree ->
resultConstraint "pattern negation" _parentTree
[ FolkloreConstraint ]
{-# INLINE rule2918 #-}
rule2918 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Pat _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule2919 #-}
rule2919 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule2920 #-}
rule2920 = \ _parentTree ->
_parentTree
{-# INLINE rule2921 #-}
rule2921 = \ (_ :: ()) ->
[]
{-# INLINE rule2922 #-}
rule2922 = \ (_ :: ()) ->
[]
{-# INLINE rule2923 #-}
rule2923 = \ ((_literalIself) :: Literal) ((_rangeIself) :: Range) ->
Pattern_Negate _rangeIself _literalIself
{-# INLINE rule2924 #-}
rule2924 = \ _self ->
_self
{-# INLINE rule2925 #-}
rule2925 = \ _beta ->
_beta
{-# INLINE rule2926 #-}
rule2926 = \ _constraints ->
_constraints
{-# INLINE rule2927 #-}
rule2927 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2928 #-}
rule2928 = \ ((_literalIelements) :: [PatternElement] ) ->
_literalIelements
{-# INLINE rule2929 #-}
rule2929 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_As #-}
sem_Pattern_As :: T_Range -> T_Name -> T_Pattern -> T_Pattern
sem_Pattern_As arg_range_ arg_name_ arg_pattern_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2930 _beta _nameIself _patternIenvironment
_patternObetaUnique = rule2931 _lhsIbetaUnique
_constraints = rule2932 _lhsIbetaUnique _newcon _patternIconstraints
_beta = rule2933 _lhsIbetaUnique
_newcon = rule2934 _beta _cinfo _patternIbeta
_cinfo = rule2935 _localInfo _nameIself _parentTree
_localInfo = rule2936 _beta _lhsImonos _self
_parentTree = rule2937 _lhsIparentTree _localInfo _patternIinfoTree
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2938 _parentTree
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2939 _nameIself _patternIpatVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2940 _patternIunboundNames
_self = rule2941 _nameIself _patternIself _rangeIself
_lhsOself :: Pattern
_lhsOself = rule2942 _self
_lhsObeta :: Tp
_lhsObeta = rule2943 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2944 _patternIbetaUnique
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2945 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2946 _patternIcounter
_lhsOelements :: [PatternElement]
_lhsOelements = rule2947 _patternIelements
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2948 _patternIpatternMatchWarnings
_patternOcounter = rule2949 _lhsIcounter
_patternOimportEnvironment = rule2950 _lhsIimportEnvironment
_patternOmonos = rule2951 _lhsImonos
_patternOnamesInScope = rule2952 _lhsInamesInScope
_patternOparentTree = rule2953 _parentTree
_patternOpatternMatchWarnings = rule2954 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2930 #-}
rule2930 = \ _beta ((_nameIself) :: Name) ((_patternIenvironment) :: PatternAssumptions) ->
M.insert _nameIself _beta _patternIenvironment
{-# INLINE rule2931 #-}
rule2931 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule2932 #-}
rule2932 = \ ((_lhsIbetaUnique) :: Int) _newcon ((_patternIconstraints) :: ConstraintSet) ->
_newcon .>.
Node [ Receive _lhsIbetaUnique
, _patternIconstraints
]
{-# INLINE rule2933 #-}
rule2933 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule2934 #-}
rule2934 = \ _beta _cinfo ((_patternIbeta) :: Tp) ->
[ (_beta .==. _patternIbeta) _cinfo ]
{-# INLINE rule2935 #-}
rule2935 = \ _localInfo ((_nameIself) :: Name) _parentTree ->
specialConstraint "as pattern" _parentTree
(self _localInfo, Just $ nameToUHA_Pat _nameIself)
[]
{-# INLINE rule2936 #-}
rule2936 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Pat _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule2937 #-}
rule2937 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternIinfoTree) :: InfoTree) ->
node _lhsIparentTree _localInfo [_patternIinfoTree]
{-# INLINE rule2938 #-}
rule2938 = \ _parentTree ->
_parentTree
{-# INLINE rule2939 #-}
rule2939 = \ ((_nameIself) :: Name) ((_patternIpatVarNames) :: Names) ->
_nameIself : _patternIpatVarNames
{-# INLINE rule2940 #-}
rule2940 = \ ((_patternIunboundNames) :: Names) ->
_patternIunboundNames
{-# INLINE rule2941 #-}
rule2941 = \ ((_nameIself) :: Name) ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
Pattern_As _rangeIself _nameIself _patternIself
{-# INLINE rule2942 #-}
rule2942 = \ _self ->
_self
{-# INLINE rule2943 #-}
rule2943 = \ _beta ->
_beta
{-# INLINE rule2944 #-}
rule2944 = \ ((_patternIbetaUnique) :: Int) ->
_patternIbetaUnique
{-# INLINE rule2945 #-}
rule2945 = \ _constraints ->
_constraints
{-# INLINE rule2946 #-}
rule2946 = \ ((_patternIcounter) :: Int) ->
_patternIcounter
{-# INLINE rule2947 #-}
rule2947 = \ ((_patternIelements) :: [PatternElement] ) ->
_patternIelements
{-# INLINE rule2948 #-}
rule2948 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
_patternIpatternMatchWarnings
{-# INLINE rule2949 #-}
rule2949 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2950 #-}
rule2950 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2951 #-}
rule2951 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2952 #-}
rule2952 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2953 #-}
rule2953 = \ _parentTree ->
_parentTree
{-# INLINE rule2954 #-}
rule2954 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Wildcard #-}
sem_Pattern_Wildcard :: T_Range -> T_Pattern
sem_Pattern_Wildcard arg_range_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2955 _lhsIbetaUnique
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2956 ()
_constraints = rule2957 ()
_beta = rule2958 _lhsIbetaUnique
_localInfo = rule2959 _beta _lhsImonos _self
_parentTree = rule2960 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2961 _parentTree
_lhsOelements :: [PatternElement]
_lhsOelements = rule2962 ()
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2963 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2964 ()
_self = rule2965 _rangeIself
_lhsOself :: Pattern
_lhsOself = rule2966 _self
_lhsObeta :: Tp
_lhsObeta = rule2967 _beta
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2968 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule2969 _lhsIcounter
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2970 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2955 #-}
rule2955 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule2956 #-}
rule2956 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule2957 #-}
rule2957 = \ (_ :: ()) ->
emptyTree
{-# INLINE rule2958 #-}
rule2958 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule2959 #-}
rule2959 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Pat _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule2960 #-}
rule2960 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule2961 #-}
rule2961 = \ _parentTree ->
_parentTree
{-# INLINE rule2962 #-}
rule2962 = \ (_ :: ()) ->
[WildcardElement]
{-# INLINE rule2963 #-}
rule2963 = \ (_ :: ()) ->
[]
{-# INLINE rule2964 #-}
rule2964 = \ (_ :: ()) ->
[]
{-# INLINE rule2965 #-}
rule2965 = \ ((_rangeIself) :: Range) ->
Pattern_Wildcard _rangeIself
{-# INLINE rule2966 #-}
rule2966 = \ _self ->
_self
{-# INLINE rule2967 #-}
rule2967 = \ _beta ->
_beta
{-# INLINE rule2968 #-}
rule2968 = \ _constraints ->
_constraints
{-# INLINE rule2969 #-}
rule2969 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2970 #-}
rule2970 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Irrefutable #-}
sem_Pattern_Irrefutable :: T_Range -> T_Pattern -> T_Pattern
sem_Pattern_Irrefutable arg_range_ arg_pattern_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2971 _patternIpatVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2972 _patternIunboundNames
_self = rule2973 _patternIself _rangeIself
_lhsOself :: Pattern
_lhsOself = rule2974 _self
_lhsObeta :: Tp
_lhsObeta = rule2975 _patternIbeta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2976 _patternIbetaUnique
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2977 _patternIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule2978 _patternIcounter
_lhsOelements :: [PatternElement]
_lhsOelements = rule2979 _patternIelements
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule2980 _patternIenvironment
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule2981 _patternIinfoTree
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule2982 _patternIpatternMatchWarnings
_patternObetaUnique = rule2983 _lhsIbetaUnique
_patternOcounter = rule2984 _lhsIcounter
_patternOimportEnvironment = rule2985 _lhsIimportEnvironment
_patternOmonos = rule2986 _lhsImonos
_patternOnamesInScope = rule2987 _lhsInamesInScope
_patternOparentTree = rule2988 _lhsIparentTree
_patternOpatternMatchWarnings = rule2989 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2971 #-}
rule2971 = \ ((_patternIpatVarNames) :: Names) ->
_patternIpatVarNames
{-# INLINE rule2972 #-}
rule2972 = \ ((_patternIunboundNames) :: Names) ->
_patternIunboundNames
{-# INLINE rule2973 #-}
rule2973 = \ ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
Pattern_Irrefutable _rangeIself _patternIself
{-# INLINE rule2974 #-}
rule2974 = \ _self ->
_self
{-# INLINE rule2975 #-}
rule2975 = \ ((_patternIbeta) :: Tp) ->
_patternIbeta
{-# INLINE rule2976 #-}
rule2976 = \ ((_patternIbetaUnique) :: Int) ->
_patternIbetaUnique
{-# INLINE rule2977 #-}
rule2977 = \ ((_patternIconstraints) :: ConstraintSet) ->
_patternIconstraints
{-# INLINE rule2978 #-}
rule2978 = \ ((_patternIcounter) :: Int) ->
_patternIcounter
{-# INLINE rule2979 #-}
rule2979 = \ ((_patternIelements) :: [PatternElement] ) ->
_patternIelements
{-# INLINE rule2980 #-}
rule2980 = \ ((_patternIenvironment) :: PatternAssumptions) ->
_patternIenvironment
{-# INLINE rule2981 #-}
rule2981 = \ ((_patternIinfoTree) :: InfoTree) ->
_patternIinfoTree
{-# INLINE rule2982 #-}
rule2982 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
_patternIpatternMatchWarnings
{-# INLINE rule2983 #-}
rule2983 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2984 #-}
rule2984 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule2985 #-}
rule2985 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule2986 #-}
rule2986 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule2987 #-}
rule2987 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule2988 #-}
rule2988 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule2989 #-}
rule2989 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Successor #-}
sem_Pattern_Successor :: T_Range -> T_Name -> T_Literal -> T_Pattern
sem_Pattern_Successor arg_range_ arg_name_ arg_literal_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_literalX86 = Control.Monad.Identity.runIdentity (attach_T_Literal (arg_literal_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_Literal_vOut85 _literalIelements _literalIliteralType _literalIself) = inv_Literal_s86 _literalX86 (T_Literal_vIn85 )
_infoTree = rule2990 ()
(_beta,_constraints,_environment) = rule2991 ()
_lhsOelements :: [PatternElement]
_lhsOelements = rule2992 ()
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule2993 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule2994 ()
_self = rule2995 _literalIself _nameIself _rangeIself
_lhsOself :: Pattern
_lhsOself = rule2996 _self
_lhsObeta :: Tp
_lhsObeta = rule2997 _beta
_lhsObetaUnique :: Int
_lhsObetaUnique = rule2998 _lhsIbetaUnique
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule2999 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule3000 _lhsIcounter
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule3001 _environment
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule3002 _infoTree
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3003 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule2990 #-}
rule2990 = \ (_ :: ()) ->
globalInfoError
{-# INLINE rule2991 #-}
rule2991 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "Pattern.Successor"
{-# INLINE rule2992 #-}
rule2992 = \ (_ :: ()) ->
pmError "Pattern_Successor.elements" "Successors are not supported"
{-# INLINE rule2993 #-}
rule2993 = \ (_ :: ()) ->
[]
{-# INLINE rule2994 #-}
rule2994 = \ (_ :: ()) ->
[]
{-# INLINE rule2995 #-}
rule2995 = \ ((_literalIself) :: Literal) ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
Pattern_Successor _rangeIself _nameIself _literalIself
{-# INLINE rule2996 #-}
rule2996 = \ _self ->
_self
{-# INLINE rule2997 #-}
rule2997 = \ _beta ->
_beta
{-# INLINE rule2998 #-}
rule2998 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule2999 #-}
rule2999 = \ _constraints ->
_constraints
{-# INLINE rule3000 #-}
rule3000 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3001 #-}
rule3001 = \ _environment ->
_environment
{-# INLINE rule3002 #-}
rule3002 = \ _infoTree ->
_infoTree
{-# INLINE rule3003 #-}
rule3003 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_NegateFloat #-}
sem_Pattern_NegateFloat :: T_Range -> T_Literal -> T_Pattern
sem_Pattern_NegateFloat arg_range_ arg_literal_ = T_Pattern (return st119) where
{-# NOINLINE st119 #-}
st119 = let
v118 :: T_Pattern_v118
v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_literalX86 = Control.Monad.Identity.runIdentity (attach_T_Literal (arg_literal_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Literal_vOut85 _literalIelements _literalIliteralType _literalIself) = inv_Literal_s86 _literalX86 (T_Literal_vIn85 )
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3004 _lhsIbetaUnique
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule3005 ()
_constraints = rule3006 _newcon
_beta = rule3007 _lhsIbetaUnique
_newcon = rule3008 _beta _cinfo
_cinfo = rule3009 _parentTree
_localInfo = rule3010 _beta _lhsImonos _self
_parentTree = rule3011 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule3012 _parentTree
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule3013 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3014 ()
_self = rule3015 _literalIself _rangeIself
_lhsOself :: Pattern
_lhsOself = rule3016 _self
_lhsObeta :: Tp
_lhsObeta = rule3017 _beta
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3018 _constraints
_lhsOcounter :: Int
_lhsOcounter = rule3019 _lhsIcounter
_lhsOelements :: [PatternElement]
_lhsOelements = rule3020 _literalIelements
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3021 _lhsIpatternMatchWarnings
__result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Pattern_s119 v118
{-# INLINE rule3004 #-}
rule3004 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule3005 #-}
rule3005 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule3006 #-}
rule3006 = \ _newcon ->
listTree _newcon
{-# INLINE rule3007 #-}
rule3007 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule3008 #-}
rule3008 = \ _beta _cinfo ->
[ (floatType .==. _beta) _cinfo ]
{-# INLINE rule3009 #-}
rule3009 = \ _parentTree ->
resultConstraint "pattern negation" _parentTree
[ FolkloreConstraint ]
{-# INLINE rule3010 #-}
rule3010 = \ _beta ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Pat _self
, assignedType = Just _beta
, monos = _lhsImonos
}
{-# INLINE rule3011 #-}
rule3011 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule3012 #-}
rule3012 = \ _parentTree ->
_parentTree
{-# INLINE rule3013 #-}
rule3013 = \ (_ :: ()) ->
[]
{-# INLINE rule3014 #-}
rule3014 = \ (_ :: ()) ->
[]
{-# INLINE rule3015 #-}
rule3015 = \ ((_literalIself) :: Literal) ((_rangeIself) :: Range) ->
Pattern_NegateFloat _rangeIself _literalIself
{-# INLINE rule3016 #-}
rule3016 = \ _self ->
_self
{-# INLINE rule3017 #-}
rule3017 = \ _beta ->
_beta
{-# INLINE rule3018 #-}
rule3018 = \ _constraints ->
_constraints
{-# INLINE rule3019 #-}
rule3019 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3020 #-}
rule3020 = \ ((_literalIelements) :: [PatternElement] ) ->
_literalIelements
{-# INLINE rule3021 #-}
rule3021 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
-- Patterns ----------------------------------------------------
-- wrapper
data Inh_Patterns = Inh_Patterns { betaUnique_Inh_Patterns :: (Int), counter_Inh_Patterns :: (Int), importEnvironment_Inh_Patterns :: (ImportEnvironment), monos_Inh_Patterns :: (Monos), namesInScope_Inh_Patterns :: (Names), parentTree_Inh_Patterns :: (InfoTree), patternMatchWarnings_Inh_Patterns :: ([Warning]) }
data Syn_Patterns = Syn_Patterns { betaUnique_Syn_Patterns :: (Int), betas_Syn_Patterns :: (Tps), constraintslist_Syn_Patterns :: (ConstraintSets), counter_Syn_Patterns :: (Int), elementss_Syn_Patterns :: ([ [PatternElement] ]), environment_Syn_Patterns :: (PatternAssumptions), infoTrees_Syn_Patterns :: (InfoTrees), numberOfPatterns_Syn_Patterns :: (Int), patVarNames_Syn_Patterns :: (Names), patternMatchWarnings_Syn_Patterns :: ([Warning]), self_Syn_Patterns :: (Patterns), unboundNames_Syn_Patterns :: (Names) }
{-# INLINABLE wrap_Patterns #-}
wrap_Patterns :: T_Patterns -> Inh_Patterns -> (Syn_Patterns )
wrap_Patterns (T_Patterns act) (Inh_Patterns _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Patterns_vIn121 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings
(T_Patterns_vOut121 _lhsObetaUnique _lhsObetas _lhsOconstraintslist _lhsOcounter _lhsOelementss _lhsOenvironment _lhsOinfoTrees _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames) <- return (inv_Patterns_s122 sem arg)
return (Syn_Patterns _lhsObetaUnique _lhsObetas _lhsOconstraintslist _lhsOcounter _lhsOelementss _lhsOenvironment _lhsOinfoTrees _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames)
)
-- cata
{-# NOINLINE sem_Patterns #-}
sem_Patterns :: Patterns -> T_Patterns
sem_Patterns list = Prelude.foldr sem_Patterns_Cons sem_Patterns_Nil (Prelude.map sem_Pattern list)
-- semantic domain
newtype T_Patterns = T_Patterns {
attach_T_Patterns :: Identity (T_Patterns_s122 )
}
newtype T_Patterns_s122 = C_Patterns_s122 {
inv_Patterns_s122 :: (T_Patterns_v121 )
}
data T_Patterns_s123 = C_Patterns_s123
type T_Patterns_v121 = (T_Patterns_vIn121 ) -> (T_Patterns_vOut121 )
data T_Patterns_vIn121 = T_Patterns_vIn121 (Int) (Int) (ImportEnvironment) (Monos) (Names) (InfoTree) ([Warning])
data T_Patterns_vOut121 = T_Patterns_vOut121 (Int) (Tps) (ConstraintSets) (Int) ([ [PatternElement] ]) (PatternAssumptions) (InfoTrees) (Int) (Names) ([Warning]) (Patterns) (Names)
{-# NOINLINE sem_Patterns_Cons #-}
sem_Patterns_Cons :: T_Pattern -> T_Patterns -> T_Patterns
sem_Patterns_Cons arg_hd_ arg_tl_ = T_Patterns (return st122) where
{-# NOINLINE st122 #-}
st122 = let
v121 :: T_Patterns_v121
v121 = \ (T_Patterns_vIn121 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_hdX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_hd_))
_tlX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_tl_))
(T_Pattern_vOut118 _hdIbeta _hdIbetaUnique _hdIconstraints _hdIcounter _hdIelements _hdIenvironment _hdIinfoTree _hdIpatVarNames _hdIpatternMatchWarnings _hdIself _hdIunboundNames) = inv_Pattern_s119 _hdX119 (T_Pattern_vIn118 _hdObetaUnique _hdOcounter _hdOimportEnvironment _hdOmonos _hdOnamesInScope _hdOparentTree _hdOpatternMatchWarnings)
(T_Patterns_vOut121 _tlIbetaUnique _tlIbetas _tlIconstraintslist _tlIcounter _tlIelementss _tlIenvironment _tlIinfoTrees _tlInumberOfPatterns _tlIpatVarNames _tlIpatternMatchWarnings _tlIself _tlIunboundNames) = inv_Patterns_s122 _tlX122 (T_Patterns_vIn121 _tlObetaUnique _tlOcounter _tlOimportEnvironment _tlOmonos _tlOnamesInScope _tlOparentTree _tlOpatternMatchWarnings)
_lhsObetas :: Tps
_lhsObetas = rule3022 _hdIbeta _tlIbetas
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule3023 _hdIenvironment _tlIenvironment
_lhsOnumberOfPatterns :: Int
_lhsOnumberOfPatterns = rule3024 _tlInumberOfPatterns
_lhsOconstraintslist :: ConstraintSets
_lhsOconstraintslist = rule3025 _hdIconstraints _tlIconstraintslist
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule3026 _hdIinfoTree _tlIinfoTrees
_lhsOelementss :: [ [PatternElement] ]
_lhsOelementss = rule3027 _hdIelements _tlIelementss
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule3028 _hdIpatVarNames _tlIpatVarNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3029 _hdIunboundNames _tlIunboundNames
_self = rule3030 _hdIself _tlIself
_lhsOself :: Patterns
_lhsOself = rule3031 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3032 _tlIbetaUnique
_lhsOcounter :: Int
_lhsOcounter = rule3033 _tlIcounter
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3034 _tlIpatternMatchWarnings
_hdObetaUnique = rule3035 _lhsIbetaUnique
_hdOcounter = rule3036 _lhsIcounter
_hdOimportEnvironment = rule3037 _lhsIimportEnvironment
_hdOmonos = rule3038 _lhsImonos
_hdOnamesInScope = rule3039 _lhsInamesInScope
_hdOparentTree = rule3040 _lhsIparentTree
_hdOpatternMatchWarnings = rule3041 _lhsIpatternMatchWarnings
_tlObetaUnique = rule3042 _hdIbetaUnique
_tlOcounter = rule3043 _hdIcounter
_tlOimportEnvironment = rule3044 _lhsIimportEnvironment
_tlOmonos = rule3045 _lhsImonos
_tlOnamesInScope = rule3046 _lhsInamesInScope
_tlOparentTree = rule3047 _lhsIparentTree
_tlOpatternMatchWarnings = rule3048 _hdIpatternMatchWarnings
__result_ = T_Patterns_vOut121 _lhsObetaUnique _lhsObetas _lhsOconstraintslist _lhsOcounter _lhsOelementss _lhsOenvironment _lhsOinfoTrees _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Patterns_s122 v121
{-# INLINE rule3022 #-}
rule3022 = \ ((_hdIbeta) :: Tp) ((_tlIbetas) :: Tps) ->
_hdIbeta : _tlIbetas
{-# INLINE rule3023 #-}
rule3023 = \ ((_hdIenvironment) :: PatternAssumptions) ((_tlIenvironment) :: PatternAssumptions) ->
_hdIenvironment `M.union` _tlIenvironment
{-# INLINE rule3024 #-}
rule3024 = \ ((_tlInumberOfPatterns) :: Int) ->
1 + _tlInumberOfPatterns
{-# INLINE rule3025 #-}
rule3025 = \ ((_hdIconstraints) :: ConstraintSet) ((_tlIconstraintslist) :: ConstraintSets) ->
_hdIconstraints : _tlIconstraintslist
{-# INLINE rule3026 #-}
rule3026 = \ ((_hdIinfoTree) :: InfoTree) ((_tlIinfoTrees) :: InfoTrees) ->
_hdIinfoTree : _tlIinfoTrees
{-# INLINE rule3027 #-}
rule3027 = \ ((_hdIelements) :: [PatternElement] ) ((_tlIelementss) :: [ [PatternElement] ]) ->
_hdIelements : _tlIelementss
{-# INLINE rule3028 #-}
rule3028 = \ ((_hdIpatVarNames) :: Names) ((_tlIpatVarNames) :: Names) ->
_hdIpatVarNames ++ _tlIpatVarNames
{-# INLINE rule3029 #-}
rule3029 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
_hdIunboundNames ++ _tlIunboundNames
{-# INLINE rule3030 #-}
rule3030 = \ ((_hdIself) :: Pattern) ((_tlIself) :: Patterns) ->
(:) _hdIself _tlIself
{-# INLINE rule3031 #-}
rule3031 = \ _self ->
_self
{-# INLINE rule3032 #-}
rule3032 = \ ((_tlIbetaUnique) :: Int) ->
_tlIbetaUnique
{-# INLINE rule3033 #-}
rule3033 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule3034 #-}
rule3034 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
_tlIpatternMatchWarnings
{-# INLINE rule3035 #-}
rule3035 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3036 #-}
rule3036 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3037 #-}
rule3037 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3038 #-}
rule3038 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3039 #-}
rule3039 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3040 #-}
rule3040 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule3041 #-}
rule3041 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3042 #-}
rule3042 = \ ((_hdIbetaUnique) :: Int) ->
_hdIbetaUnique
{-# INLINE rule3043 #-}
rule3043 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule3044 #-}
rule3044 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3045 #-}
rule3045 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3046 #-}
rule3046 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3047 #-}
rule3047 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule3048 #-}
rule3048 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
_hdIpatternMatchWarnings
{-# NOINLINE sem_Patterns_Nil #-}
sem_Patterns_Nil :: T_Patterns
sem_Patterns_Nil = T_Patterns (return st122) where
{-# NOINLINE st122 #-}
st122 = let
v121 :: T_Patterns_v121
v121 = \ (T_Patterns_vIn121 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
_lhsObetas :: Tps
_lhsObetas = rule3049 ()
_lhsOenvironment :: PatternAssumptions
_lhsOenvironment = rule3050 ()
_lhsOnumberOfPatterns :: Int
_lhsOnumberOfPatterns = rule3051 ()
_lhsOconstraintslist :: ConstraintSets
_lhsOconstraintslist = rule3052 ()
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule3053 ()
_lhsOelementss :: [ [PatternElement] ]
_lhsOelementss = rule3054 ()
_lhsOpatVarNames :: Names
_lhsOpatVarNames = rule3055 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3056 ()
_self = rule3057 ()
_lhsOself :: Patterns
_lhsOself = rule3058 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3059 _lhsIbetaUnique
_lhsOcounter :: Int
_lhsOcounter = rule3060 _lhsIcounter
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3061 _lhsIpatternMatchWarnings
__result_ = T_Patterns_vOut121 _lhsObetaUnique _lhsObetas _lhsOconstraintslist _lhsOcounter _lhsOelementss _lhsOenvironment _lhsOinfoTrees _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_Patterns_s122 v121
{-# INLINE rule3049 #-}
rule3049 = \ (_ :: ()) ->
[]
{-# INLINE rule3050 #-}
rule3050 = \ (_ :: ()) ->
noAssumptions
{-# INLINE rule3051 #-}
rule3051 = \ (_ :: ()) ->
0
{-# INLINE rule3052 #-}
rule3052 = \ (_ :: ()) ->
[]
{-# INLINE rule3053 #-}
rule3053 = \ (_ :: ()) ->
[]
{-# INLINE rule3054 #-}
rule3054 = \ (_ :: ()) ->
[]
{-# INLINE rule3055 #-}
rule3055 = \ (_ :: ()) ->
[]
{-# INLINE rule3056 #-}
rule3056 = \ (_ :: ()) ->
[]
{-# INLINE rule3057 #-}
rule3057 = \ (_ :: ()) ->
[]
{-# INLINE rule3058 #-}
rule3058 = \ _self ->
_self
{-# INLINE rule3059 #-}
rule3059 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3060 #-}
rule3060 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3061 #-}
rule3061 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
-- Position ----------------------------------------------------
-- wrapper
data Inh_Position = Inh_Position { }
data Syn_Position = Syn_Position { self_Syn_Position :: (Position) }
{-# INLINABLE wrap_Position #-}
wrap_Position :: T_Position -> Inh_Position -> (Syn_Position )
wrap_Position (T_Position act) (Inh_Position ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Position_vIn124
(T_Position_vOut124 _lhsOself) <- return (inv_Position_s125 sem arg)
return (Syn_Position _lhsOself)
)
-- cata
{-# NOINLINE sem_Position #-}
sem_Position :: Position -> T_Position
sem_Position ( Position_Position filename_ line_ column_ ) = sem_Position_Position filename_ line_ column_
sem_Position ( Position_Unknown ) = sem_Position_Unknown
-- semantic domain
newtype T_Position = T_Position {
attach_T_Position :: Identity (T_Position_s125 )
}
newtype T_Position_s125 = C_Position_s125 {
inv_Position_s125 :: (T_Position_v124 )
}
data T_Position_s126 = C_Position_s126
type T_Position_v124 = (T_Position_vIn124 ) -> (T_Position_vOut124 )
data T_Position_vIn124 = T_Position_vIn124
data T_Position_vOut124 = T_Position_vOut124 (Position)
{-# NOINLINE sem_Position_Position #-}
sem_Position_Position :: (String) -> (Int) -> (Int) -> T_Position
sem_Position_Position arg_filename_ arg_line_ arg_column_ = T_Position (return st125) where
{-# NOINLINE st125 #-}
st125 = let
v124 :: T_Position_v124
v124 = \ (T_Position_vIn124 ) -> ( let
_self = rule3062 arg_column_ arg_filename_ arg_line_
_lhsOself :: Position
_lhsOself = rule3063 _self
__result_ = T_Position_vOut124 _lhsOself
in __result_ )
in C_Position_s125 v124
{-# INLINE rule3062 #-}
rule3062 = \ column_ filename_ line_ ->
Position_Position filename_ line_ column_
{-# INLINE rule3063 #-}
rule3063 = \ _self ->
_self
{-# NOINLINE sem_Position_Unknown #-}
sem_Position_Unknown :: T_Position
sem_Position_Unknown = T_Position (return st125) where
{-# NOINLINE st125 #-}
st125 = let
v124 :: T_Position_v124
v124 = \ (T_Position_vIn124 ) -> ( let
_self = rule3064 ()
_lhsOself :: Position
_lhsOself = rule3065 _self
__result_ = T_Position_vOut124 _lhsOself
in __result_ )
in C_Position_s125 v124
{-# INLINE rule3064 #-}
rule3064 = \ (_ :: ()) ->
Position_Unknown
{-# INLINE rule3065 #-}
rule3065 = \ _self ->
_self
-- Qualifier ---------------------------------------------------
-- wrapper
data Inh_Qualifier = Inh_Qualifier { allPatterns_Inh_Qualifier :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Qualifier :: (M.Map NameWithRange TpScheme), assumptions_Inh_Qualifier :: (Assumptions), availablePredicates_Inh_Qualifier :: (Predicates), betaUnique_Inh_Qualifier :: (Int), classEnvironment_Inh_Qualifier :: (ClassEnvironment), collectErrors_Inh_Qualifier :: (TypeErrors), collectWarnings_Inh_Qualifier :: (Warnings), constraints_Inh_Qualifier :: (ConstraintSet), counter_Inh_Qualifier :: (Int), currentChunk_Inh_Qualifier :: (Int), dictionaryEnvironment_Inh_Qualifier :: (DictionaryEnvironment), importEnvironment_Inh_Qualifier :: (ImportEnvironment), matchIO_Inh_Qualifier :: (IO ()), monos_Inh_Qualifier :: (Monos), namesInScope_Inh_Qualifier :: (Names), orderedTypeSynonyms_Inh_Qualifier :: (OrderedTypeSynonyms), parentTree_Inh_Qualifier :: (InfoTree), patternMatchWarnings_Inh_Qualifier :: ([Warning]), substitution_Inh_Qualifier :: (FixpointSubstitution), typeschemeMap_Inh_Qualifier :: (M.Map Int (Scheme Predicates)), unboundNames_Inh_Qualifier :: (Names), uniqueChunk_Inh_Qualifier :: (Int), uniqueSecondRound_Inh_Qualifier :: (Int) }
data Syn_Qualifier = Syn_Qualifier { assumptions_Syn_Qualifier :: (Assumptions), betaUnique_Syn_Qualifier :: (Int), collectErrors_Syn_Qualifier :: (TypeErrors), collectInstances_Syn_Qualifier :: ([(Name, Instance)]), collectWarnings_Syn_Qualifier :: (Warnings), constraints_Syn_Qualifier :: (ConstraintSet), counter_Syn_Qualifier :: (Int), dictionaryEnvironment_Syn_Qualifier :: (DictionaryEnvironment), infoTree_Syn_Qualifier :: (InfoTree), matchIO_Syn_Qualifier :: (IO ()), monos_Syn_Qualifier :: (Monos), namesInScope_Syn_Qualifier :: (Names), patternMatchWarnings_Syn_Qualifier :: ([Warning]), self_Syn_Qualifier :: (Qualifier), unboundNames_Syn_Qualifier :: (Names), uniqueChunk_Syn_Qualifier :: (Int), uniqueSecondRound_Syn_Qualifier :: (Int) }
{-# INLINABLE wrap_Qualifier #-}
wrap_Qualifier :: T_Qualifier -> Inh_Qualifier -> (Syn_Qualifier )
wrap_Qualifier (T_Qualifier act) (Inh_Qualifier _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Qualifier_vIn127 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound
(T_Qualifier_vOut127 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_Qualifier_s128 sem arg)
return (Syn_Qualifier _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
)
-- cata
{-# NOINLINE sem_Qualifier #-}
sem_Qualifier :: Qualifier -> T_Qualifier
sem_Qualifier ( Qualifier_Guard range_ guard_ ) = sem_Qualifier_Guard ( sem_Range range_ ) ( sem_Expression guard_ )
sem_Qualifier ( Qualifier_Let range_ declarations_ ) = sem_Qualifier_Let ( sem_Range range_ ) ( sem_Declarations declarations_ )
sem_Qualifier ( Qualifier_Generator range_ pattern_ expression_ ) = sem_Qualifier_Generator ( sem_Range range_ ) ( sem_Pattern pattern_ ) ( sem_Expression expression_ )
sem_Qualifier ( Qualifier_Empty range_ ) = sem_Qualifier_Empty ( sem_Range range_ )
-- semantic domain
newtype T_Qualifier = T_Qualifier {
attach_T_Qualifier :: Identity (T_Qualifier_s128 )
}
newtype T_Qualifier_s128 = C_Qualifier_s128 {
inv_Qualifier_s128 :: (T_Qualifier_v127 )
}
data T_Qualifier_s129 = C_Qualifier_s129
type T_Qualifier_v127 = (T_Qualifier_vIn127 ) -> (T_Qualifier_vOut127 )
data T_Qualifier_vIn127 = T_Qualifier_vIn127 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Assumptions) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (ConstraintSet) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Names) (Int) (Int)
data T_Qualifier_vOut127 = T_Qualifier_vOut127 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (InfoTree) (IO ()) (Monos) (Names) ([Warning]) (Qualifier) (Names) (Int) (Int)
{-# NOINLINE sem_Qualifier_Guard #-}
sem_Qualifier_Guard :: T_Range -> T_Expression -> T_Qualifier
sem_Qualifier_Guard arg_range_ arg_guard_ = T_Qualifier (return st128) where
{-# NOINLINE st128 #-}
st128 = let
v127 :: T_Qualifier_v127
v127 = \ (T_Qualifier_vIn127 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_guardX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_guard_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _guardIassumptions _guardIbeta _guardIbetaUnique _guardIcollectErrors _guardIcollectInstances _guardIcollectWarnings _guardIconstraints _guardIcounter _guardIdictionaryEnvironment _guardIinfoTree _guardImatchIO _guardImatches _guardIpatternMatchWarnings _guardIself _guardIunboundNames _guardIuniqueChunk _guardIuniqueSecondRound) = inv_Expression_s41 _guardX41 (T_Expression_vIn40 _guardOallPatterns _guardOallTypeSchemes _guardOavailablePredicates _guardObetaUnique _guardOclassEnvironment _guardOcollectErrors _guardOcollectWarnings _guardOcounter _guardOcurrentChunk _guardOdictionaryEnvironment _guardOimportEnvironment _guardOmatchIO _guardOmonos _guardOnamesInScope _guardOorderedTypeSynonyms _guardOparentTree _guardOpatternMatchWarnings _guardOsubstitution _guardOtryPatterns _guardOtypeschemeMap _guardOuniqueChunk _guardOuniqueSecondRound)
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule3066 _guardIassumptions _lhsIassumptions
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3067 _locConstraints
_locConstraints = rule3068 _guardIconstraints _lhsIconstraints _newcon
_newcon = rule3069 _cinfo _guardIbeta
_cinfo = rule3070 _parentTree
_localInfo = rule3071 _lhsImonos _self
_parentTree = rule3072 _guardIinfoTree _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule3073 _parentTree
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3074 _guardIunboundNames _lhsIunboundNames
_guardOtryPatterns = rule3075 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3076 _guardIcollectInstances
_self = rule3077 _guardIself _rangeIself
_lhsOself :: Qualifier
_lhsOself = rule3078 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3079 _guardIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3080 _guardIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3081 _guardIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule3082 _guardIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3083 _guardIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3084 _guardImatchIO
_lhsOmonos :: Monos
_lhsOmonos = rule3085 _lhsImonos
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule3086 _lhsInamesInScope
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3087 _guardIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3088 _guardIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule3089 _guardIuniqueSecondRound
_guardOallPatterns = rule3090 _lhsIallPatterns
_guardOallTypeSchemes = rule3091 _lhsIallTypeSchemes
_guardOavailablePredicates = rule3092 _lhsIavailablePredicates
_guardObetaUnique = rule3093 _lhsIbetaUnique
_guardOclassEnvironment = rule3094 _lhsIclassEnvironment
_guardOcollectErrors = rule3095 _lhsIcollectErrors
_guardOcollectWarnings = rule3096 _lhsIcollectWarnings
_guardOcounter = rule3097 _lhsIcounter
_guardOcurrentChunk = rule3098 _lhsIcurrentChunk
_guardOdictionaryEnvironment = rule3099 _lhsIdictionaryEnvironment
_guardOimportEnvironment = rule3100 _lhsIimportEnvironment
_guardOmatchIO = rule3101 _lhsImatchIO
_guardOmonos = rule3102 _lhsImonos
_guardOnamesInScope = rule3103 _lhsInamesInScope
_guardOorderedTypeSynonyms = rule3104 _lhsIorderedTypeSynonyms
_guardOparentTree = rule3105 _parentTree
_guardOpatternMatchWarnings = rule3106 _lhsIpatternMatchWarnings
_guardOsubstitution = rule3107 _lhsIsubstitution
_guardOtypeschemeMap = rule3108 _lhsItypeschemeMap
_guardOuniqueChunk = rule3109 _lhsIuniqueChunk
_guardOuniqueSecondRound = rule3110 _lhsIuniqueSecondRound
__result_ = T_Qualifier_vOut127 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Qualifier_s128 v127
{-# INLINE rule3066 #-}
rule3066 = \ ((_guardIassumptions) :: Assumptions) ((_lhsIassumptions) :: Assumptions) ->
_lhsIassumptions `combine` _guardIassumptions
{-# INLINE rule3067 #-}
rule3067 = \ _locConstraints ->
_locConstraints
{-# INLINE rule3068 #-}
rule3068 = \ ((_guardIconstraints) :: ConstraintSet) ((_lhsIconstraints) :: ConstraintSet) _newcon ->
Node [ _newcon .<. _guardIconstraints
, _lhsIconstraints
]
{-# INLINE rule3069 #-}
rule3069 = \ _cinfo ((_guardIbeta) :: Tp) ->
[ (_guardIbeta .==. boolType) _cinfo ]
{-# INLINE rule3070 #-}
rule3070 = \ _parentTree ->
orphanConstraint 0 "boolean qualifier" _parentTree
[]
{-# INLINE rule3071 #-}
rule3071 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Qual _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule3072 #-}
rule3072 = \ ((_guardIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo [_guardIinfoTree]
{-# INLINE rule3073 #-}
rule3073 = \ _parentTree ->
_parentTree
{-# INLINE rule3074 #-}
rule3074 = \ ((_guardIunboundNames) :: Names) ((_lhsIunboundNames) :: Names) ->
_guardIunboundNames ++ _lhsIunboundNames
{-# INLINE rule3075 #-}
rule3075 = \ (_ :: ()) ->
[]
{-# INLINE rule3076 #-}
rule3076 = \ ((_guardIcollectInstances) :: [(Name, Instance)]) ->
_guardIcollectInstances
{-# INLINE rule3077 #-}
rule3077 = \ ((_guardIself) :: Expression) ((_rangeIself) :: Range) ->
Qualifier_Guard _rangeIself _guardIself
{-# INLINE rule3078 #-}
rule3078 = \ _self ->
_self
{-# INLINE rule3079 #-}
rule3079 = \ ((_guardIbetaUnique) :: Int) ->
_guardIbetaUnique
{-# INLINE rule3080 #-}
rule3080 = \ ((_guardIcollectErrors) :: TypeErrors) ->
_guardIcollectErrors
{-# INLINE rule3081 #-}
rule3081 = \ ((_guardIcollectWarnings) :: Warnings) ->
_guardIcollectWarnings
{-# INLINE rule3082 #-}
rule3082 = \ ((_guardIcounter) :: Int) ->
_guardIcounter
{-# INLINE rule3083 #-}
rule3083 = \ ((_guardIdictionaryEnvironment) :: DictionaryEnvironment) ->
_guardIdictionaryEnvironment
{-# INLINE rule3084 #-}
rule3084 = \ ((_guardImatchIO) :: IO ()) ->
_guardImatchIO
{-# INLINE rule3085 #-}
rule3085 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3086 #-}
rule3086 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3087 #-}
rule3087 = \ ((_guardIpatternMatchWarnings) :: [Warning]) ->
_guardIpatternMatchWarnings
{-# INLINE rule3088 #-}
rule3088 = \ ((_guardIuniqueChunk) :: Int) ->
_guardIuniqueChunk
{-# INLINE rule3089 #-}
rule3089 = \ ((_guardIuniqueSecondRound) :: Int) ->
_guardIuniqueSecondRound
{-# INLINE rule3090 #-}
rule3090 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3091 #-}
rule3091 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule3092 #-}
rule3092 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3093 #-}
rule3093 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3094 #-}
rule3094 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3095 #-}
rule3095 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3096 #-}
rule3096 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3097 #-}
rule3097 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3098 #-}
rule3098 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3099 #-}
rule3099 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3100 #-}
rule3100 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3101 #-}
rule3101 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3102 #-}
rule3102 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3103 #-}
rule3103 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3104 #-}
rule3104 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3105 #-}
rule3105 = \ _parentTree ->
_parentTree
{-# INLINE rule3106 #-}
rule3106 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3107 #-}
rule3107 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3108 #-}
rule3108 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3109 #-}
rule3109 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3110 #-}
rule3110 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Qualifier_Let #-}
sem_Qualifier_Let :: T_Range -> T_Declarations -> T_Qualifier
sem_Qualifier_Let arg_range_ arg_declarations_ = T_Qualifier (return st128) where
{-# NOINLINE st128 #-}
st128 = let
v127 :: T_Qualifier_v127
v127 = \ (T_Qualifier_vIn127 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_declarationsX32 = Control.Monad.Identity.runIdentity (attach_T_Declarations (arg_declarations_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Declarations_vOut31 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsIcollectErrors _declarationsIcollectInstances _declarationsIcollectWarnings _declarationsIcounter _declarationsIdeclVarNames _declarationsIdictionaryEnvironment _declarationsIinfoTrees _declarationsImatchIO _declarationsIpatternMatchWarnings _declarationsIrestrictedNames _declarationsIself _declarationsIsimplePatNames _declarationsItypeSignatures _declarationsIunboundNames _declarationsIuniqueChunk) = inv_Declarations_s32 _declarationsX32 (T_Declarations_vIn31 _declarationsOallPatterns _declarationsOallTypeSchemes _declarationsOavailablePredicates _declarationsObetaUnique _declarationsObindingGroups _declarationsOclassEnvironment _declarationsOcollectErrors _declarationsOcollectWarnings _declarationsOcounter _declarationsOcurrentChunk _declarationsOdictionaryEnvironment _declarationsOimportEnvironment _declarationsOinheritedBDG _declarationsOmatchIO _declarationsOmonos _declarationsOnamesInScope _declarationsOorderedTypeSynonyms _declarationsOparentTree _declarationsOpatternMatchWarnings _declarationsOsubstitution _declarationsOtypeSignatures _declarationsOtypeschemeMap _declarationsOuniqueChunk)
_declarationsObindingGroups = rule3111 ()
_lhsOassumptions :: Assumptions
_lhsOconstraints :: ConstraintSet
_lhsObetaUnique :: Int
(_lhsOassumptions,_lhsOconstraints,_inheritedBDG,_chunkNr,_lhsObetaUnique,_implicitsFM) = rule3112 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsItypeSignatures _declarationsIuniqueChunk _lhsIassumptions _lhsIconstraints _lhsIcurrentChunk _lhsImonos
_inferredTypes = rule3113 _implicitsFM _lhsItypeschemeMap
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3114 _declarationsIcollectWarnings _declarationsIsimplePatNames _inferredTypes
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3115 _declarationsIcollectErrors _declarationsIrestrictedNames _inferredTypes
_allTypeSchemes = rule3116 _lhsIallTypeSchemes _localTypes
_localTypes = rule3117 _declarationsIbindingGroups _declarationsItypeSignatures _inferredTypes
_declarationsOtypeSignatures = rule3118 ()
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3119 _chunkNr
_localInfo = rule3120 _lhsImonos _self
_declInfo = rule3121 _declarationsIself _lhsImonos
_thisTree = rule3122 _declTree _lhsIparentTree _localInfo
_declTree = rule3123 _declInfo _declarationsIinfoTrees _thisTree
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule3124 _thisTree
_declarationsOparentTree = rule3125 _declTree
(_collectTypeConstructors,_collectValueConstructors,_collectTypeSynonyms,_collectConstructorEnv,_derivedFunctions,_operatorFixities) = rule3126 ()
(_namesInScope,_unboundNames,_scopeInfo) = rule3127 _declarationsIdeclVarNames _declarationsIunboundNames _lhsInamesInScope _lhsIunboundNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3128 _unboundNames
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3129 _declarationsIcollectInstances
_self = rule3130 _declarationsIself _rangeIself
_lhsOself :: Qualifier
_lhsOself = rule3131 _self
_lhsOcounter :: Int
_lhsOcounter = rule3132 _declarationsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3133 _declarationsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3134 _declarationsImatchIO
_lhsOmonos :: Monos
_lhsOmonos = rule3135 _lhsImonos
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule3136 _namesInScope
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3137 _declarationsIpatternMatchWarnings
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule3138 _lhsIuniqueSecondRound
_declarationsOallPatterns = rule3139 _lhsIallPatterns
_declarationsOallTypeSchemes = rule3140 _allTypeSchemes
_declarationsOavailablePredicates = rule3141 _lhsIavailablePredicates
_declarationsObetaUnique = rule3142 _lhsIbetaUnique
_declarationsOclassEnvironment = rule3143 _lhsIclassEnvironment
_declarationsOcollectErrors = rule3144 _lhsIcollectErrors
_declarationsOcollectWarnings = rule3145 _lhsIcollectWarnings
_declarationsOcounter = rule3146 _lhsIcounter
_declarationsOcurrentChunk = rule3147 _lhsIcurrentChunk
_declarationsOdictionaryEnvironment = rule3148 _lhsIdictionaryEnvironment
_declarationsOimportEnvironment = rule3149 _lhsIimportEnvironment
_declarationsOinheritedBDG = rule3150 _inheritedBDG
_declarationsOmatchIO = rule3151 _lhsImatchIO
_declarationsOmonos = rule3152 _lhsImonos
_declarationsOnamesInScope = rule3153 _namesInScope
_declarationsOorderedTypeSynonyms = rule3154 _lhsIorderedTypeSynonyms
_declarationsOpatternMatchWarnings = rule3155 _lhsIpatternMatchWarnings
_declarationsOsubstitution = rule3156 _lhsIsubstitution
_declarationsOtypeschemeMap = rule3157 _lhsItypeschemeMap
_declarationsOuniqueChunk = rule3158 _lhsIuniqueChunk
__result_ = T_Qualifier_vOut127 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Qualifier_s128 v127
{-# INLINE rule3111 #-}
rule3111 = \ (_ :: ()) ->
[]
{-# INLINE rule3112 #-}
rule3112 = \ ((_declarationsIbetaUnique) :: Int) ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) ((_declarationsIuniqueChunk) :: Int) ((_lhsIassumptions) :: Assumptions) ((_lhsIconstraints) :: ConstraintSet) ((_lhsIcurrentChunk) :: Int) ((_lhsImonos) :: Monos) ->
let inputBDG = (False, _lhsIcurrentChunk, _declarationsIuniqueChunk, _lhsImonos, _declarationsItypeSignatures, mybdggroup, _declarationsIbetaUnique)
mybdggroup = Just (_lhsIassumptions, [_lhsIconstraints])
in performBindingGroup inputBDG _declarationsIbindingGroups
{-# INLINE rule3113 #-}
rule3113 = \ _implicitsFM ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
findInferredTypes _lhsItypeschemeMap _implicitsFM
{-# INLINE rule3114 #-}
rule3114 = \ ((_declarationsIcollectWarnings) :: Warnings) ((_declarationsIsimplePatNames) :: Names) _inferredTypes ->
missingTypeSignature False _declarationsIsimplePatNames _inferredTypes
++ _declarationsIcollectWarnings
{-# INLINE rule3115 #-}
rule3115 = \ ((_declarationsIcollectErrors) :: TypeErrors) ((_declarationsIrestrictedNames) :: Names) _inferredTypes ->
restrictedNameErrors _inferredTypes _declarationsIrestrictedNames
++ _declarationsIcollectErrors
{-# INLINE rule3116 #-}
rule3116 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) _localTypes ->
_localTypes `M.union` _lhsIallTypeSchemes
{-# INLINE rule3117 #-}
rule3117 = \ ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) _inferredTypes ->
makeLocalTypeEnv (_declarationsItypeSignatures `M.union` _inferredTypes) _declarationsIbindingGroups
{-# INLINE rule3118 #-}
rule3118 = \ (_ :: ()) ->
M.empty
{-# INLINE rule3119 #-}
rule3119 = \ _chunkNr ->
_chunkNr
{-# INLINE rule3120 #-}
rule3120 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Qual _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule3121 #-}
rule3121 = \ ((_declarationsIself) :: Declarations) ((_lhsImonos) :: Monos) ->
LocalInfo { self = UHA_Decls _declarationsIself
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule3122 #-}
rule3122 = \ _declTree ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo [_declTree]
{-# INLINE rule3123 #-}
rule3123 = \ _declInfo ((_declarationsIinfoTrees) :: InfoTrees) _thisTree ->
node _thisTree _declInfo _declarationsIinfoTrees
{-# INLINE rule3124 #-}
rule3124 = \ _thisTree ->
_thisTree
{-# INLINE rule3125 #-}
rule3125 = \ _declTree ->
_declTree
{-# INLINE rule3126 #-}
rule3126 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "toplevel Qualifier"
{-# INLINE rule3127 #-}
rule3127 = \ ((_declarationsIdeclVarNames) :: Names) ((_declarationsIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ((_lhsIunboundNames) :: Names) ->
changeOfScope _declarationsIdeclVarNames (_declarationsIunboundNames ++ _lhsIunboundNames) _lhsInamesInScope
{-# INLINE rule3128 #-}
rule3128 = \ _unboundNames ->
_unboundNames
{-# INLINE rule3129 #-}
rule3129 = \ ((_declarationsIcollectInstances) :: [(Name, Instance)]) ->
_declarationsIcollectInstances
{-# INLINE rule3130 #-}
rule3130 = \ ((_declarationsIself) :: Declarations) ((_rangeIself) :: Range) ->
Qualifier_Let _rangeIself _declarationsIself
{-# INLINE rule3131 #-}
rule3131 = \ _self ->
_self
{-# INLINE rule3132 #-}
rule3132 = \ ((_declarationsIcounter) :: Int) ->
_declarationsIcounter
{-# INLINE rule3133 #-}
rule3133 = \ ((_declarationsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_declarationsIdictionaryEnvironment
{-# INLINE rule3134 #-}
rule3134 = \ ((_declarationsImatchIO) :: IO ()) ->
_declarationsImatchIO
{-# INLINE rule3135 #-}
rule3135 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3136 #-}
rule3136 = \ _namesInScope ->
_namesInScope
{-# INLINE rule3137 #-}
rule3137 = \ ((_declarationsIpatternMatchWarnings) :: [Warning]) ->
_declarationsIpatternMatchWarnings
{-# INLINE rule3138 #-}
rule3138 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule3139 #-}
rule3139 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3140 #-}
rule3140 = \ _allTypeSchemes ->
_allTypeSchemes
{-# INLINE rule3141 #-}
rule3141 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3142 #-}
rule3142 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3143 #-}
rule3143 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3144 #-}
rule3144 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3145 #-}
rule3145 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3146 #-}
rule3146 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3147 #-}
rule3147 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3148 #-}
rule3148 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3149 #-}
rule3149 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3150 #-}
rule3150 = \ _inheritedBDG ->
_inheritedBDG
{-# INLINE rule3151 #-}
rule3151 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3152 #-}
rule3152 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3153 #-}
rule3153 = \ _namesInScope ->
_namesInScope
{-# INLINE rule3154 #-}
rule3154 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3155 #-}
rule3155 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3156 #-}
rule3156 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3157 #-}
rule3157 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3158 #-}
rule3158 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Qualifier_Generator #-}
sem_Qualifier_Generator :: T_Range -> T_Pattern -> T_Expression -> T_Qualifier
sem_Qualifier_Generator arg_range_ arg_pattern_ arg_expression_ = T_Qualifier (return st128) where
{-# NOINLINE st128 #-}
st128 = let
v127 :: T_Qualifier_v127
v127 = \ (T_Qualifier_vIn127 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule3159 _assumptions' _expressionIassumptions
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3160 _locConstraints
_lhsOmonos :: Monos
_lhsOmonos = rule3161 _csetBinds _lhsImonos _patternIenvironment
_locConstraints = rule3162 _csetBinds _expressionIconstraints _lhsIconstraints _newcon _patternIconstraints
(_csetBinds,_assumptions') = rule3163 _cinfoBind _lhsIassumptions _patternIenvironment
_newcon = rule3164 _cinfoResult _expressionIbeta _patternIbeta
_cinfoResult = rule3165 _parentTree
_cinfoBind = rule3166 _parentTree _patternIenvironment
_localInfo = rule3167 _lhsImonos _self
_parentTree = rule3168 _expressionIinfoTree _lhsIparentTree _localInfo _patternIinfoTree
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule3169 _parentTree
(_namesInScope,_unboundNames,_scopeInfo) = rule3170 _expressionIunboundNames _lhsInamesInScope _lhsIunboundNames _patternIpatVarNames
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule3171 _namesInScope
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3172 _unboundNames
_expressionOnamesInScope = rule3173 _lhsInamesInScope
_expressionOtryPatterns = rule3174 ()
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3175 _expressionIpatternMatchWarnings _lhsIimportEnvironment _lhsIsubstitution _patternIbeta _patternIelements _rangeIself
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3176 _expressionIcollectInstances
_self = rule3177 _expressionIself _patternIself _rangeIself
_lhsOself :: Qualifier
_lhsOself = rule3178 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3179 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3180 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3181 _expressionIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule3182 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3183 _expressionIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3184 _expressionImatchIO
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3185 _expressionIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule3186 _expressionIuniqueSecondRound
_patternObetaUnique = rule3187 _lhsIbetaUnique
_patternOcounter = rule3188 _lhsIcounter
_patternOimportEnvironment = rule3189 _lhsIimportEnvironment
_patternOmonos = rule3190 _lhsImonos
_patternOnamesInScope = rule3191 _namesInScope
_patternOparentTree = rule3192 _parentTree
_patternOpatternMatchWarnings = rule3193 _lhsIpatternMatchWarnings
_expressionOallPatterns = rule3194 _lhsIallPatterns
_expressionOallTypeSchemes = rule3195 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule3196 _lhsIavailablePredicates
_expressionObetaUnique = rule3197 _patternIbetaUnique
_expressionOclassEnvironment = rule3198 _lhsIclassEnvironment
_expressionOcollectErrors = rule3199 _lhsIcollectErrors
_expressionOcollectWarnings = rule3200 _lhsIcollectWarnings
_expressionOcounter = rule3201 _patternIcounter
_expressionOcurrentChunk = rule3202 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule3203 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule3204 _lhsIimportEnvironment
_expressionOmatchIO = rule3205 _lhsImatchIO
_expressionOmonos = rule3206 _lhsImonos
_expressionOorderedTypeSynonyms = rule3207 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule3208 _parentTree
_expressionOpatternMatchWarnings = rule3209 _patternIpatternMatchWarnings
_expressionOsubstitution = rule3210 _lhsIsubstitution
_expressionOtypeschemeMap = rule3211 _lhsItypeschemeMap
_expressionOuniqueChunk = rule3212 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule3213 _lhsIuniqueSecondRound
__result_ = T_Qualifier_vOut127 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Qualifier_s128 v127
{-# INLINE rule3159 #-}
rule3159 = \ _assumptions' ((_expressionIassumptions) :: Assumptions) ->
_assumptions' `combine` _expressionIassumptions
{-# INLINE rule3160 #-}
rule3160 = \ _locConstraints ->
_locConstraints
{-# INLINE rule3161 #-}
rule3161 = \ _csetBinds ((_lhsImonos) :: Monos) ((_patternIenvironment) :: PatternAssumptions) ->
M.elems _patternIenvironment ++ getMonos _csetBinds ++ _lhsImonos
{-# INLINE rule3162 #-}
rule3162 = \ _csetBinds ((_expressionIconstraints) :: ConstraintSet) ((_lhsIconstraints) :: ConstraintSet) _newcon ((_patternIconstraints) :: ConstraintSet) ->
_newcon .>. _csetBinds .>>.
Node [ _patternIconstraints
, _expressionIconstraints
, _lhsIconstraints
]
{-# INLINE rule3163 #-}
rule3163 = \ _cinfoBind ((_lhsIassumptions) :: Assumptions) ((_patternIenvironment) :: PatternAssumptions) ->
(_patternIenvironment .===. _lhsIassumptions) _cinfoBind
{-# INLINE rule3164 #-}
rule3164 = \ _cinfoResult ((_expressionIbeta) :: Tp) ((_patternIbeta) :: Tp) ->
[ (_expressionIbeta .==. listType _patternIbeta) _cinfoResult ]
{-# INLINE rule3165 #-}
rule3165 = \ _parentTree ->
childConstraint 1 "generator" _parentTree
[]
{-# INLINE rule3166 #-}
rule3166 = \ _parentTree ((_patternIenvironment) :: PatternAssumptions) ->
\name -> variableConstraint "variable" (nameToUHA_Expr name)
[ FolkloreConstraint
, makeUnifier name "generator" _patternIenvironment _parentTree
]
{-# INLINE rule3167 #-}
rule3167 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Qual _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule3168 #-}
rule3168 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternIinfoTree) :: InfoTree) ->
node _lhsIparentTree _localInfo [_patternIinfoTree, _expressionIinfoTree]
{-# INLINE rule3169 #-}
rule3169 = \ _parentTree ->
_parentTree
{-# INLINE rule3170 #-}
rule3170 = \ ((_expressionIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ((_lhsIunboundNames) :: Names) ((_patternIpatVarNames) :: Names) ->
changeOfScope _patternIpatVarNames (_expressionIunboundNames ++ _lhsIunboundNames) _lhsInamesInScope
{-# INLINE rule3171 #-}
rule3171 = \ _namesInScope ->
_namesInScope
{-# INLINE rule3172 #-}
rule3172 = \ _unboundNames ->
_unboundNames
{-# INLINE rule3173 #-}
rule3173 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3174 #-}
rule3174 = \ (_ :: ()) ->
[]
{-# INLINE rule3175 #-}
rule3175 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_patternIbeta) :: Tp) ((_patternIelements) :: [PatternElement] ) ((_rangeIself) :: Range) ->
patternMatchWarnings _lhsIimportEnvironment
_lhsIsubstitution
_patternIbeta
(:[])
[(_patternIelements, False)]
_rangeIself
Nothing
False
[]
"generator"
"<-"
++ _expressionIpatternMatchWarnings
{-# INLINE rule3176 #-}
rule3176 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances
{-# INLINE rule3177 #-}
rule3177 = \ ((_expressionIself) :: Expression) ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
Qualifier_Generator _rangeIself _patternIself _expressionIself
{-# INLINE rule3178 #-}
rule3178 = \ _self ->
_self
{-# INLINE rule3179 #-}
rule3179 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule3180 #-}
rule3180 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule3181 #-}
rule3181 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule3182 #-}
rule3182 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule3183 #-}
rule3183 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule3184 #-}
rule3184 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule3185 #-}
rule3185 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule3186 #-}
rule3186 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule3187 #-}
rule3187 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3188 #-}
rule3188 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3189 #-}
rule3189 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3190 #-}
rule3190 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3191 #-}
rule3191 = \ _namesInScope ->
_namesInScope
{-# INLINE rule3192 #-}
rule3192 = \ _parentTree ->
_parentTree
{-# INLINE rule3193 #-}
rule3193 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3194 #-}
rule3194 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3195 #-}
rule3195 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule3196 #-}
rule3196 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3197 #-}
rule3197 = \ ((_patternIbetaUnique) :: Int) ->
_patternIbetaUnique
{-# INLINE rule3198 #-}
rule3198 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3199 #-}
rule3199 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3200 #-}
rule3200 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3201 #-}
rule3201 = \ ((_patternIcounter) :: Int) ->
_patternIcounter
{-# INLINE rule3202 #-}
rule3202 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3203 #-}
rule3203 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3204 #-}
rule3204 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3205 #-}
rule3205 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3206 #-}
rule3206 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3207 #-}
rule3207 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3208 #-}
rule3208 = \ _parentTree ->
_parentTree
{-# INLINE rule3209 #-}
rule3209 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
_patternIpatternMatchWarnings
{-# INLINE rule3210 #-}
rule3210 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3211 #-}
rule3211 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3212 #-}
rule3212 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3213 #-}
rule3213 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Qualifier_Empty #-}
sem_Qualifier_Empty :: T_Range -> T_Qualifier
sem_Qualifier_Empty arg_range_ = T_Qualifier (return st128) where
{-# NOINLINE st128 #-}
st128 = let
v127 :: T_Qualifier_v127
v127 = \ (T_Qualifier_vIn127 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_localInfo = rule3214 _lhsImonos _self
_parentTree = rule3215 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule3216 _parentTree
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3217 ()
_self = rule3218 _rangeIself
_lhsOself :: Qualifier
_lhsOself = rule3219 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule3220 _lhsIassumptions
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3221 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3222 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3223 _lhsIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3224 _lhsIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule3225 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3226 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3227 _lhsImatchIO
_lhsOmonos :: Monos
_lhsOmonos = rule3228 _lhsImonos
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule3229 _lhsInamesInScope
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3230 _lhsIpatternMatchWarnings
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3231 _lhsIunboundNames
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3232 _lhsIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule3233 _lhsIuniqueSecondRound
__result_ = T_Qualifier_vOut127 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Qualifier_s128 v127
{-# INLINE rule3214 #-}
rule3214 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Qual _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule3215 #-}
rule3215 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule3216 #-}
rule3216 = \ _parentTree ->
_parentTree
{-# INLINE rule3217 #-}
rule3217 = \ (_ :: ()) ->
[]
{-# INLINE rule3218 #-}
rule3218 = \ ((_rangeIself) :: Range) ->
Qualifier_Empty _rangeIself
{-# INLINE rule3219 #-}
rule3219 = \ _self ->
_self
{-# INLINE rule3220 #-}
rule3220 = \ ((_lhsIassumptions) :: Assumptions) ->
_lhsIassumptions
{-# INLINE rule3221 #-}
rule3221 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3222 #-}
rule3222 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3223 #-}
rule3223 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3224 #-}
rule3224 = \ ((_lhsIconstraints) :: ConstraintSet) ->
_lhsIconstraints
{-# INLINE rule3225 #-}
rule3225 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3226 #-}
rule3226 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3227 #-}
rule3227 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3228 #-}
rule3228 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3229 #-}
rule3229 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3230 #-}
rule3230 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3231 #-}
rule3231 = \ ((_lhsIunboundNames) :: Names) ->
_lhsIunboundNames
{-# INLINE rule3232 #-}
rule3232 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3233 #-}
rule3233 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
-- Qualifiers --------------------------------------------------
-- wrapper
data Inh_Qualifiers = Inh_Qualifiers { allPatterns_Inh_Qualifiers :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Qualifiers :: (M.Map NameWithRange TpScheme), assumptions_Inh_Qualifiers :: (Assumptions), availablePredicates_Inh_Qualifiers :: (Predicates), betaUnique_Inh_Qualifiers :: (Int), classEnvironment_Inh_Qualifiers :: (ClassEnvironment), collectErrors_Inh_Qualifiers :: (TypeErrors), collectWarnings_Inh_Qualifiers :: (Warnings), constraints_Inh_Qualifiers :: (ConstraintSet), counter_Inh_Qualifiers :: (Int), currentChunk_Inh_Qualifiers :: (Int), dictionaryEnvironment_Inh_Qualifiers :: (DictionaryEnvironment), importEnvironment_Inh_Qualifiers :: (ImportEnvironment), matchIO_Inh_Qualifiers :: (IO ()), monos_Inh_Qualifiers :: (Monos), namesInScope_Inh_Qualifiers :: (Names), orderedTypeSynonyms_Inh_Qualifiers :: (OrderedTypeSynonyms), parentTree_Inh_Qualifiers :: (InfoTree), patternMatchWarnings_Inh_Qualifiers :: ([Warning]), substitution_Inh_Qualifiers :: (FixpointSubstitution), typeschemeMap_Inh_Qualifiers :: (M.Map Int (Scheme Predicates)), unboundNames_Inh_Qualifiers :: (Names), uniqueChunk_Inh_Qualifiers :: (Int), uniqueSecondRound_Inh_Qualifiers :: (Int) }
data Syn_Qualifiers = Syn_Qualifiers { assumptions_Syn_Qualifiers :: (Assumptions), betaUnique_Syn_Qualifiers :: (Int), collectErrors_Syn_Qualifiers :: (TypeErrors), collectInstances_Syn_Qualifiers :: ([(Name, Instance)]), collectWarnings_Syn_Qualifiers :: (Warnings), constraints_Syn_Qualifiers :: (ConstraintSet), counter_Syn_Qualifiers :: (Int), dictionaryEnvironment_Syn_Qualifiers :: (DictionaryEnvironment), infoTrees_Syn_Qualifiers :: (InfoTrees), matchIO_Syn_Qualifiers :: (IO ()), monos_Syn_Qualifiers :: (Monos), namesInScope_Syn_Qualifiers :: (Names), patternMatchWarnings_Syn_Qualifiers :: ([Warning]), self_Syn_Qualifiers :: (Qualifiers), unboundNames_Syn_Qualifiers :: (Names), uniqueChunk_Syn_Qualifiers :: (Int), uniqueSecondRound_Syn_Qualifiers :: (Int) }
{-# INLINABLE wrap_Qualifiers #-}
wrap_Qualifiers :: T_Qualifiers -> Inh_Qualifiers -> (Syn_Qualifiers )
wrap_Qualifiers (T_Qualifiers act) (Inh_Qualifiers _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Qualifiers_vIn130 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound
(T_Qualifiers_vOut130 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_Qualifiers_s131 sem arg)
return (Syn_Qualifiers _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
)
-- cata
{-# NOINLINE sem_Qualifiers #-}
sem_Qualifiers :: Qualifiers -> T_Qualifiers
sem_Qualifiers list = Prelude.foldr sem_Qualifiers_Cons sem_Qualifiers_Nil (Prelude.map sem_Qualifier list)
-- semantic domain
newtype T_Qualifiers = T_Qualifiers {
attach_T_Qualifiers :: Identity (T_Qualifiers_s131 )
}
newtype T_Qualifiers_s131 = C_Qualifiers_s131 {
inv_Qualifiers_s131 :: (T_Qualifiers_v130 )
}
data T_Qualifiers_s132 = C_Qualifiers_s132
type T_Qualifiers_v130 = (T_Qualifiers_vIn130 ) -> (T_Qualifiers_vOut130 )
data T_Qualifiers_vIn130 = T_Qualifiers_vIn130 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Assumptions) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (ConstraintSet) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Names) (Int) (Int)
data T_Qualifiers_vOut130 = T_Qualifiers_vOut130 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (InfoTrees) (IO ()) (Monos) (Names) ([Warning]) (Qualifiers) (Names) (Int) (Int)
{-# NOINLINE sem_Qualifiers_Cons #-}
sem_Qualifiers_Cons :: T_Qualifier -> T_Qualifiers -> T_Qualifiers
sem_Qualifiers_Cons arg_hd_ arg_tl_ = T_Qualifiers (return st131) where
{-# NOINLINE st131 #-}
st131 = let
v130 :: T_Qualifiers_v130
v130 = \ (T_Qualifiers_vIn130 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_hdX128 = Control.Monad.Identity.runIdentity (attach_T_Qualifier (arg_hd_))
_tlX131 = Control.Monad.Identity.runIdentity (attach_T_Qualifiers (arg_tl_))
(T_Qualifier_vOut127 _hdIassumptions _hdIbetaUnique _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIconstraints _hdIcounter _hdIdictionaryEnvironment _hdIinfoTree _hdImatchIO _hdImonos _hdInamesInScope _hdIpatternMatchWarnings _hdIself _hdIunboundNames _hdIuniqueChunk _hdIuniqueSecondRound) = inv_Qualifier_s128 _hdX128 (T_Qualifier_vIn127 _hdOallPatterns _hdOallTypeSchemes _hdOassumptions _hdOavailablePredicates _hdObetaUnique _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOconstraints _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeschemeMap _hdOunboundNames _hdOuniqueChunk _hdOuniqueSecondRound)
(T_Qualifiers_vOut130 _tlIassumptions _tlIbetaUnique _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIconstraints _tlIcounter _tlIdictionaryEnvironment _tlIinfoTrees _tlImatchIO _tlImonos _tlInamesInScope _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk _tlIuniqueSecondRound) = inv_Qualifiers_s131 _tlX131 (T_Qualifiers_vIn130 _tlOallPatterns _tlOallTypeSchemes _tlOassumptions _tlOavailablePredicates _tlObetaUnique _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOconstraints _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeschemeMap _tlOunboundNames _tlOuniqueChunk _tlOuniqueSecondRound)
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule3234 _hdIassumptions
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3235 _hdIconstraints
_hdOassumptions = rule3236 _tlIassumptions
_hdOconstraints = rule3237 _tlIconstraints
_tlOassumptions = rule3238 _lhsIassumptions
_tlOconstraints = rule3239 _lhsIconstraints
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule3240 _hdIinfoTree _tlIinfoTrees
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3241 _hdIunboundNames
_tlOunboundNames = rule3242 _lhsIunboundNames
_hdOunboundNames = rule3243 _tlIunboundNames
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3244 _hdIcollectInstances _tlIcollectInstances
_self = rule3245 _hdIself _tlIself
_lhsOself :: Qualifiers
_lhsOself = rule3246 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3247 _tlIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3248 _tlIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3249 _tlIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule3250 _tlIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3251 _tlIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3252 _tlImatchIO
_lhsOmonos :: Monos
_lhsOmonos = rule3253 _tlImonos
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule3254 _tlInamesInScope
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3255 _tlIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3256 _tlIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule3257 _tlIuniqueSecondRound
_hdOallPatterns = rule3258 _lhsIallPatterns
_hdOallTypeSchemes = rule3259 _lhsIallTypeSchemes
_hdOavailablePredicates = rule3260 _lhsIavailablePredicates
_hdObetaUnique = rule3261 _lhsIbetaUnique
_hdOclassEnvironment = rule3262 _lhsIclassEnvironment
_hdOcollectErrors = rule3263 _lhsIcollectErrors
_hdOcollectWarnings = rule3264 _lhsIcollectWarnings
_hdOcounter = rule3265 _lhsIcounter
_hdOcurrentChunk = rule3266 _lhsIcurrentChunk
_hdOdictionaryEnvironment = rule3267 _lhsIdictionaryEnvironment
_hdOimportEnvironment = rule3268 _lhsIimportEnvironment
_hdOmatchIO = rule3269 _lhsImatchIO
_hdOmonos = rule3270 _lhsImonos
_hdOnamesInScope = rule3271 _lhsInamesInScope
_hdOorderedTypeSynonyms = rule3272 _lhsIorderedTypeSynonyms
_hdOparentTree = rule3273 _lhsIparentTree
_hdOpatternMatchWarnings = rule3274 _lhsIpatternMatchWarnings
_hdOsubstitution = rule3275 _lhsIsubstitution
_hdOtypeschemeMap = rule3276 _lhsItypeschemeMap
_hdOuniqueChunk = rule3277 _lhsIuniqueChunk
_hdOuniqueSecondRound = rule3278 _lhsIuniqueSecondRound
_tlOallPatterns = rule3279 _lhsIallPatterns
_tlOallTypeSchemes = rule3280 _lhsIallTypeSchemes
_tlOavailablePredicates = rule3281 _lhsIavailablePredicates
_tlObetaUnique = rule3282 _hdIbetaUnique
_tlOclassEnvironment = rule3283 _lhsIclassEnvironment
_tlOcollectErrors = rule3284 _hdIcollectErrors
_tlOcollectWarnings = rule3285 _hdIcollectWarnings
_tlOcounter = rule3286 _hdIcounter
_tlOcurrentChunk = rule3287 _lhsIcurrentChunk
_tlOdictionaryEnvironment = rule3288 _hdIdictionaryEnvironment
_tlOimportEnvironment = rule3289 _lhsIimportEnvironment
_tlOmatchIO = rule3290 _hdImatchIO
_tlOmonos = rule3291 _hdImonos
_tlOnamesInScope = rule3292 _hdInamesInScope
_tlOorderedTypeSynonyms = rule3293 _lhsIorderedTypeSynonyms
_tlOparentTree = rule3294 _lhsIparentTree
_tlOpatternMatchWarnings = rule3295 _hdIpatternMatchWarnings
_tlOsubstitution = rule3296 _lhsIsubstitution
_tlOtypeschemeMap = rule3297 _lhsItypeschemeMap
_tlOuniqueChunk = rule3298 _hdIuniqueChunk
_tlOuniqueSecondRound = rule3299 _hdIuniqueSecondRound
__result_ = T_Qualifiers_vOut130 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Qualifiers_s131 v130
{-# INLINE rule3234 #-}
rule3234 = \ ((_hdIassumptions) :: Assumptions) ->
_hdIassumptions
{-# INLINE rule3235 #-}
rule3235 = \ ((_hdIconstraints) :: ConstraintSet) ->
_hdIconstraints
{-# INLINE rule3236 #-}
rule3236 = \ ((_tlIassumptions) :: Assumptions) ->
_tlIassumptions
{-# INLINE rule3237 #-}
rule3237 = \ ((_tlIconstraints) :: ConstraintSet) ->
_tlIconstraints
{-# INLINE rule3238 #-}
rule3238 = \ ((_lhsIassumptions) :: Assumptions) ->
_lhsIassumptions
{-# INLINE rule3239 #-}
rule3239 = \ ((_lhsIconstraints) :: ConstraintSet) ->
_lhsIconstraints
{-# INLINE rule3240 #-}
rule3240 = \ ((_hdIinfoTree) :: InfoTree) ((_tlIinfoTrees) :: InfoTrees) ->
_hdIinfoTree : _tlIinfoTrees
{-# INLINE rule3241 #-}
rule3241 = \ ((_hdIunboundNames) :: Names) ->
_hdIunboundNames
{-# INLINE rule3242 #-}
rule3242 = \ ((_lhsIunboundNames) :: Names) ->
_lhsIunboundNames
{-# INLINE rule3243 #-}
rule3243 = \ ((_tlIunboundNames) :: Names) ->
_tlIunboundNames
{-# INLINE rule3244 #-}
rule3244 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
_hdIcollectInstances ++ _tlIcollectInstances
{-# INLINE rule3245 #-}
rule3245 = \ ((_hdIself) :: Qualifier) ((_tlIself) :: Qualifiers) ->
(:) _hdIself _tlIself
{-# INLINE rule3246 #-}
rule3246 = \ _self ->
_self
{-# INLINE rule3247 #-}
rule3247 = \ ((_tlIbetaUnique) :: Int) ->
_tlIbetaUnique
{-# INLINE rule3248 #-}
rule3248 = \ ((_tlIcollectErrors) :: TypeErrors) ->
_tlIcollectErrors
{-# INLINE rule3249 #-}
rule3249 = \ ((_tlIcollectWarnings) :: Warnings) ->
_tlIcollectWarnings
{-# INLINE rule3250 #-}
rule3250 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule3251 #-}
rule3251 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
_tlIdictionaryEnvironment
{-# INLINE rule3252 #-}
rule3252 = \ ((_tlImatchIO) :: IO ()) ->
_tlImatchIO
{-# INLINE rule3253 #-}
rule3253 = \ ((_tlImonos) :: Monos) ->
_tlImonos
{-# INLINE rule3254 #-}
rule3254 = \ ((_tlInamesInScope) :: Names) ->
_tlInamesInScope
{-# INLINE rule3255 #-}
rule3255 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
_tlIpatternMatchWarnings
{-# INLINE rule3256 #-}
rule3256 = \ ((_tlIuniqueChunk) :: Int) ->
_tlIuniqueChunk
{-# INLINE rule3257 #-}
rule3257 = \ ((_tlIuniqueSecondRound) :: Int) ->
_tlIuniqueSecondRound
{-# INLINE rule3258 #-}
rule3258 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3259 #-}
rule3259 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule3260 #-}
rule3260 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3261 #-}
rule3261 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3262 #-}
rule3262 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3263 #-}
rule3263 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3264 #-}
rule3264 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3265 #-}
rule3265 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3266 #-}
rule3266 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3267 #-}
rule3267 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3268 #-}
rule3268 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3269 #-}
rule3269 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3270 #-}
rule3270 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3271 #-}
rule3271 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3272 #-}
rule3272 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3273 #-}
rule3273 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule3274 #-}
rule3274 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3275 #-}
rule3275 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3276 #-}
rule3276 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3277 #-}
rule3277 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3278 #-}
rule3278 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule3279 #-}
rule3279 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3280 #-}
rule3280 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule3281 #-}
rule3281 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3282 #-}
rule3282 = \ ((_hdIbetaUnique) :: Int) ->
_hdIbetaUnique
{-# INLINE rule3283 #-}
rule3283 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3284 #-}
rule3284 = \ ((_hdIcollectErrors) :: TypeErrors) ->
_hdIcollectErrors
{-# INLINE rule3285 #-}
rule3285 = \ ((_hdIcollectWarnings) :: Warnings) ->
_hdIcollectWarnings
{-# INLINE rule3286 #-}
rule3286 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule3287 #-}
rule3287 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3288 #-}
rule3288 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
_hdIdictionaryEnvironment
{-# INLINE rule3289 #-}
rule3289 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3290 #-}
rule3290 = \ ((_hdImatchIO) :: IO ()) ->
_hdImatchIO
{-# INLINE rule3291 #-}
rule3291 = \ ((_hdImonos) :: Monos) ->
_hdImonos
{-# INLINE rule3292 #-}
rule3292 = \ ((_hdInamesInScope) :: Names) ->
_hdInamesInScope
{-# INLINE rule3293 #-}
rule3293 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3294 #-}
rule3294 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule3295 #-}
rule3295 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
_hdIpatternMatchWarnings
{-# INLINE rule3296 #-}
rule3296 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3297 #-}
rule3297 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3298 #-}
rule3298 = \ ((_hdIuniqueChunk) :: Int) ->
_hdIuniqueChunk
{-# INLINE rule3299 #-}
rule3299 = \ ((_hdIuniqueSecondRound) :: Int) ->
_hdIuniqueSecondRound
{-# NOINLINE sem_Qualifiers_Nil #-}
sem_Qualifiers_Nil :: T_Qualifiers
sem_Qualifiers_Nil = T_Qualifiers (return st131) where
{-# NOINLINE st131 #-}
st131 = let
v130 :: T_Qualifiers_v130
v130 = \ (T_Qualifiers_vIn130 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule3300 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3301 _lhsIunboundNames
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3302 ()
_self = rule3303 ()
_lhsOself :: Qualifiers
_lhsOself = rule3304 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule3305 _lhsIassumptions
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3306 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3307 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3308 _lhsIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3309 _lhsIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule3310 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3311 _lhsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3312 _lhsImatchIO
_lhsOmonos :: Monos
_lhsOmonos = rule3313 _lhsImonos
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule3314 _lhsInamesInScope
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3315 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3316 _lhsIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule3317 _lhsIuniqueSecondRound
__result_ = T_Qualifiers_vOut130 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Qualifiers_s131 v130
{-# INLINE rule3300 #-}
rule3300 = \ (_ :: ()) ->
[]
{-# INLINE rule3301 #-}
rule3301 = \ ((_lhsIunboundNames) :: Names) ->
_lhsIunboundNames
{-# INLINE rule3302 #-}
rule3302 = \ (_ :: ()) ->
[]
{-# INLINE rule3303 #-}
rule3303 = \ (_ :: ()) ->
[]
{-# INLINE rule3304 #-}
rule3304 = \ _self ->
_self
{-# INLINE rule3305 #-}
rule3305 = \ ((_lhsIassumptions) :: Assumptions) ->
_lhsIassumptions
{-# INLINE rule3306 #-}
rule3306 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3307 #-}
rule3307 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3308 #-}
rule3308 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3309 #-}
rule3309 = \ ((_lhsIconstraints) :: ConstraintSet) ->
_lhsIconstraints
{-# INLINE rule3310 #-}
rule3310 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3311 #-}
rule3311 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3312 #-}
rule3312 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3313 #-}
rule3313 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3314 #-}
rule3314 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3315 #-}
rule3315 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3316 #-}
rule3316 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3317 #-}
rule3317 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
-- Range -------------------------------------------------------
-- wrapper
data Inh_Range = Inh_Range { }
data Syn_Range = Syn_Range { self_Syn_Range :: (Range) }
{-# INLINABLE wrap_Range #-}
wrap_Range :: T_Range -> Inh_Range -> (Syn_Range )
wrap_Range (T_Range act) (Inh_Range ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Range_vIn133
(T_Range_vOut133 _lhsOself) <- return (inv_Range_s134 sem arg)
return (Syn_Range _lhsOself)
)
-- cata
{-# INLINE sem_Range #-}
sem_Range :: Range -> T_Range
sem_Range ( Range_Range start_ stop_ ) = sem_Range_Range ( sem_Position start_ ) ( sem_Position stop_ )
-- semantic domain
newtype T_Range = T_Range {
attach_T_Range :: Identity (T_Range_s134 )
}
newtype T_Range_s134 = C_Range_s134 {
inv_Range_s134 :: (T_Range_v133 )
}
data T_Range_s135 = C_Range_s135
type T_Range_v133 = (T_Range_vIn133 ) -> (T_Range_vOut133 )
data T_Range_vIn133 = T_Range_vIn133
data T_Range_vOut133 = T_Range_vOut133 (Range)
{-# NOINLINE sem_Range_Range #-}
sem_Range_Range :: T_Position -> T_Position -> T_Range
sem_Range_Range arg_start_ arg_stop_ = T_Range (return st134) where
{-# NOINLINE st134 #-}
st134 = let
v133 :: T_Range_v133
v133 = \ (T_Range_vIn133 ) -> ( let
_startX125 = Control.Monad.Identity.runIdentity (attach_T_Position (arg_start_))
_stopX125 = Control.Monad.Identity.runIdentity (attach_T_Position (arg_stop_))
(T_Position_vOut124 _startIself) = inv_Position_s125 _startX125 (T_Position_vIn124 )
(T_Position_vOut124 _stopIself) = inv_Position_s125 _stopX125 (T_Position_vIn124 )
_self = rule3318 _startIself _stopIself
_lhsOself :: Range
_lhsOself = rule3319 _self
__result_ = T_Range_vOut133 _lhsOself
in __result_ )
in C_Range_s134 v133
{-# INLINE rule3318 #-}
rule3318 = \ ((_startIself) :: Position) ((_stopIself) :: Position) ->
Range_Range _startIself _stopIself
{-# INLINE rule3319 #-}
rule3319 = \ _self ->
_self
-- RecordExpressionBinding -------------------------------------
-- wrapper
data Inh_RecordExpressionBinding = Inh_RecordExpressionBinding { allTypeSchemes_Inh_RecordExpressionBinding :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_RecordExpressionBinding :: (Predicates), classEnvironment_Inh_RecordExpressionBinding :: (ClassEnvironment), collectErrors_Inh_RecordExpressionBinding :: (TypeErrors), collectWarnings_Inh_RecordExpressionBinding :: (Warnings), counter_Inh_RecordExpressionBinding :: (Int), currentChunk_Inh_RecordExpressionBinding :: (Int), dictionaryEnvironment_Inh_RecordExpressionBinding :: (DictionaryEnvironment), importEnvironment_Inh_RecordExpressionBinding :: (ImportEnvironment), namesInScope_Inh_RecordExpressionBinding :: (Names), orderedTypeSynonyms_Inh_RecordExpressionBinding :: (OrderedTypeSynonyms), patternMatchWarnings_Inh_RecordExpressionBinding :: ([Warning]), substitution_Inh_RecordExpressionBinding :: (FixpointSubstitution), typeschemeMap_Inh_RecordExpressionBinding :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_RecordExpressionBinding :: (Int) }
data Syn_RecordExpressionBinding = Syn_RecordExpressionBinding { collectErrors_Syn_RecordExpressionBinding :: (TypeErrors), collectInstances_Syn_RecordExpressionBinding :: ([(Name, Instance)]), collectWarnings_Syn_RecordExpressionBinding :: (Warnings), counter_Syn_RecordExpressionBinding :: (Int), dictionaryEnvironment_Syn_RecordExpressionBinding :: (DictionaryEnvironment), patternMatchWarnings_Syn_RecordExpressionBinding :: ([Warning]), self_Syn_RecordExpressionBinding :: (RecordExpressionBinding), unboundNames_Syn_RecordExpressionBinding :: (Names), uniqueChunk_Syn_RecordExpressionBinding :: (Int) }
{-# INLINABLE wrap_RecordExpressionBinding #-}
wrap_RecordExpressionBinding :: T_RecordExpressionBinding -> Inh_RecordExpressionBinding -> (Syn_RecordExpressionBinding )
wrap_RecordExpressionBinding (T_RecordExpressionBinding act) (Inh_RecordExpressionBinding _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_RecordExpressionBinding_vIn136 _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
(T_RecordExpressionBinding_vOut136 _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_RecordExpressionBinding_s137 sem arg)
return (Syn_RecordExpressionBinding _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk)
)
-- cata
{-# NOINLINE sem_RecordExpressionBinding #-}
sem_RecordExpressionBinding :: RecordExpressionBinding -> T_RecordExpressionBinding
sem_RecordExpressionBinding ( RecordExpressionBinding_RecordExpressionBinding range_ name_ expression_ ) = sem_RecordExpressionBinding_RecordExpressionBinding ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Expression expression_ )
-- semantic domain
newtype T_RecordExpressionBinding = T_RecordExpressionBinding {
attach_T_RecordExpressionBinding :: Identity (T_RecordExpressionBinding_s137 )
}
newtype T_RecordExpressionBinding_s137 = C_RecordExpressionBinding_s137 {
inv_RecordExpressionBinding_s137 :: (T_RecordExpressionBinding_v136 )
}
data T_RecordExpressionBinding_s138 = C_RecordExpressionBinding_s138
type T_RecordExpressionBinding_v136 = (T_RecordExpressionBinding_vIn136 ) -> (T_RecordExpressionBinding_vOut136 )
data T_RecordExpressionBinding_vIn136 = T_RecordExpressionBinding_vIn136 (M.Map NameWithRange TpScheme) (Predicates) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (Names) (OrderedTypeSynonyms) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_RecordExpressionBinding_vOut136 = T_RecordExpressionBinding_vOut136 (TypeErrors) ([(Name, Instance)]) (Warnings) (Int) (DictionaryEnvironment) ([Warning]) (RecordExpressionBinding) (Names) (Int)
{-# NOINLINE sem_RecordExpressionBinding_RecordExpressionBinding #-}
sem_RecordExpressionBinding_RecordExpressionBinding :: T_Range -> T_Name -> T_Expression -> T_RecordExpressionBinding
sem_RecordExpressionBinding_RecordExpressionBinding arg_range_ arg_name_ arg_expression_ = T_RecordExpressionBinding (return st137) where
{-# NOINLINE st137 #-}
st137 = let
v136 :: T_RecordExpressionBinding_v136
v136 = \ (T_RecordExpressionBinding_vIn136 _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_parentTree = rule3320 ()
(_monos,_constructorenv,_betaUnique,_miscerrors,_warnings,_kindErrors,_valueConstructors,_allValueConstructors,_typeConstructors,_allTypeConstructors,_importEnvironment) = rule3321 ()
(_allPatterns,_tryPatterns,_matchIO,_uniqueSecondRound) = rule3322 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3323 _expressionIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3324 _expressionIunboundNames
_self = rule3325 _expressionIself _nameIself _rangeIself
_lhsOself :: RecordExpressionBinding
_lhsOself = rule3326 _self
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3327 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3328 _expressionIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule3329 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3330 _expressionIdictionaryEnvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3331 _expressionIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3332 _expressionIuniqueChunk
_expressionOallPatterns = rule3333 _allPatterns
_expressionOallTypeSchemes = rule3334 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule3335 _lhsIavailablePredicates
_expressionObetaUnique = rule3336 _betaUnique
_expressionOclassEnvironment = rule3337 _lhsIclassEnvironment
_expressionOcollectErrors = rule3338 _lhsIcollectErrors
_expressionOcollectWarnings = rule3339 _lhsIcollectWarnings
_expressionOcounter = rule3340 _lhsIcounter
_expressionOcurrentChunk = rule3341 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule3342 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule3343 _importEnvironment
_expressionOmatchIO = rule3344 _matchIO
_expressionOmonos = rule3345 _monos
_expressionOnamesInScope = rule3346 _lhsInamesInScope
_expressionOorderedTypeSynonyms = rule3347 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule3348 _parentTree
_expressionOpatternMatchWarnings = rule3349 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule3350 _lhsIsubstitution
_expressionOtryPatterns = rule3351 _tryPatterns
_expressionOtypeschemeMap = rule3352 _lhsItypeschemeMap
_expressionOuniqueChunk = rule3353 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule3354 _uniqueSecondRound
__result_ = T_RecordExpressionBinding_vOut136 _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_RecordExpressionBinding_s137 v136
{-# INLINE rule3320 #-}
rule3320 = \ (_ :: ()) ->
globalInfoError
{-# INLINE rule3321 #-}
rule3321 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "RecordExpressionBinding.RecordExpressionBinding"
{-# INLINE rule3322 #-}
rule3322 = \ (_ :: ()) ->
internalError "TS_PatternMatching.ag" "n/a" "RecordExpressionBinding is not supported"
{-# INLINE rule3323 #-}
rule3323 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances
{-# INLINE rule3324 #-}
rule3324 = \ ((_expressionIunboundNames) :: Names) ->
_expressionIunboundNames
{-# INLINE rule3325 #-}
rule3325 = \ ((_expressionIself) :: Expression) ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
RecordExpressionBinding_RecordExpressionBinding _rangeIself _nameIself _expressionIself
{-# INLINE rule3326 #-}
rule3326 = \ _self ->
_self
{-# INLINE rule3327 #-}
rule3327 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule3328 #-}
rule3328 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule3329 #-}
rule3329 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule3330 #-}
rule3330 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule3331 #-}
rule3331 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule3332 #-}
rule3332 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule3333 #-}
rule3333 = \ _allPatterns ->
_allPatterns
{-# INLINE rule3334 #-}
rule3334 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule3335 #-}
rule3335 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3336 #-}
rule3336 = \ _betaUnique ->
_betaUnique
{-# INLINE rule3337 #-}
rule3337 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3338 #-}
rule3338 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3339 #-}
rule3339 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3340 #-}
rule3340 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3341 #-}
rule3341 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3342 #-}
rule3342 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3343 #-}
rule3343 = \ _importEnvironment ->
_importEnvironment
{-# INLINE rule3344 #-}
rule3344 = \ _matchIO ->
_matchIO
{-# INLINE rule3345 #-}
rule3345 = \ _monos ->
_monos
{-# INLINE rule3346 #-}
rule3346 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3347 #-}
rule3347 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3348 #-}
rule3348 = \ _parentTree ->
_parentTree
{-# INLINE rule3349 #-}
rule3349 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3350 #-}
rule3350 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3351 #-}
rule3351 = \ _tryPatterns ->
_tryPatterns
{-# INLINE rule3352 #-}
rule3352 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3353 #-}
rule3353 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3354 #-}
rule3354 = \ _uniqueSecondRound ->
_uniqueSecondRound
-- RecordExpressionBindings ------------------------------------
-- wrapper
data Inh_RecordExpressionBindings = Inh_RecordExpressionBindings { allTypeSchemes_Inh_RecordExpressionBindings :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_RecordExpressionBindings :: (Predicates), classEnvironment_Inh_RecordExpressionBindings :: (ClassEnvironment), collectErrors_Inh_RecordExpressionBindings :: (TypeErrors), collectWarnings_Inh_RecordExpressionBindings :: (Warnings), counter_Inh_RecordExpressionBindings :: (Int), currentChunk_Inh_RecordExpressionBindings :: (Int), dictionaryEnvironment_Inh_RecordExpressionBindings :: (DictionaryEnvironment), importEnvironment_Inh_RecordExpressionBindings :: (ImportEnvironment), namesInScope_Inh_RecordExpressionBindings :: (Names), orderedTypeSynonyms_Inh_RecordExpressionBindings :: (OrderedTypeSynonyms), patternMatchWarnings_Inh_RecordExpressionBindings :: ([Warning]), substitution_Inh_RecordExpressionBindings :: (FixpointSubstitution), typeschemeMap_Inh_RecordExpressionBindings :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_RecordExpressionBindings :: (Int) }
data Syn_RecordExpressionBindings = Syn_RecordExpressionBindings { collectErrors_Syn_RecordExpressionBindings :: (TypeErrors), collectInstances_Syn_RecordExpressionBindings :: ([(Name, Instance)]), collectWarnings_Syn_RecordExpressionBindings :: (Warnings), counter_Syn_RecordExpressionBindings :: (Int), dictionaryEnvironment_Syn_RecordExpressionBindings :: (DictionaryEnvironment), patternMatchWarnings_Syn_RecordExpressionBindings :: ([Warning]), self_Syn_RecordExpressionBindings :: (RecordExpressionBindings), unboundNames_Syn_RecordExpressionBindings :: (Names), uniqueChunk_Syn_RecordExpressionBindings :: (Int) }
{-# INLINABLE wrap_RecordExpressionBindings #-}
wrap_RecordExpressionBindings :: T_RecordExpressionBindings -> Inh_RecordExpressionBindings -> (Syn_RecordExpressionBindings )
wrap_RecordExpressionBindings (T_RecordExpressionBindings act) (Inh_RecordExpressionBindings _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_RecordExpressionBindings_vIn139 _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
(T_RecordExpressionBindings_vOut139 _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_RecordExpressionBindings_s140 sem arg)
return (Syn_RecordExpressionBindings _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk)
)
-- cata
{-# NOINLINE sem_RecordExpressionBindings #-}
sem_RecordExpressionBindings :: RecordExpressionBindings -> T_RecordExpressionBindings
sem_RecordExpressionBindings list = Prelude.foldr sem_RecordExpressionBindings_Cons sem_RecordExpressionBindings_Nil (Prelude.map sem_RecordExpressionBinding list)
-- semantic domain
newtype T_RecordExpressionBindings = T_RecordExpressionBindings {
attach_T_RecordExpressionBindings :: Identity (T_RecordExpressionBindings_s140 )
}
newtype T_RecordExpressionBindings_s140 = C_RecordExpressionBindings_s140 {
inv_RecordExpressionBindings_s140 :: (T_RecordExpressionBindings_v139 )
}
data T_RecordExpressionBindings_s141 = C_RecordExpressionBindings_s141
type T_RecordExpressionBindings_v139 = (T_RecordExpressionBindings_vIn139 ) -> (T_RecordExpressionBindings_vOut139 )
data T_RecordExpressionBindings_vIn139 = T_RecordExpressionBindings_vIn139 (M.Map NameWithRange TpScheme) (Predicates) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (Names) (OrderedTypeSynonyms) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_RecordExpressionBindings_vOut139 = T_RecordExpressionBindings_vOut139 (TypeErrors) ([(Name, Instance)]) (Warnings) (Int) (DictionaryEnvironment) ([Warning]) (RecordExpressionBindings) (Names) (Int)
{-# NOINLINE sem_RecordExpressionBindings_Cons #-}
sem_RecordExpressionBindings_Cons :: T_RecordExpressionBinding -> T_RecordExpressionBindings -> T_RecordExpressionBindings
sem_RecordExpressionBindings_Cons arg_hd_ arg_tl_ = T_RecordExpressionBindings (return st140) where
{-# NOINLINE st140 #-}
st140 = let
v139 :: T_RecordExpressionBindings_v139
v139 = \ (T_RecordExpressionBindings_vIn139 _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_hdX137 = Control.Monad.Identity.runIdentity (attach_T_RecordExpressionBinding (arg_hd_))
_tlX140 = Control.Monad.Identity.runIdentity (attach_T_RecordExpressionBindings (arg_tl_))
(T_RecordExpressionBinding_vOut136 _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIcounter _hdIdictionaryEnvironment _hdIpatternMatchWarnings _hdIself _hdIunboundNames _hdIuniqueChunk) = inv_RecordExpressionBinding_s137 _hdX137 (T_RecordExpressionBinding_vIn136 _hdOallTypeSchemes _hdOavailablePredicates _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOnamesInScope _hdOorderedTypeSynonyms _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeschemeMap _hdOuniqueChunk)
(T_RecordExpressionBindings_vOut139 _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIcounter _tlIdictionaryEnvironment _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk) = inv_RecordExpressionBindings_s140 _tlX140 (T_RecordExpressionBindings_vIn139 _tlOallTypeSchemes _tlOavailablePredicates _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOnamesInScope _tlOorderedTypeSynonyms _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeschemeMap _tlOuniqueChunk)
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3355 _hdIcollectInstances _tlIcollectInstances
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3356 _hdIunboundNames _tlIunboundNames
_self = rule3357 _hdIself _tlIself
_lhsOself :: RecordExpressionBindings
_lhsOself = rule3358 _self
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3359 _tlIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3360 _tlIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule3361 _tlIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3362 _tlIdictionaryEnvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3363 _tlIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3364 _tlIuniqueChunk
_hdOallTypeSchemes = rule3365 _lhsIallTypeSchemes
_hdOavailablePredicates = rule3366 _lhsIavailablePredicates
_hdOclassEnvironment = rule3367 _lhsIclassEnvironment
_hdOcollectErrors = rule3368 _lhsIcollectErrors
_hdOcollectWarnings = rule3369 _lhsIcollectWarnings
_hdOcounter = rule3370 _lhsIcounter
_hdOcurrentChunk = rule3371 _lhsIcurrentChunk
_hdOdictionaryEnvironment = rule3372 _lhsIdictionaryEnvironment
_hdOimportEnvironment = rule3373 _lhsIimportEnvironment
_hdOnamesInScope = rule3374 _lhsInamesInScope
_hdOorderedTypeSynonyms = rule3375 _lhsIorderedTypeSynonyms
_hdOpatternMatchWarnings = rule3376 _lhsIpatternMatchWarnings
_hdOsubstitution = rule3377 _lhsIsubstitution
_hdOtypeschemeMap = rule3378 _lhsItypeschemeMap
_hdOuniqueChunk = rule3379 _lhsIuniqueChunk
_tlOallTypeSchemes = rule3380 _lhsIallTypeSchemes
_tlOavailablePredicates = rule3381 _lhsIavailablePredicates
_tlOclassEnvironment = rule3382 _lhsIclassEnvironment
_tlOcollectErrors = rule3383 _hdIcollectErrors
_tlOcollectWarnings = rule3384 _hdIcollectWarnings
_tlOcounter = rule3385 _hdIcounter
_tlOcurrentChunk = rule3386 _lhsIcurrentChunk
_tlOdictionaryEnvironment = rule3387 _hdIdictionaryEnvironment
_tlOimportEnvironment = rule3388 _lhsIimportEnvironment
_tlOnamesInScope = rule3389 _lhsInamesInScope
_tlOorderedTypeSynonyms = rule3390 _lhsIorderedTypeSynonyms
_tlOpatternMatchWarnings = rule3391 _hdIpatternMatchWarnings
_tlOsubstitution = rule3392 _lhsIsubstitution
_tlOtypeschemeMap = rule3393 _lhsItypeschemeMap
_tlOuniqueChunk = rule3394 _hdIuniqueChunk
__result_ = T_RecordExpressionBindings_vOut139 _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_RecordExpressionBindings_s140 v139
{-# INLINE rule3355 #-}
rule3355 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
_hdIcollectInstances ++ _tlIcollectInstances
{-# INLINE rule3356 #-}
rule3356 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
_hdIunboundNames ++ _tlIunboundNames
{-# INLINE rule3357 #-}
rule3357 = \ ((_hdIself) :: RecordExpressionBinding) ((_tlIself) :: RecordExpressionBindings) ->
(:) _hdIself _tlIself
{-# INLINE rule3358 #-}
rule3358 = \ _self ->
_self
{-# INLINE rule3359 #-}
rule3359 = \ ((_tlIcollectErrors) :: TypeErrors) ->
_tlIcollectErrors
{-# INLINE rule3360 #-}
rule3360 = \ ((_tlIcollectWarnings) :: Warnings) ->
_tlIcollectWarnings
{-# INLINE rule3361 #-}
rule3361 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule3362 #-}
rule3362 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
_tlIdictionaryEnvironment
{-# INLINE rule3363 #-}
rule3363 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
_tlIpatternMatchWarnings
{-# INLINE rule3364 #-}
rule3364 = \ ((_tlIuniqueChunk) :: Int) ->
_tlIuniqueChunk
{-# INLINE rule3365 #-}
rule3365 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule3366 #-}
rule3366 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3367 #-}
rule3367 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3368 #-}
rule3368 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3369 #-}
rule3369 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3370 #-}
rule3370 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3371 #-}
rule3371 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3372 #-}
rule3372 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3373 #-}
rule3373 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3374 #-}
rule3374 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3375 #-}
rule3375 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3376 #-}
rule3376 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3377 #-}
rule3377 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3378 #-}
rule3378 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3379 #-}
rule3379 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3380 #-}
rule3380 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule3381 #-}
rule3381 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3382 #-}
rule3382 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3383 #-}
rule3383 = \ ((_hdIcollectErrors) :: TypeErrors) ->
_hdIcollectErrors
{-# INLINE rule3384 #-}
rule3384 = \ ((_hdIcollectWarnings) :: Warnings) ->
_hdIcollectWarnings
{-# INLINE rule3385 #-}
rule3385 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule3386 #-}
rule3386 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3387 #-}
rule3387 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
_hdIdictionaryEnvironment
{-# INLINE rule3388 #-}
rule3388 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3389 #-}
rule3389 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3390 #-}
rule3390 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3391 #-}
rule3391 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
_hdIpatternMatchWarnings
{-# INLINE rule3392 #-}
rule3392 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3393 #-}
rule3393 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3394 #-}
rule3394 = \ ((_hdIuniqueChunk) :: Int) ->
_hdIuniqueChunk
{-# NOINLINE sem_RecordExpressionBindings_Nil #-}
sem_RecordExpressionBindings_Nil :: T_RecordExpressionBindings
sem_RecordExpressionBindings_Nil = T_RecordExpressionBindings (return st140) where
{-# NOINLINE st140 #-}
st140 = let
v139 :: T_RecordExpressionBindings_v139
v139 = \ (T_RecordExpressionBindings_vIn139 _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3395 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3396 ()
_self = rule3397 ()
_lhsOself :: RecordExpressionBindings
_lhsOself = rule3398 _self
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3399 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3400 _lhsIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule3401 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3402 _lhsIdictionaryEnvironment
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3403 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3404 _lhsIuniqueChunk
__result_ = T_RecordExpressionBindings_vOut139 _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_RecordExpressionBindings_s140 v139
{-# INLINE rule3395 #-}
rule3395 = \ (_ :: ()) ->
[]
{-# INLINE rule3396 #-}
rule3396 = \ (_ :: ()) ->
[]
{-# INLINE rule3397 #-}
rule3397 = \ (_ :: ()) ->
[]
{-# INLINE rule3398 #-}
rule3398 = \ _self ->
_self
{-# INLINE rule3399 #-}
rule3399 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3400 #-}
rule3400 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3401 #-}
rule3401 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3402 #-}
rule3402 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3403 #-}
rule3403 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3404 #-}
rule3404 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
-- RecordPatternBinding ----------------------------------------
-- wrapper
data Inh_RecordPatternBinding = Inh_RecordPatternBinding { counter_Inh_RecordPatternBinding :: (Int), namesInScope_Inh_RecordPatternBinding :: (Names), patternMatchWarnings_Inh_RecordPatternBinding :: ([Warning]) }
data Syn_RecordPatternBinding = Syn_RecordPatternBinding { counter_Syn_RecordPatternBinding :: (Int), patternMatchWarnings_Syn_RecordPatternBinding :: ([Warning]), self_Syn_RecordPatternBinding :: (RecordPatternBinding), unboundNames_Syn_RecordPatternBinding :: (Names) }
{-# INLINABLE wrap_RecordPatternBinding #-}
wrap_RecordPatternBinding :: T_RecordPatternBinding -> Inh_RecordPatternBinding -> (Syn_RecordPatternBinding )
wrap_RecordPatternBinding (T_RecordPatternBinding act) (Inh_RecordPatternBinding _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_RecordPatternBinding_vIn142 _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings
(T_RecordPatternBinding_vOut142 _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames) <- return (inv_RecordPatternBinding_s143 sem arg)
return (Syn_RecordPatternBinding _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames)
)
-- cata
{-# NOINLINE sem_RecordPatternBinding #-}
sem_RecordPatternBinding :: RecordPatternBinding -> T_RecordPatternBinding
sem_RecordPatternBinding ( RecordPatternBinding_RecordPatternBinding range_ name_ pattern_ ) = sem_RecordPatternBinding_RecordPatternBinding ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Pattern pattern_ )
-- semantic domain
newtype T_RecordPatternBinding = T_RecordPatternBinding {
attach_T_RecordPatternBinding :: Identity (T_RecordPatternBinding_s143 )
}
newtype T_RecordPatternBinding_s143 = C_RecordPatternBinding_s143 {
inv_RecordPatternBinding_s143 :: (T_RecordPatternBinding_v142 )
}
data T_RecordPatternBinding_s144 = C_RecordPatternBinding_s144
type T_RecordPatternBinding_v142 = (T_RecordPatternBinding_vIn142 ) -> (T_RecordPatternBinding_vOut142 )
data T_RecordPatternBinding_vIn142 = T_RecordPatternBinding_vIn142 (Int) (Names) ([Warning])
data T_RecordPatternBinding_vOut142 = T_RecordPatternBinding_vOut142 (Int) ([Warning]) (RecordPatternBinding) (Names)
{-# NOINLINE sem_RecordPatternBinding_RecordPatternBinding #-}
sem_RecordPatternBinding_RecordPatternBinding :: T_Range -> T_Name -> T_Pattern -> T_RecordPatternBinding
sem_RecordPatternBinding_RecordPatternBinding arg_range_ arg_name_ arg_pattern_ = T_RecordPatternBinding (return st143) where
{-# NOINLINE st143 #-}
st143 = let
v142 :: T_RecordPatternBinding_v142
v142 = \ (T_RecordPatternBinding_vIn142 _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
_parentTree = rule3405 ()
(_monos,_constructorenv,_betaUnique,_miscerrors,_warnings,_valueConstructors,_allValueConstructors,_typeConstructors,_allTypeConstructors,_importEnvironment) = rule3406 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3407 _patternIunboundNames
_self = rule3408 _nameIself _patternIself _rangeIself
_lhsOself :: RecordPatternBinding
_lhsOself = rule3409 _self
_lhsOcounter :: Int
_lhsOcounter = rule3410 _patternIcounter
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3411 _patternIpatternMatchWarnings
_patternObetaUnique = rule3412 _betaUnique
_patternOcounter = rule3413 _lhsIcounter
_patternOimportEnvironment = rule3414 _importEnvironment
_patternOmonos = rule3415 _monos
_patternOnamesInScope = rule3416 _lhsInamesInScope
_patternOparentTree = rule3417 _parentTree
_patternOpatternMatchWarnings = rule3418 _lhsIpatternMatchWarnings
__result_ = T_RecordPatternBinding_vOut142 _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_RecordPatternBinding_s143 v142
{-# INLINE rule3405 #-}
rule3405 = \ (_ :: ()) ->
globalInfoError
{-# INLINE rule3406 #-}
rule3406 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "RecordPatternBinding.RecordPatternBinding"
{-# INLINE rule3407 #-}
rule3407 = \ ((_patternIunboundNames) :: Names) ->
_patternIunboundNames
{-# INLINE rule3408 #-}
rule3408 = \ ((_nameIself) :: Name) ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
RecordPatternBinding_RecordPatternBinding _rangeIself _nameIself _patternIself
{-# INLINE rule3409 #-}
rule3409 = \ _self ->
_self
{-# INLINE rule3410 #-}
rule3410 = \ ((_patternIcounter) :: Int) ->
_patternIcounter
{-# INLINE rule3411 #-}
rule3411 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
_patternIpatternMatchWarnings
{-# INLINE rule3412 #-}
rule3412 = \ _betaUnique ->
_betaUnique
{-# INLINE rule3413 #-}
rule3413 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3414 #-}
rule3414 = \ _importEnvironment ->
_importEnvironment
{-# INLINE rule3415 #-}
rule3415 = \ _monos ->
_monos
{-# INLINE rule3416 #-}
rule3416 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3417 #-}
rule3417 = \ _parentTree ->
_parentTree
{-# INLINE rule3418 #-}
rule3418 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
-- RecordPatternBindings ---------------------------------------
-- wrapper
data Inh_RecordPatternBindings = Inh_RecordPatternBindings { counter_Inh_RecordPatternBindings :: (Int), namesInScope_Inh_RecordPatternBindings :: (Names), patternMatchWarnings_Inh_RecordPatternBindings :: ([Warning]) }
data Syn_RecordPatternBindings = Syn_RecordPatternBindings { counter_Syn_RecordPatternBindings :: (Int), patternMatchWarnings_Syn_RecordPatternBindings :: ([Warning]), self_Syn_RecordPatternBindings :: (RecordPatternBindings), unboundNames_Syn_RecordPatternBindings :: (Names) }
{-# INLINABLE wrap_RecordPatternBindings #-}
wrap_RecordPatternBindings :: T_RecordPatternBindings -> Inh_RecordPatternBindings -> (Syn_RecordPatternBindings )
wrap_RecordPatternBindings (T_RecordPatternBindings act) (Inh_RecordPatternBindings _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_RecordPatternBindings_vIn145 _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings
(T_RecordPatternBindings_vOut145 _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames) <- return (inv_RecordPatternBindings_s146 sem arg)
return (Syn_RecordPatternBindings _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames)
)
-- cata
{-# NOINLINE sem_RecordPatternBindings #-}
sem_RecordPatternBindings :: RecordPatternBindings -> T_RecordPatternBindings
sem_RecordPatternBindings list = Prelude.foldr sem_RecordPatternBindings_Cons sem_RecordPatternBindings_Nil (Prelude.map sem_RecordPatternBinding list)
-- semantic domain
newtype T_RecordPatternBindings = T_RecordPatternBindings {
attach_T_RecordPatternBindings :: Identity (T_RecordPatternBindings_s146 )
}
newtype T_RecordPatternBindings_s146 = C_RecordPatternBindings_s146 {
inv_RecordPatternBindings_s146 :: (T_RecordPatternBindings_v145 )
}
data T_RecordPatternBindings_s147 = C_RecordPatternBindings_s147
type T_RecordPatternBindings_v145 = (T_RecordPatternBindings_vIn145 ) -> (T_RecordPatternBindings_vOut145 )
data T_RecordPatternBindings_vIn145 = T_RecordPatternBindings_vIn145 (Int) (Names) ([Warning])
data T_RecordPatternBindings_vOut145 = T_RecordPatternBindings_vOut145 (Int) ([Warning]) (RecordPatternBindings) (Names)
{-# NOINLINE sem_RecordPatternBindings_Cons #-}
sem_RecordPatternBindings_Cons :: T_RecordPatternBinding -> T_RecordPatternBindings -> T_RecordPatternBindings
sem_RecordPatternBindings_Cons arg_hd_ arg_tl_ = T_RecordPatternBindings (return st146) where
{-# NOINLINE st146 #-}
st146 = let
v145 :: T_RecordPatternBindings_v145
v145 = \ (T_RecordPatternBindings_vIn145 _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings) -> ( let
_hdX143 = Control.Monad.Identity.runIdentity (attach_T_RecordPatternBinding (arg_hd_))
_tlX146 = Control.Monad.Identity.runIdentity (attach_T_RecordPatternBindings (arg_tl_))
(T_RecordPatternBinding_vOut142 _hdIcounter _hdIpatternMatchWarnings _hdIself _hdIunboundNames) = inv_RecordPatternBinding_s143 _hdX143 (T_RecordPatternBinding_vIn142 _hdOcounter _hdOnamesInScope _hdOpatternMatchWarnings)
(T_RecordPatternBindings_vOut145 _tlIcounter _tlIpatternMatchWarnings _tlIself _tlIunboundNames) = inv_RecordPatternBindings_s146 _tlX146 (T_RecordPatternBindings_vIn145 _tlOcounter _tlOnamesInScope _tlOpatternMatchWarnings)
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3419 _hdIunboundNames _tlIunboundNames
_self = rule3420 _hdIself _tlIself
_lhsOself :: RecordPatternBindings
_lhsOself = rule3421 _self
_lhsOcounter :: Int
_lhsOcounter = rule3422 _tlIcounter
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3423 _tlIpatternMatchWarnings
_hdOcounter = rule3424 _lhsIcounter
_hdOnamesInScope = rule3425 _lhsInamesInScope
_hdOpatternMatchWarnings = rule3426 _lhsIpatternMatchWarnings
_tlOcounter = rule3427 _hdIcounter
_tlOnamesInScope = rule3428 _lhsInamesInScope
_tlOpatternMatchWarnings = rule3429 _hdIpatternMatchWarnings
__result_ = T_RecordPatternBindings_vOut145 _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_RecordPatternBindings_s146 v145
{-# INLINE rule3419 #-}
rule3419 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
_hdIunboundNames ++ _tlIunboundNames
{-# INLINE rule3420 #-}
rule3420 = \ ((_hdIself) :: RecordPatternBinding) ((_tlIself) :: RecordPatternBindings) ->
(:) _hdIself _tlIself
{-# INLINE rule3421 #-}
rule3421 = \ _self ->
_self
{-# INLINE rule3422 #-}
rule3422 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule3423 #-}
rule3423 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
_tlIpatternMatchWarnings
{-# INLINE rule3424 #-}
rule3424 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3425 #-}
rule3425 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3426 #-}
rule3426 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3427 #-}
rule3427 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule3428 #-}
rule3428 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3429 #-}
rule3429 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
_hdIpatternMatchWarnings
{-# NOINLINE sem_RecordPatternBindings_Nil #-}
sem_RecordPatternBindings_Nil :: T_RecordPatternBindings
sem_RecordPatternBindings_Nil = T_RecordPatternBindings (return st146) where
{-# NOINLINE st146 #-}
st146 = let
v145 :: T_RecordPatternBindings_v145
v145 = \ (T_RecordPatternBindings_vIn145 _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings) -> ( let
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3430 ()
_self = rule3431 ()
_lhsOself :: RecordPatternBindings
_lhsOself = rule3432 _self
_lhsOcounter :: Int
_lhsOcounter = rule3433 _lhsIcounter
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3434 _lhsIpatternMatchWarnings
__result_ = T_RecordPatternBindings_vOut145 _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
in __result_ )
in C_RecordPatternBindings_s146 v145
{-# INLINE rule3430 #-}
rule3430 = \ (_ :: ()) ->
[]
{-# INLINE rule3431 #-}
rule3431 = \ (_ :: ()) ->
[]
{-# INLINE rule3432 #-}
rule3432 = \ _self ->
_self
{-# INLINE rule3433 #-}
rule3433 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3434 #-}
rule3434 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
-- RightHandSide -----------------------------------------------
-- wrapper
data Inh_RightHandSide = Inh_RightHandSide { allPatterns_Inh_RightHandSide :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_RightHandSide :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_RightHandSide :: (Predicates), betaRight_Inh_RightHandSide :: (Tp), betaUnique_Inh_RightHandSide :: (Int), classEnvironment_Inh_RightHandSide :: (ClassEnvironment), collectErrors_Inh_RightHandSide :: (TypeErrors), collectWarnings_Inh_RightHandSide :: (Warnings), counter_Inh_RightHandSide :: (Int), currentChunk_Inh_RightHandSide :: (Int), dictionaryEnvironment_Inh_RightHandSide :: (DictionaryEnvironment), importEnvironment_Inh_RightHandSide :: (ImportEnvironment), matchIO_Inh_RightHandSide :: (IO ()), monos_Inh_RightHandSide :: (Monos), namesInScope_Inh_RightHandSide :: (Names), orderedTypeSynonyms_Inh_RightHandSide :: (OrderedTypeSynonyms), parentTree_Inh_RightHandSide :: (InfoTree), patternMatchWarnings_Inh_RightHandSide :: ([Warning]), substitution_Inh_RightHandSide :: (FixpointSubstitution), typeschemeMap_Inh_RightHandSide :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_RightHandSide :: (Int) }
data Syn_RightHandSide = Syn_RightHandSide { assumptions_Syn_RightHandSide :: (Assumptions), betaUnique_Syn_RightHandSide :: (Int), collectErrors_Syn_RightHandSide :: (TypeErrors), collectInstances_Syn_RightHandSide :: ([(Name, Instance)]), collectWarnings_Syn_RightHandSide :: (Warnings), constraints_Syn_RightHandSide :: (ConstraintSet), counter_Syn_RightHandSide :: (Int), dictionaryEnvironment_Syn_RightHandSide :: (DictionaryEnvironment), fallthrough_Syn_RightHandSide :: (Bool), infoTree_Syn_RightHandSide :: (InfoTree), matchIO_Syn_RightHandSide :: (IO ()), patternMatchWarnings_Syn_RightHandSide :: ([Warning]), self_Syn_RightHandSide :: (RightHandSide), unboundNames_Syn_RightHandSide :: (Names), uniqueChunk_Syn_RightHandSide :: (Int) }
{-# INLINABLE wrap_RightHandSide #-}
wrap_RightHandSide :: T_RightHandSide -> Inh_RightHandSide -> (Syn_RightHandSide )
wrap_RightHandSide (T_RightHandSide act) (Inh_RightHandSide _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_RightHandSide_vIn148 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
(T_RightHandSide_vOut148 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_RightHandSide_s149 sem arg)
return (Syn_RightHandSide _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk)
)
-- cata
{-# NOINLINE sem_RightHandSide #-}
sem_RightHandSide :: RightHandSide -> T_RightHandSide
sem_RightHandSide ( RightHandSide_Expression range_ expression_ where_ ) = sem_RightHandSide_Expression ( sem_Range range_ ) ( sem_Expression expression_ ) ( sem_MaybeDeclarations where_ )
sem_RightHandSide ( RightHandSide_Guarded range_ guardedexpressions_ where_ ) = sem_RightHandSide_Guarded ( sem_Range range_ ) ( sem_GuardedExpressions guardedexpressions_ ) ( sem_MaybeDeclarations where_ )
-- semantic domain
newtype T_RightHandSide = T_RightHandSide {
attach_T_RightHandSide :: Identity (T_RightHandSide_s149 )
}
newtype T_RightHandSide_s149 = C_RightHandSide_s149 {
inv_RightHandSide_s149 :: (T_RightHandSide_v148 )
}
data T_RightHandSide_s150 = C_RightHandSide_s150
type T_RightHandSide_v148 = (T_RightHandSide_vIn148 ) -> (T_RightHandSide_vOut148 )
data T_RightHandSide_vIn148 = T_RightHandSide_vIn148 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_RightHandSide_vOut148 = T_RightHandSide_vOut148 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (Bool) (InfoTree) (IO ()) ([Warning]) (RightHandSide) (Names) (Int)
{-# NOINLINE sem_RightHandSide_Expression #-}
sem_RightHandSide_Expression :: T_Range -> T_Expression -> T_MaybeDeclarations -> T_RightHandSide
sem_RightHandSide_Expression arg_range_ arg_expression_ arg_where_ = T_RightHandSide (return st149) where
{-# NOINLINE st149 #-}
st149 = let
v148 :: T_RightHandSide_v148
v148 = \ (T_RightHandSide_vIn148 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
_whereX89 = Control.Monad.Identity.runIdentity (attach_T_MaybeDeclarations (arg_where_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
(T_MaybeDeclarations_vOut88 _whereIassumptions _whereIbetaUnique _whereIcollectErrors _whereIcollectInstances _whereIcollectWarnings _whereIconstraints _whereIcounter _whereIdictionaryEnvironment _whereIinfoTrees _whereIlocalTypes _whereImatchIO _whereInamesInScope _whereIpatternMatchWarnings _whereIself _whereIunboundNames _whereIuniqueChunk) = inv_MaybeDeclarations_s89 _whereX89 (T_MaybeDeclarations_vIn88 _whereOallPatterns _whereOallTypeSchemes _whereOassumptions _whereOavailablePredicates _whereObetaUnique _whereOclassEnvironment _whereOcollectErrors _whereOcollectWarnings _whereOconstraints _whereOcounter _whereOcurrentChunk _whereOdictionaryEnvironment _whereOimportEnvironment _whereOmatchIO _whereOmonos _whereOnamesInScope _whereOorderedTypeSynonyms _whereOparentTree _whereOpatternMatchWarnings _whereOsubstitution _whereOtypeschemeMap _whereOunboundNames _whereOuniqueChunk)
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule3435 _whereIassumptions
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3436 _whereIconstraints
_whereOassumptions = rule3437 _expressionIassumptions
_whereOconstraints = rule3438 _expressionIconstraints _newcon
_newcon = rule3439 _cinfo _expressionIbeta _lhsIbetaRight
_allTypeSchemes = rule3440 _lhsIallTypeSchemes _whereIlocalTypes
_cinfo = rule3441 _lhsIbetaRight _lhsIparentTree _parentTree
_localInfo = rule3442 _lhsImonos _self
_parentTree = rule3443 _expressionIinfoTree _lhsIparentTree _localInfo _whereIinfoTrees
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule3444 _parentTree
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3445 _whereIunboundNames
_expressionOnamesInScope = rule3446 _whereInamesInScope
_whereOunboundNames = rule3447 _expressionIunboundNames
_expressionOuniqueSecondRound = rule3448 _expressionIbetaUnique
_whereObetaUnique = rule3449 _expressionIuniqueSecondRound
_expressionOtryPatterns = rule3450 ()
_lhsOfallthrough :: Bool
_lhsOfallthrough = rule3451 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3452 _expressionIcollectInstances _whereIcollectInstances
_self = rule3453 _expressionIself _rangeIself _whereIself
_lhsOself :: RightHandSide
_lhsOself = rule3454 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3455 _whereIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3456 _whereIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3457 _whereIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule3458 _whereIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3459 _whereIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3460 _whereImatchIO
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3461 _whereIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3462 _whereIuniqueChunk
_expressionOallPatterns = rule3463 _lhsIallPatterns
_expressionOallTypeSchemes = rule3464 _allTypeSchemes
_expressionOavailablePredicates = rule3465 _lhsIavailablePredicates
_expressionObetaUnique = rule3466 _lhsIbetaUnique
_expressionOclassEnvironment = rule3467 _lhsIclassEnvironment
_expressionOcollectErrors = rule3468 _lhsIcollectErrors
_expressionOcollectWarnings = rule3469 _lhsIcollectWarnings
_expressionOcounter = rule3470 _lhsIcounter
_expressionOcurrentChunk = rule3471 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule3472 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule3473 _lhsIimportEnvironment
_expressionOmatchIO = rule3474 _lhsImatchIO
_expressionOmonos = rule3475 _lhsImonos
_expressionOorderedTypeSynonyms = rule3476 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule3477 _parentTree
_expressionOpatternMatchWarnings = rule3478 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule3479 _lhsIsubstitution
_expressionOtypeschemeMap = rule3480 _lhsItypeschemeMap
_expressionOuniqueChunk = rule3481 _lhsIuniqueChunk
_whereOallPatterns = rule3482 _lhsIallPatterns
_whereOallTypeSchemes = rule3483 _allTypeSchemes
_whereOavailablePredicates = rule3484 _lhsIavailablePredicates
_whereOclassEnvironment = rule3485 _lhsIclassEnvironment
_whereOcollectErrors = rule3486 _expressionIcollectErrors
_whereOcollectWarnings = rule3487 _expressionIcollectWarnings
_whereOcounter = rule3488 _expressionIcounter
_whereOcurrentChunk = rule3489 _lhsIcurrentChunk
_whereOdictionaryEnvironment = rule3490 _expressionIdictionaryEnvironment
_whereOimportEnvironment = rule3491 _lhsIimportEnvironment
_whereOmatchIO = rule3492 _expressionImatchIO
_whereOmonos = rule3493 _lhsImonos
_whereOnamesInScope = rule3494 _lhsInamesInScope
_whereOorderedTypeSynonyms = rule3495 _lhsIorderedTypeSynonyms
_whereOparentTree = rule3496 _parentTree
_whereOpatternMatchWarnings = rule3497 _expressionIpatternMatchWarnings
_whereOsubstitution = rule3498 _lhsIsubstitution
_whereOtypeschemeMap = rule3499 _lhsItypeschemeMap
_whereOuniqueChunk = rule3500 _expressionIuniqueChunk
__result_ = T_RightHandSide_vOut148 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_RightHandSide_s149 v148
{-# INLINE rule3435 #-}
rule3435 = \ ((_whereIassumptions) :: Assumptions) ->
_whereIassumptions
{-# INLINE rule3436 #-}
rule3436 = \ ((_whereIconstraints) :: ConstraintSet) ->
_whereIconstraints
{-# INLINE rule3437 #-}
rule3437 = \ ((_expressionIassumptions) :: Assumptions) ->
_expressionIassumptions
{-# INLINE rule3438 #-}
rule3438 = \ ((_expressionIconstraints) :: ConstraintSet) _newcon ->
_newcon .>. _expressionIconstraints
{-# INLINE rule3439 #-}
rule3439 = \ _cinfo ((_expressionIbeta) :: Tp) ((_lhsIbetaRight) :: Tp) ->
[ (_expressionIbeta .==. _lhsIbetaRight) _cinfo ]
{-# INLINE rule3440 #-}
rule3440 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ((_whereIlocalTypes) :: M.Map NameWithRange TpScheme) ->
_whereIlocalTypes `M.union` _lhsIallTypeSchemes
{-# INLINE rule3441 #-}
rule3441 = \ ((_lhsIbetaRight) :: Tp) ((_lhsIparentTree) :: InfoTree) _parentTree ->
orphanConstraint 0 "right-hand side" _parentTree
[ Unifier (head (ftv _lhsIbetaRight)) ("right-hand sides", attribute (skip_UHA_FB_RHS _lhsIparentTree), "right-hand side") ]
{-# INLINE rule3442 #-}
rule3442 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_RHS _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule3443 #-}
rule3443 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_whereIinfoTrees) :: InfoTrees) ->
node _lhsIparentTree _localInfo (_expressionIinfoTree : _whereIinfoTrees)
{-# INLINE rule3444 #-}
rule3444 = \ _parentTree ->
_parentTree
{-# INLINE rule3445 #-}
rule3445 = \ ((_whereIunboundNames) :: Names) ->
_whereIunboundNames
{-# INLINE rule3446 #-}
rule3446 = \ ((_whereInamesInScope) :: Names) ->
_whereInamesInScope
{-# INLINE rule3447 #-}
rule3447 = \ ((_expressionIunboundNames) :: Names) ->
_expressionIunboundNames
{-# INLINE rule3448 #-}
rule3448 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule3449 #-}
rule3449 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule3450 #-}
rule3450 = \ (_ :: ()) ->
[]
{-# INLINE rule3451 #-}
rule3451 = \ (_ :: ()) ->
False
{-# INLINE rule3452 #-}
rule3452 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ((_whereIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances ++ _whereIcollectInstances
{-# INLINE rule3453 #-}
rule3453 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ((_whereIself) :: MaybeDeclarations) ->
RightHandSide_Expression _rangeIself _expressionIself _whereIself
{-# INLINE rule3454 #-}
rule3454 = \ _self ->
_self
{-# INLINE rule3455 #-}
rule3455 = \ ((_whereIbetaUnique) :: Int) ->
_whereIbetaUnique
{-# INLINE rule3456 #-}
rule3456 = \ ((_whereIcollectErrors) :: TypeErrors) ->
_whereIcollectErrors
{-# INLINE rule3457 #-}
rule3457 = \ ((_whereIcollectWarnings) :: Warnings) ->
_whereIcollectWarnings
{-# INLINE rule3458 #-}
rule3458 = \ ((_whereIcounter) :: Int) ->
_whereIcounter
{-# INLINE rule3459 #-}
rule3459 = \ ((_whereIdictionaryEnvironment) :: DictionaryEnvironment) ->
_whereIdictionaryEnvironment
{-# INLINE rule3460 #-}
rule3460 = \ ((_whereImatchIO) :: IO ()) ->
_whereImatchIO
{-# INLINE rule3461 #-}
rule3461 = \ ((_whereIpatternMatchWarnings) :: [Warning]) ->
_whereIpatternMatchWarnings
{-# INLINE rule3462 #-}
rule3462 = \ ((_whereIuniqueChunk) :: Int) ->
_whereIuniqueChunk
{-# INLINE rule3463 #-}
rule3463 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3464 #-}
rule3464 = \ _allTypeSchemes ->
_allTypeSchemes
{-# INLINE rule3465 #-}
rule3465 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3466 #-}
rule3466 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3467 #-}
rule3467 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3468 #-}
rule3468 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3469 #-}
rule3469 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3470 #-}
rule3470 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3471 #-}
rule3471 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3472 #-}
rule3472 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3473 #-}
rule3473 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3474 #-}
rule3474 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3475 #-}
rule3475 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3476 #-}
rule3476 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3477 #-}
rule3477 = \ _parentTree ->
_parentTree
{-# INLINE rule3478 #-}
rule3478 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3479 #-}
rule3479 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3480 #-}
rule3480 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3481 #-}
rule3481 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3482 #-}
rule3482 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3483 #-}
rule3483 = \ _allTypeSchemes ->
_allTypeSchemes
{-# INLINE rule3484 #-}
rule3484 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3485 #-}
rule3485 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3486 #-}
rule3486 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule3487 #-}
rule3487 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule3488 #-}
rule3488 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule3489 #-}
rule3489 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3490 #-}
rule3490 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule3491 #-}
rule3491 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3492 #-}
rule3492 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule3493 #-}
rule3493 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3494 #-}
rule3494 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3495 #-}
rule3495 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3496 #-}
rule3496 = \ _parentTree ->
_parentTree
{-# INLINE rule3497 #-}
rule3497 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule3498 #-}
rule3498 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3499 #-}
rule3499 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3500 #-}
rule3500 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# NOINLINE sem_RightHandSide_Guarded #-}
sem_RightHandSide_Guarded :: T_Range -> T_GuardedExpressions -> T_MaybeDeclarations -> T_RightHandSide
sem_RightHandSide_Guarded arg_range_ arg_guardedexpressions_ arg_where_ = T_RightHandSide (return st149) where
{-# NOINLINE st149 #-}
st149 = let
v148 :: T_RightHandSide_v148
v148 = \ (T_RightHandSide_vIn148 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_guardedexpressionsX65 = Control.Monad.Identity.runIdentity (attach_T_GuardedExpressions (arg_guardedexpressions_))
_whereX89 = Control.Monad.Identity.runIdentity (attach_T_MaybeDeclarations (arg_where_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_GuardedExpressions_vOut64 _guardedexpressionsIassumptions _guardedexpressionsIbetaUnique _guardedexpressionsIcollectErrors _guardedexpressionsIcollectInstances _guardedexpressionsIcollectWarnings _guardedexpressionsIconstraintslist _guardedexpressionsIcounter _guardedexpressionsIdictionaryEnvironment _guardedexpressionsIfallthrough _guardedexpressionsIinfoTrees _guardedexpressionsImatchIO _guardedexpressionsIpatternMatchWarnings _guardedexpressionsIself _guardedexpressionsIunboundNames _guardedexpressionsIuniqueChunk _guardedexpressionsIuniqueSecondRound) = inv_GuardedExpressions_s65 _guardedexpressionsX65 (T_GuardedExpressions_vIn64 _guardedexpressionsOallPatterns _guardedexpressionsOallTypeSchemes _guardedexpressionsOavailablePredicates _guardedexpressionsObetaRight _guardedexpressionsObetaUnique _guardedexpressionsOclassEnvironment _guardedexpressionsOcollectErrors _guardedexpressionsOcollectWarnings _guardedexpressionsOcounter _guardedexpressionsOcurrentChunk _guardedexpressionsOdictionaryEnvironment _guardedexpressionsOimportEnvironment _guardedexpressionsOmatchIO _guardedexpressionsOmonos _guardedexpressionsOnamesInScope _guardedexpressionsOnumberOfGuards _guardedexpressionsOopen _guardedexpressionsOorderedTypeSynonyms _guardedexpressionsOparentTree _guardedexpressionsOpatternMatchWarnings _guardedexpressionsOsubstitution _guardedexpressionsOtypeschemeMap _guardedexpressionsOuniqueChunk _guardedexpressionsOuniqueSecondRound)
(T_MaybeDeclarations_vOut88 _whereIassumptions _whereIbetaUnique _whereIcollectErrors _whereIcollectInstances _whereIcollectWarnings _whereIconstraints _whereIcounter _whereIdictionaryEnvironment _whereIinfoTrees _whereIlocalTypes _whereImatchIO _whereInamesInScope _whereIpatternMatchWarnings _whereIself _whereIunboundNames _whereIuniqueChunk) = inv_MaybeDeclarations_s89 _whereX89 (T_MaybeDeclarations_vIn88 _whereOallPatterns _whereOallTypeSchemes _whereOassumptions _whereOavailablePredicates _whereObetaUnique _whereOclassEnvironment _whereOcollectErrors _whereOcollectWarnings _whereOconstraints _whereOcounter _whereOcurrentChunk _whereOdictionaryEnvironment _whereOimportEnvironment _whereOmatchIO _whereOmonos _whereOnamesInScope _whereOorderedTypeSynonyms _whereOparentTree _whereOpatternMatchWarnings _whereOsubstitution _whereOtypeschemeMap _whereOunboundNames _whereOuniqueChunk)
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule3501 _whereIassumptions
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3502 _whereIconstraints
_guardedexpressionsOnumberOfGuards = rule3503 _guardedexpressionsIconstraintslist
_whereOassumptions = rule3504 _guardedexpressionsIassumptions
_whereOconstraints = rule3505 _guardedexpressionsIconstraintslist
_allTypeSchemes = rule3506 _lhsIallTypeSchemes _whereIlocalTypes
_localInfo = rule3507 _lhsImonos _self
_parentTree = rule3508 _guardedexpressionsIinfoTrees _lhsIparentTree _localInfo _whereIinfoTrees
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule3509 _parentTree
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3510 _whereIunboundNames
_guardedexpressionsOnamesInScope = rule3511 _whereInamesInScope
_whereOunboundNames = rule3512 _guardedexpressionsIunboundNames
_guardedexpressionsOuniqueSecondRound = rule3513 _guardedexpressionsIbetaUnique
_whereObetaUnique = rule3514 _guardedexpressionsIuniqueSecondRound
_lhsOfallthrough :: Bool
_lhsOfallthrough = rule3515 _guardedexpressionsIfallthrough
_guardedexpressionsOopen = rule3516 ()
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3517 _guardedexpressionsIfallthrough _rangeIself _whereIpatternMatchWarnings
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3518 _guardedexpressionsIcollectInstances _whereIcollectInstances
_self = rule3519 _guardedexpressionsIself _rangeIself _whereIself
_lhsOself :: RightHandSide
_lhsOself = rule3520 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3521 _whereIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3522 _whereIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3523 _whereIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule3524 _whereIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3525 _whereIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3526 _whereImatchIO
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3527 _whereIuniqueChunk
_guardedexpressionsOallPatterns = rule3528 _lhsIallPatterns
_guardedexpressionsOallTypeSchemes = rule3529 _allTypeSchemes
_guardedexpressionsOavailablePredicates = rule3530 _lhsIavailablePredicates
_guardedexpressionsObetaRight = rule3531 _lhsIbetaRight
_guardedexpressionsObetaUnique = rule3532 _lhsIbetaUnique
_guardedexpressionsOclassEnvironment = rule3533 _lhsIclassEnvironment
_guardedexpressionsOcollectErrors = rule3534 _lhsIcollectErrors
_guardedexpressionsOcollectWarnings = rule3535 _lhsIcollectWarnings
_guardedexpressionsOcounter = rule3536 _lhsIcounter
_guardedexpressionsOcurrentChunk = rule3537 _lhsIcurrentChunk
_guardedexpressionsOdictionaryEnvironment = rule3538 _lhsIdictionaryEnvironment
_guardedexpressionsOimportEnvironment = rule3539 _lhsIimportEnvironment
_guardedexpressionsOmatchIO = rule3540 _lhsImatchIO
_guardedexpressionsOmonos = rule3541 _lhsImonos
_guardedexpressionsOorderedTypeSynonyms = rule3542 _lhsIorderedTypeSynonyms
_guardedexpressionsOparentTree = rule3543 _parentTree
_guardedexpressionsOpatternMatchWarnings = rule3544 _lhsIpatternMatchWarnings
_guardedexpressionsOsubstitution = rule3545 _lhsIsubstitution
_guardedexpressionsOtypeschemeMap = rule3546 _lhsItypeschemeMap
_guardedexpressionsOuniqueChunk = rule3547 _lhsIuniqueChunk
_whereOallPatterns = rule3548 _lhsIallPatterns
_whereOallTypeSchemes = rule3549 _allTypeSchemes
_whereOavailablePredicates = rule3550 _lhsIavailablePredicates
_whereOclassEnvironment = rule3551 _lhsIclassEnvironment
_whereOcollectErrors = rule3552 _guardedexpressionsIcollectErrors
_whereOcollectWarnings = rule3553 _guardedexpressionsIcollectWarnings
_whereOcounter = rule3554 _guardedexpressionsIcounter
_whereOcurrentChunk = rule3555 _lhsIcurrentChunk
_whereOdictionaryEnvironment = rule3556 _guardedexpressionsIdictionaryEnvironment
_whereOimportEnvironment = rule3557 _lhsIimportEnvironment
_whereOmatchIO = rule3558 _guardedexpressionsImatchIO
_whereOmonos = rule3559 _lhsImonos
_whereOnamesInScope = rule3560 _lhsInamesInScope
_whereOorderedTypeSynonyms = rule3561 _lhsIorderedTypeSynonyms
_whereOparentTree = rule3562 _parentTree
_whereOpatternMatchWarnings = rule3563 _guardedexpressionsIpatternMatchWarnings
_whereOsubstitution = rule3564 _lhsIsubstitution
_whereOtypeschemeMap = rule3565 _lhsItypeschemeMap
_whereOuniqueChunk = rule3566 _guardedexpressionsIuniqueChunk
__result_ = T_RightHandSide_vOut148 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
in __result_ )
in C_RightHandSide_s149 v148
{-# INLINE rule3501 #-}
rule3501 = \ ((_whereIassumptions) :: Assumptions) ->
_whereIassumptions
{-# INLINE rule3502 #-}
rule3502 = \ ((_whereIconstraints) :: ConstraintSet) ->
_whereIconstraints
{-# INLINE rule3503 #-}
rule3503 = \ ((_guardedexpressionsIconstraintslist) :: ConstraintSets) ->
length _guardedexpressionsIconstraintslist
{-# INLINE rule3504 #-}
rule3504 = \ ((_guardedexpressionsIassumptions) :: Assumptions) ->
_guardedexpressionsIassumptions
{-# INLINE rule3505 #-}
rule3505 = \ ((_guardedexpressionsIconstraintslist) :: ConstraintSets) ->
Node _guardedexpressionsIconstraintslist
{-# INLINE rule3506 #-}
rule3506 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ((_whereIlocalTypes) :: M.Map NameWithRange TpScheme) ->
_whereIlocalTypes `M.union` _lhsIallTypeSchemes
{-# INLINE rule3507 #-}
rule3507 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_RHS _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule3508 #-}
rule3508 = \ ((_guardedexpressionsIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) _localInfo ((_whereIinfoTrees) :: InfoTrees) ->
node _lhsIparentTree _localInfo (_guardedexpressionsIinfoTrees ++ _whereIinfoTrees)
{-# INLINE rule3509 #-}
rule3509 = \ _parentTree ->
_parentTree
{-# INLINE rule3510 #-}
rule3510 = \ ((_whereIunboundNames) :: Names) ->
_whereIunboundNames
{-# INLINE rule3511 #-}
rule3511 = \ ((_whereInamesInScope) :: Names) ->
_whereInamesInScope
{-# INLINE rule3512 #-}
rule3512 = \ ((_guardedexpressionsIunboundNames) :: Names) ->
_guardedexpressionsIunboundNames
{-# INLINE rule3513 #-}
rule3513 = \ ((_guardedexpressionsIbetaUnique) :: Int) ->
_guardedexpressionsIbetaUnique
{-# INLINE rule3514 #-}
rule3514 = \ ((_guardedexpressionsIuniqueSecondRound) :: Int) ->
_guardedexpressionsIuniqueSecondRound
{-# INLINE rule3515 #-}
rule3515 = \ ((_guardedexpressionsIfallthrough) :: Bool) ->
_guardedexpressionsIfallthrough
{-# INLINE rule3516 #-}
rule3516 = \ (_ :: ()) ->
True
{-# INLINE rule3517 #-}
rule3517 = \ ((_guardedexpressionsIfallthrough) :: Bool) ((_rangeIself) :: Range) ((_whereIpatternMatchWarnings) :: [Warning]) ->
(if _guardedexpressionsIfallthrough then [FallThrough _rangeIself] else [])
++ _whereIpatternMatchWarnings
{-# INLINE rule3518 #-}
rule3518 = \ ((_guardedexpressionsIcollectInstances) :: [(Name, Instance)]) ((_whereIcollectInstances) :: [(Name, Instance)]) ->
_guardedexpressionsIcollectInstances ++ _whereIcollectInstances
{-# INLINE rule3519 #-}
rule3519 = \ ((_guardedexpressionsIself) :: GuardedExpressions) ((_rangeIself) :: Range) ((_whereIself) :: MaybeDeclarations) ->
RightHandSide_Guarded _rangeIself _guardedexpressionsIself _whereIself
{-# INLINE rule3520 #-}
rule3520 = \ _self ->
_self
{-# INLINE rule3521 #-}
rule3521 = \ ((_whereIbetaUnique) :: Int) ->
_whereIbetaUnique
{-# INLINE rule3522 #-}
rule3522 = \ ((_whereIcollectErrors) :: TypeErrors) ->
_whereIcollectErrors
{-# INLINE rule3523 #-}
rule3523 = \ ((_whereIcollectWarnings) :: Warnings) ->
_whereIcollectWarnings
{-# INLINE rule3524 #-}
rule3524 = \ ((_whereIcounter) :: Int) ->
_whereIcounter
{-# INLINE rule3525 #-}
rule3525 = \ ((_whereIdictionaryEnvironment) :: DictionaryEnvironment) ->
_whereIdictionaryEnvironment
{-# INLINE rule3526 #-}
rule3526 = \ ((_whereImatchIO) :: IO ()) ->
_whereImatchIO
{-# INLINE rule3527 #-}
rule3527 = \ ((_whereIuniqueChunk) :: Int) ->
_whereIuniqueChunk
{-# INLINE rule3528 #-}
rule3528 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3529 #-}
rule3529 = \ _allTypeSchemes ->
_allTypeSchemes
{-# INLINE rule3530 #-}
rule3530 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3531 #-}
rule3531 = \ ((_lhsIbetaRight) :: Tp) ->
_lhsIbetaRight
{-# INLINE rule3532 #-}
rule3532 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3533 #-}
rule3533 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3534 #-}
rule3534 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3535 #-}
rule3535 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3536 #-}
rule3536 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3537 #-}
rule3537 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3538 #-}
rule3538 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3539 #-}
rule3539 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3540 #-}
rule3540 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3541 #-}
rule3541 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3542 #-}
rule3542 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3543 #-}
rule3543 = \ _parentTree ->
_parentTree
{-# INLINE rule3544 #-}
rule3544 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3545 #-}
rule3545 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3546 #-}
rule3546 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3547 #-}
rule3547 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3548 #-}
rule3548 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3549 #-}
rule3549 = \ _allTypeSchemes ->
_allTypeSchemes
{-# INLINE rule3550 #-}
rule3550 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3551 #-}
rule3551 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3552 #-}
rule3552 = \ ((_guardedexpressionsIcollectErrors) :: TypeErrors) ->
_guardedexpressionsIcollectErrors
{-# INLINE rule3553 #-}
rule3553 = \ ((_guardedexpressionsIcollectWarnings) :: Warnings) ->
_guardedexpressionsIcollectWarnings
{-# INLINE rule3554 #-}
rule3554 = \ ((_guardedexpressionsIcounter) :: Int) ->
_guardedexpressionsIcounter
{-# INLINE rule3555 #-}
rule3555 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3556 #-}
rule3556 = \ ((_guardedexpressionsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_guardedexpressionsIdictionaryEnvironment
{-# INLINE rule3557 #-}
rule3557 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3558 #-}
rule3558 = \ ((_guardedexpressionsImatchIO) :: IO ()) ->
_guardedexpressionsImatchIO
{-# INLINE rule3559 #-}
rule3559 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3560 #-}
rule3560 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3561 #-}
rule3561 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3562 #-}
rule3562 = \ _parentTree ->
_parentTree
{-# INLINE rule3563 #-}
rule3563 = \ ((_guardedexpressionsIpatternMatchWarnings) :: [Warning]) ->
_guardedexpressionsIpatternMatchWarnings
{-# INLINE rule3564 #-}
rule3564 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3565 #-}
rule3565 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3566 #-}
rule3566 = \ ((_guardedexpressionsIuniqueChunk) :: Int) ->
_guardedexpressionsIuniqueChunk
-- SimpleType --------------------------------------------------
-- wrapper
data Inh_SimpleType = Inh_SimpleType { }
data Syn_SimpleType = Syn_SimpleType { name_Syn_SimpleType :: (Name), self_Syn_SimpleType :: (SimpleType), typevariables_Syn_SimpleType :: (Names) }
{-# INLINABLE wrap_SimpleType #-}
wrap_SimpleType :: T_SimpleType -> Inh_SimpleType -> (Syn_SimpleType )
wrap_SimpleType (T_SimpleType act) (Inh_SimpleType ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_SimpleType_vIn151
(T_SimpleType_vOut151 _lhsOname _lhsOself _lhsOtypevariables) <- return (inv_SimpleType_s152 sem arg)
return (Syn_SimpleType _lhsOname _lhsOself _lhsOtypevariables)
)
-- cata
{-# INLINE sem_SimpleType #-}
sem_SimpleType :: SimpleType -> T_SimpleType
sem_SimpleType ( SimpleType_SimpleType range_ name_ typevariables_ ) = sem_SimpleType_SimpleType ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Names typevariables_ )
-- semantic domain
newtype T_SimpleType = T_SimpleType {
attach_T_SimpleType :: Identity (T_SimpleType_s152 )
}
newtype T_SimpleType_s152 = C_SimpleType_s152 {
inv_SimpleType_s152 :: (T_SimpleType_v151 )
}
data T_SimpleType_s153 = C_SimpleType_s153
type T_SimpleType_v151 = (T_SimpleType_vIn151 ) -> (T_SimpleType_vOut151 )
data T_SimpleType_vIn151 = T_SimpleType_vIn151
data T_SimpleType_vOut151 = T_SimpleType_vOut151 (Name) (SimpleType) (Names)
{-# NOINLINE sem_SimpleType_SimpleType #-}
sem_SimpleType_SimpleType :: T_Range -> T_Name -> T_Names -> T_SimpleType
sem_SimpleType_SimpleType arg_range_ arg_name_ arg_typevariables_ = T_SimpleType (return st152) where
{-# NOINLINE st152 #-}
st152 = let
v151 :: T_SimpleType_v151
v151 = \ (T_SimpleType_vIn151 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
_typevariablesX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_typevariables_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
(T_Names_vOut115 _typevariablesIself) = inv_Names_s116 _typevariablesX116 (T_Names_vIn115 )
_lhsOname :: Name
_lhsOname = rule3567 _nameIself
_lhsOtypevariables :: Names
_lhsOtypevariables = rule3568 _typevariablesIself
_self = rule3569 _nameIself _rangeIself _typevariablesIself
_lhsOself :: SimpleType
_lhsOself = rule3570 _self
__result_ = T_SimpleType_vOut151 _lhsOname _lhsOself _lhsOtypevariables
in __result_ )
in C_SimpleType_s152 v151
{-# INLINE rule3567 #-}
rule3567 = \ ((_nameIself) :: Name) ->
_nameIself
{-# INLINE rule3568 #-}
rule3568 = \ ((_typevariablesIself) :: Names) ->
_typevariablesIself
{-# INLINE rule3569 #-}
rule3569 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ((_typevariablesIself) :: Names) ->
SimpleType_SimpleType _rangeIself _nameIself _typevariablesIself
{-# INLINE rule3570 #-}
rule3570 = \ _self ->
_self
-- Statement ---------------------------------------------------
-- wrapper
data Inh_Statement = Inh_Statement { allPatterns_Inh_Statement :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Statement :: (M.Map NameWithRange TpScheme), assumptions_Inh_Statement :: (Assumptions), availablePredicates_Inh_Statement :: (Predicates), betaUnique_Inh_Statement :: (Int), classEnvironment_Inh_Statement :: (ClassEnvironment), collectErrors_Inh_Statement :: (TypeErrors), collectWarnings_Inh_Statement :: (Warnings), constraints_Inh_Statement :: (ConstraintSet), counter_Inh_Statement :: (Int), currentChunk_Inh_Statement :: (Int), dictionaryEnvironment_Inh_Statement :: (DictionaryEnvironment), generatorBeta_Inh_Statement :: (Maybe Tp), importEnvironment_Inh_Statement :: (ImportEnvironment), matchIO_Inh_Statement :: (IO ()), monos_Inh_Statement :: (Monos), namesInScope_Inh_Statement :: (Names), orderedTypeSynonyms_Inh_Statement :: (OrderedTypeSynonyms), parentTree_Inh_Statement :: (InfoTree), patternMatchWarnings_Inh_Statement :: ([Warning]), substitution_Inh_Statement :: (FixpointSubstitution), typeschemeMap_Inh_Statement :: (M.Map Int (Scheme Predicates)), unboundNames_Inh_Statement :: (Names), uniqueChunk_Inh_Statement :: (Int), uniqueSecondRound_Inh_Statement :: (Int) }
data Syn_Statement = Syn_Statement { assumptions_Syn_Statement :: (Assumptions), betaUnique_Syn_Statement :: (Int), collectErrors_Syn_Statement :: (TypeErrors), collectInstances_Syn_Statement :: ([(Name, Instance)]), collectWarnings_Syn_Statement :: (Warnings), constraints_Syn_Statement :: (ConstraintSet), counter_Syn_Statement :: (Int), dictionaryEnvironment_Syn_Statement :: (DictionaryEnvironment), generatorBeta_Syn_Statement :: (Maybe Tp), infoTree_Syn_Statement :: (InfoTree), matchIO_Syn_Statement :: (IO ()), monos_Syn_Statement :: (Monos), namesInScope_Syn_Statement :: (Names), patternMatchWarnings_Syn_Statement :: ([Warning]), self_Syn_Statement :: (Statement), unboundNames_Syn_Statement :: (Names), uniqueChunk_Syn_Statement :: (Int), uniqueSecondRound_Syn_Statement :: (Int) }
{-# INLINABLE wrap_Statement #-}
wrap_Statement :: T_Statement -> Inh_Statement -> (Syn_Statement )
wrap_Statement (T_Statement act) (Inh_Statement _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Statement_vIn154 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound
(T_Statement_vOut154 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_Statement_s155 sem arg)
return (Syn_Statement _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
)
-- cata
{-# NOINLINE sem_Statement #-}
sem_Statement :: Statement -> T_Statement
sem_Statement ( Statement_Expression range_ expression_ ) = sem_Statement_Expression ( sem_Range range_ ) ( sem_Expression expression_ )
sem_Statement ( Statement_Let range_ declarations_ ) = sem_Statement_Let ( sem_Range range_ ) ( sem_Declarations declarations_ )
sem_Statement ( Statement_Generator range_ pattern_ expression_ ) = sem_Statement_Generator ( sem_Range range_ ) ( sem_Pattern pattern_ ) ( sem_Expression expression_ )
sem_Statement ( Statement_Empty range_ ) = sem_Statement_Empty ( sem_Range range_ )
-- semantic domain
newtype T_Statement = T_Statement {
attach_T_Statement :: Identity (T_Statement_s155 )
}
newtype T_Statement_s155 = C_Statement_s155 {
inv_Statement_s155 :: (T_Statement_v154 )
}
data T_Statement_s156 = C_Statement_s156
type T_Statement_v154 = (T_Statement_vIn154 ) -> (T_Statement_vOut154 )
data T_Statement_vIn154 = T_Statement_vIn154 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Assumptions) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (ConstraintSet) (Int) (Int) (DictionaryEnvironment) (Maybe Tp) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Names) (Int) (Int)
data T_Statement_vOut154 = T_Statement_vOut154 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (Maybe Tp) (InfoTree) (IO ()) (Monos) (Names) ([Warning]) (Statement) (Names) (Int) (Int)
{-# NOINLINE sem_Statement_Expression #-}
sem_Statement_Expression :: T_Range -> T_Expression -> T_Statement
sem_Statement_Expression arg_range_ arg_expression_ = T_Statement (return st155) where
{-# NOINLINE st155 #-}
st155 = let
v154 :: T_Statement_v154
v154 = \ (T_Statement_vIn154 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_lhsOgeneratorBeta :: Maybe Tp
_lhsOgeneratorBeta = rule3571 _beta
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule3572 _expressionIassumptions _lhsIassumptions
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3573 _locConstraints
_expressionObetaUnique = rule3574 _lhsIbetaUnique
_locConstraints = rule3575 _expressionIconstraints _lhsIconstraints _newcon
_beta = rule3576 _lhsIbetaUnique
_newcon = rule3577 _beta _cinfo _expressionIbeta
_cinfo = rule3578 _parentTree
_localInfo = rule3579 _lhsImonos _self
_parentTree = rule3580 _expressionIinfoTree _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule3581 _parentTree
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3582 _expressionIunboundNames _lhsIunboundNames
_expressionOtryPatterns = rule3583 ()
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3584 _expressionIcollectInstances
_self = rule3585 _expressionIself _rangeIself
_lhsOself :: Statement
_lhsOself = rule3586 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3587 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3588 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3589 _expressionIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule3590 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3591 _expressionIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3592 _expressionImatchIO
_lhsOmonos :: Monos
_lhsOmonos = rule3593 _lhsImonos
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule3594 _lhsInamesInScope
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3595 _expressionIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3596 _expressionIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule3597 _expressionIuniqueSecondRound
_expressionOallPatterns = rule3598 _lhsIallPatterns
_expressionOallTypeSchemes = rule3599 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule3600 _lhsIavailablePredicates
_expressionOclassEnvironment = rule3601 _lhsIclassEnvironment
_expressionOcollectErrors = rule3602 _lhsIcollectErrors
_expressionOcollectWarnings = rule3603 _lhsIcollectWarnings
_expressionOcounter = rule3604 _lhsIcounter
_expressionOcurrentChunk = rule3605 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule3606 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule3607 _lhsIimportEnvironment
_expressionOmatchIO = rule3608 _lhsImatchIO
_expressionOmonos = rule3609 _lhsImonos
_expressionOnamesInScope = rule3610 _lhsInamesInScope
_expressionOorderedTypeSynonyms = rule3611 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule3612 _parentTree
_expressionOpatternMatchWarnings = rule3613 _lhsIpatternMatchWarnings
_expressionOsubstitution = rule3614 _lhsIsubstitution
_expressionOtypeschemeMap = rule3615 _lhsItypeschemeMap
_expressionOuniqueChunk = rule3616 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule3617 _lhsIuniqueSecondRound
__result_ = T_Statement_vOut154 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Statement_s155 v154
{-# INLINE rule3571 #-}
rule3571 = \ _beta ->
Just _beta
{-# INLINE rule3572 #-}
rule3572 = \ ((_expressionIassumptions) :: Assumptions) ((_lhsIassumptions) :: Assumptions) ->
_lhsIassumptions `combine` _expressionIassumptions
{-# INLINE rule3573 #-}
rule3573 = \ _locConstraints ->
_locConstraints
{-# INLINE rule3574 #-}
rule3574 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique + 1
{-# INLINE rule3575 #-}
rule3575 = \ ((_expressionIconstraints) :: ConstraintSet) ((_lhsIconstraints) :: ConstraintSet) _newcon ->
Node [ _newcon .<. _expressionIconstraints
, _lhsIconstraints
]
{-# INLINE rule3576 #-}
rule3576 = \ ((_lhsIbetaUnique) :: Int) ->
TVar _lhsIbetaUnique
{-# INLINE rule3577 #-}
rule3577 = \ _beta _cinfo ((_expressionIbeta) :: Tp) ->
[ (_expressionIbeta .==. ioType _beta) _cinfo ]
{-# INLINE rule3578 #-}
rule3578 = \ _parentTree ->
orphanConstraint 0 "generator" _parentTree
[]
{-# INLINE rule3579 #-}
rule3579 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Stat _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule3580 #-}
rule3580 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo [_expressionIinfoTree]
{-# INLINE rule3581 #-}
rule3581 = \ _parentTree ->
_parentTree
{-# INLINE rule3582 #-}
rule3582 = \ ((_expressionIunboundNames) :: Names) ((_lhsIunboundNames) :: Names) ->
_expressionIunboundNames ++ _lhsIunboundNames
{-# INLINE rule3583 #-}
rule3583 = \ (_ :: ()) ->
[]
{-# INLINE rule3584 #-}
rule3584 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances
{-# INLINE rule3585 #-}
rule3585 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
Statement_Expression _rangeIself _expressionIself
{-# INLINE rule3586 #-}
rule3586 = \ _self ->
_self
{-# INLINE rule3587 #-}
rule3587 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule3588 #-}
rule3588 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule3589 #-}
rule3589 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule3590 #-}
rule3590 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule3591 #-}
rule3591 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule3592 #-}
rule3592 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule3593 #-}
rule3593 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3594 #-}
rule3594 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3595 #-}
rule3595 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
_expressionIpatternMatchWarnings
{-# INLINE rule3596 #-}
rule3596 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule3597 #-}
rule3597 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule3598 #-}
rule3598 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3599 #-}
rule3599 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule3600 #-}
rule3600 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3601 #-}
rule3601 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3602 #-}
rule3602 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3603 #-}
rule3603 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3604 #-}
rule3604 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3605 #-}
rule3605 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3606 #-}
rule3606 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3607 #-}
rule3607 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3608 #-}
rule3608 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3609 #-}
rule3609 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3610 #-}
rule3610 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3611 #-}
rule3611 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3612 #-}
rule3612 = \ _parentTree ->
_parentTree
{-# INLINE rule3613 #-}
rule3613 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3614 #-}
rule3614 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3615 #-}
rule3615 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3616 #-}
rule3616 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3617 #-}
rule3617 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Statement_Let #-}
sem_Statement_Let :: T_Range -> T_Declarations -> T_Statement
sem_Statement_Let arg_range_ arg_declarations_ = T_Statement (return st155) where
{-# NOINLINE st155 #-}
st155 = let
v154 :: T_Statement_v154
v154 = \ (T_Statement_vIn154 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_declarationsX32 = Control.Monad.Identity.runIdentity (attach_T_Declarations (arg_declarations_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Declarations_vOut31 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsIcollectErrors _declarationsIcollectInstances _declarationsIcollectWarnings _declarationsIcounter _declarationsIdeclVarNames _declarationsIdictionaryEnvironment _declarationsIinfoTrees _declarationsImatchIO _declarationsIpatternMatchWarnings _declarationsIrestrictedNames _declarationsIself _declarationsIsimplePatNames _declarationsItypeSignatures _declarationsIunboundNames _declarationsIuniqueChunk) = inv_Declarations_s32 _declarationsX32 (T_Declarations_vIn31 _declarationsOallPatterns _declarationsOallTypeSchemes _declarationsOavailablePredicates _declarationsObetaUnique _declarationsObindingGroups _declarationsOclassEnvironment _declarationsOcollectErrors _declarationsOcollectWarnings _declarationsOcounter _declarationsOcurrentChunk _declarationsOdictionaryEnvironment _declarationsOimportEnvironment _declarationsOinheritedBDG _declarationsOmatchIO _declarationsOmonos _declarationsOnamesInScope _declarationsOorderedTypeSynonyms _declarationsOparentTree _declarationsOpatternMatchWarnings _declarationsOsubstitution _declarationsOtypeSignatures _declarationsOtypeschemeMap _declarationsOuniqueChunk)
_lhsOgeneratorBeta :: Maybe Tp
_lhsOgeneratorBeta = rule3618 ()
_declarationsObindingGroups = rule3619 ()
_lhsOassumptions :: Assumptions
_lhsOconstraints :: ConstraintSet
_lhsObetaUnique :: Int
(_lhsOassumptions,_lhsOconstraints,_inheritedBDG,_chunkNr,_lhsObetaUnique,_implicitsFM) = rule3620 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsItypeSignatures _declarationsIuniqueChunk _lhsIassumptions _lhsIconstraints _lhsIcurrentChunk _lhsImonos
_inferredTypes = rule3621 _implicitsFM _lhsItypeschemeMap
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3622 _declarationsIcollectWarnings _declarationsIsimplePatNames _inferredTypes
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3623 _declarationsIcollectErrors _declarationsIrestrictedNames _inferredTypes
_allTypeSchemes = rule3624 _lhsIallTypeSchemes _localTypes
_localTypes = rule3625 _declarationsIbindingGroups _declarationsItypeSignatures _inferredTypes
_declarationsOtypeSignatures = rule3626 ()
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3627 _chunkNr
_localInfo = rule3628 _lhsImonos _self
_declInfo = rule3629 _declarationsIself _lhsImonos
_thisTree = rule3630 _declTree _lhsIparentTree _localInfo
_declTree = rule3631 _declInfo _declarationsIinfoTrees _thisTree
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule3632 _thisTree
_declarationsOparentTree = rule3633 _declTree
(_collectTypeConstructors,_collectValueConstructors,_collectTypeSynonyms,_collectConstructorEnv,_derivedFunctions,_operatorFixities) = rule3634 ()
(_namesInScope,_unboundNames,_scopeInfo) = rule3635 _declarationsIdeclVarNames _declarationsIunboundNames _lhsInamesInScope _lhsIunboundNames
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3636 _unboundNames
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3637 _declarationsIcollectInstances
_self = rule3638 _declarationsIself _rangeIself
_lhsOself :: Statement
_lhsOself = rule3639 _self
_lhsOcounter :: Int
_lhsOcounter = rule3640 _declarationsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3641 _declarationsIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3642 _declarationsImatchIO
_lhsOmonos :: Monos
_lhsOmonos = rule3643 _lhsImonos
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule3644 _namesInScope
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3645 _declarationsIpatternMatchWarnings
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule3646 _lhsIuniqueSecondRound
_declarationsOallPatterns = rule3647 _lhsIallPatterns
_declarationsOallTypeSchemes = rule3648 _allTypeSchemes
_declarationsOavailablePredicates = rule3649 _lhsIavailablePredicates
_declarationsObetaUnique = rule3650 _lhsIbetaUnique
_declarationsOclassEnvironment = rule3651 _lhsIclassEnvironment
_declarationsOcollectErrors = rule3652 _lhsIcollectErrors
_declarationsOcollectWarnings = rule3653 _lhsIcollectWarnings
_declarationsOcounter = rule3654 _lhsIcounter
_declarationsOcurrentChunk = rule3655 _lhsIcurrentChunk
_declarationsOdictionaryEnvironment = rule3656 _lhsIdictionaryEnvironment
_declarationsOimportEnvironment = rule3657 _lhsIimportEnvironment
_declarationsOinheritedBDG = rule3658 _inheritedBDG
_declarationsOmatchIO = rule3659 _lhsImatchIO
_declarationsOmonos = rule3660 _lhsImonos
_declarationsOnamesInScope = rule3661 _namesInScope
_declarationsOorderedTypeSynonyms = rule3662 _lhsIorderedTypeSynonyms
_declarationsOpatternMatchWarnings = rule3663 _lhsIpatternMatchWarnings
_declarationsOsubstitution = rule3664 _lhsIsubstitution
_declarationsOtypeschemeMap = rule3665 _lhsItypeschemeMap
_declarationsOuniqueChunk = rule3666 _lhsIuniqueChunk
__result_ = T_Statement_vOut154 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Statement_s155 v154
{-# INLINE rule3618 #-}
rule3618 = \ (_ :: ()) ->
Nothing
{-# INLINE rule3619 #-}
rule3619 = \ (_ :: ()) ->
[]
{-# INLINE rule3620 #-}
rule3620 = \ ((_declarationsIbetaUnique) :: Int) ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) ((_declarationsIuniqueChunk) :: Int) ((_lhsIassumptions) :: Assumptions) ((_lhsIconstraints) :: ConstraintSet) ((_lhsIcurrentChunk) :: Int) ((_lhsImonos) :: Monos) ->
let inputBDG = (False, _lhsIcurrentChunk, _declarationsIuniqueChunk, _lhsImonos, _declarationsItypeSignatures, mybdggroup, _declarationsIbetaUnique)
mybdggroup = Just (_lhsIassumptions, [_lhsIconstraints])
in performBindingGroup inputBDG _declarationsIbindingGroups
{-# INLINE rule3621 #-}
rule3621 = \ _implicitsFM ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
findInferredTypes _lhsItypeschemeMap _implicitsFM
{-# INLINE rule3622 #-}
rule3622 = \ ((_declarationsIcollectWarnings) :: Warnings) ((_declarationsIsimplePatNames) :: Names) _inferredTypes ->
missingTypeSignature False _declarationsIsimplePatNames _inferredTypes
++ _declarationsIcollectWarnings
{-# INLINE rule3623 #-}
rule3623 = \ ((_declarationsIcollectErrors) :: TypeErrors) ((_declarationsIrestrictedNames) :: Names) _inferredTypes ->
restrictedNameErrors _inferredTypes _declarationsIrestrictedNames
++ _declarationsIcollectErrors
{-# INLINE rule3624 #-}
rule3624 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) _localTypes ->
_localTypes `M.union` _lhsIallTypeSchemes
{-# INLINE rule3625 #-}
rule3625 = \ ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) _inferredTypes ->
makeLocalTypeEnv (_declarationsItypeSignatures `M.union` _inferredTypes) _declarationsIbindingGroups
{-# INLINE rule3626 #-}
rule3626 = \ (_ :: ()) ->
M.empty
{-# INLINE rule3627 #-}
rule3627 = \ _chunkNr ->
_chunkNr
{-# INLINE rule3628 #-}
rule3628 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Stat _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule3629 #-}
rule3629 = \ ((_declarationsIself) :: Declarations) ((_lhsImonos) :: Monos) ->
LocalInfo { self = UHA_Decls _declarationsIself
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule3630 #-}
rule3630 = \ _declTree ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo [_declTree]
{-# INLINE rule3631 #-}
rule3631 = \ _declInfo ((_declarationsIinfoTrees) :: InfoTrees) _thisTree ->
node _thisTree _declInfo _declarationsIinfoTrees
{-# INLINE rule3632 #-}
rule3632 = \ _thisTree ->
_thisTree
{-# INLINE rule3633 #-}
rule3633 = \ _declTree ->
_declTree
{-# INLINE rule3634 #-}
rule3634 = \ (_ :: ()) ->
internalError "PartialSyntax.ag" "n/a" "toplevel Statement"
{-# INLINE rule3635 #-}
rule3635 = \ ((_declarationsIdeclVarNames) :: Names) ((_declarationsIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ((_lhsIunboundNames) :: Names) ->
changeOfScope _declarationsIdeclVarNames (_declarationsIunboundNames ++ _lhsIunboundNames) _lhsInamesInScope
{-# INLINE rule3636 #-}
rule3636 = \ _unboundNames ->
_unboundNames
{-# INLINE rule3637 #-}
rule3637 = \ ((_declarationsIcollectInstances) :: [(Name, Instance)]) ->
_declarationsIcollectInstances
{-# INLINE rule3638 #-}
rule3638 = \ ((_declarationsIself) :: Declarations) ((_rangeIself) :: Range) ->
Statement_Let _rangeIself _declarationsIself
{-# INLINE rule3639 #-}
rule3639 = \ _self ->
_self
{-# INLINE rule3640 #-}
rule3640 = \ ((_declarationsIcounter) :: Int) ->
_declarationsIcounter
{-# INLINE rule3641 #-}
rule3641 = \ ((_declarationsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_declarationsIdictionaryEnvironment
{-# INLINE rule3642 #-}
rule3642 = \ ((_declarationsImatchIO) :: IO ()) ->
_declarationsImatchIO
{-# INLINE rule3643 #-}
rule3643 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3644 #-}
rule3644 = \ _namesInScope ->
_namesInScope
{-# INLINE rule3645 #-}
rule3645 = \ ((_declarationsIpatternMatchWarnings) :: [Warning]) ->
_declarationsIpatternMatchWarnings
{-# INLINE rule3646 #-}
rule3646 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule3647 #-}
rule3647 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3648 #-}
rule3648 = \ _allTypeSchemes ->
_allTypeSchemes
{-# INLINE rule3649 #-}
rule3649 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3650 #-}
rule3650 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3651 #-}
rule3651 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3652 #-}
rule3652 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3653 #-}
rule3653 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3654 #-}
rule3654 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3655 #-}
rule3655 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3656 #-}
rule3656 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3657 #-}
rule3657 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3658 #-}
rule3658 = \ _inheritedBDG ->
_inheritedBDG
{-# INLINE rule3659 #-}
rule3659 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3660 #-}
rule3660 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3661 #-}
rule3661 = \ _namesInScope ->
_namesInScope
{-# INLINE rule3662 #-}
rule3662 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3663 #-}
rule3663 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3664 #-}
rule3664 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3665 #-}
rule3665 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3666 #-}
rule3666 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# NOINLINE sem_Statement_Generator #-}
sem_Statement_Generator :: T_Range -> T_Pattern -> T_Expression -> T_Statement
sem_Statement_Generator arg_range_ arg_pattern_ arg_expression_ = T_Statement (return st155) where
{-# NOINLINE st155 #-}
st155 = let
v154 :: T_Statement_v154
v154 = \ (T_Statement_vIn154 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
_expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
(T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
_lhsOgeneratorBeta :: Maybe Tp
_lhsOgeneratorBeta = rule3667 ()
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3668 _locConstraints
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule3669 _assumptions' _expressionIassumptions
_lhsOmonos :: Monos
_lhsOmonos = rule3670 _csetBinds _lhsImonos _patternIenvironment
_locConstraints = rule3671 _csetBinds _expressionIconstraints _lhsIconstraints _newcon _patternIconstraints
_newcon = rule3672 _cinfoResult _expressionIbeta _patternIbeta
(_csetBinds,_assumptions') = rule3673 _cinfoBind _lhsIassumptions _patternIenvironment
_cinfoResult = rule3674 _parentTree
_cinfoBind = rule3675 _parentTree _patternIenvironment
_localInfo = rule3676 _lhsImonos _self
_parentTree = rule3677 _expressionIinfoTree _lhsIparentTree _localInfo _patternIinfoTree
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule3678 _parentTree
(_namesInScope,_unboundNames,_scopeInfo) = rule3679 _expressionIunboundNames _lhsInamesInScope _lhsIunboundNames _patternIpatVarNames
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule3680 _namesInScope
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3681 _unboundNames
_expressionOnamesInScope = rule3682 _lhsInamesInScope
_expressionOtryPatterns = rule3683 ()
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3684 _expressionIpatternMatchWarnings _lhsIimportEnvironment _lhsIsubstitution _patternIbeta _patternIelements _rangeIself
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3685 _expressionIcollectInstances
_self = rule3686 _expressionIself _patternIself _rangeIself
_lhsOself :: Statement
_lhsOself = rule3687 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3688 _expressionIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3689 _expressionIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3690 _expressionIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule3691 _expressionIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3692 _expressionIdictionaryEnvironment
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3693 _expressionImatchIO
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3694 _expressionIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule3695 _expressionIuniqueSecondRound
_patternObetaUnique = rule3696 _lhsIbetaUnique
_patternOcounter = rule3697 _lhsIcounter
_patternOimportEnvironment = rule3698 _lhsIimportEnvironment
_patternOmonos = rule3699 _lhsImonos
_patternOnamesInScope = rule3700 _namesInScope
_patternOparentTree = rule3701 _parentTree
_patternOpatternMatchWarnings = rule3702 _lhsIpatternMatchWarnings
_expressionOallPatterns = rule3703 _lhsIallPatterns
_expressionOallTypeSchemes = rule3704 _lhsIallTypeSchemes
_expressionOavailablePredicates = rule3705 _lhsIavailablePredicates
_expressionObetaUnique = rule3706 _patternIbetaUnique
_expressionOclassEnvironment = rule3707 _lhsIclassEnvironment
_expressionOcollectErrors = rule3708 _lhsIcollectErrors
_expressionOcollectWarnings = rule3709 _lhsIcollectWarnings
_expressionOcounter = rule3710 _patternIcounter
_expressionOcurrentChunk = rule3711 _lhsIcurrentChunk
_expressionOdictionaryEnvironment = rule3712 _lhsIdictionaryEnvironment
_expressionOimportEnvironment = rule3713 _lhsIimportEnvironment
_expressionOmatchIO = rule3714 _lhsImatchIO
_expressionOmonos = rule3715 _lhsImonos
_expressionOorderedTypeSynonyms = rule3716 _lhsIorderedTypeSynonyms
_expressionOparentTree = rule3717 _parentTree
_expressionOpatternMatchWarnings = rule3718 _patternIpatternMatchWarnings
_expressionOsubstitution = rule3719 _lhsIsubstitution
_expressionOtypeschemeMap = rule3720 _lhsItypeschemeMap
_expressionOuniqueChunk = rule3721 _lhsIuniqueChunk
_expressionOuniqueSecondRound = rule3722 _lhsIuniqueSecondRound
__result_ = T_Statement_vOut154 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Statement_s155 v154
{-# INLINE rule3667 #-}
rule3667 = \ (_ :: ()) ->
Nothing
{-# INLINE rule3668 #-}
rule3668 = \ _locConstraints ->
_locConstraints
{-# INLINE rule3669 #-}
rule3669 = \ _assumptions' ((_expressionIassumptions) :: Assumptions) ->
_assumptions' `combine` _expressionIassumptions
{-# INLINE rule3670 #-}
rule3670 = \ _csetBinds ((_lhsImonos) :: Monos) ((_patternIenvironment) :: PatternAssumptions) ->
M.elems _patternIenvironment ++ getMonos _csetBinds ++ _lhsImonos
{-# INLINE rule3671 #-}
rule3671 = \ _csetBinds ((_expressionIconstraints) :: ConstraintSet) ((_lhsIconstraints) :: ConstraintSet) _newcon ((_patternIconstraints) :: ConstraintSet) ->
_newcon .>. _csetBinds .>>.
Node [ _patternIconstraints
, _expressionIconstraints
, _lhsIconstraints
]
{-# INLINE rule3672 #-}
rule3672 = \ _cinfoResult ((_expressionIbeta) :: Tp) ((_patternIbeta) :: Tp) ->
[ (_expressionIbeta .==. ioType _patternIbeta) _cinfoResult ]
{-# INLINE rule3673 #-}
rule3673 = \ _cinfoBind ((_lhsIassumptions) :: Assumptions) ((_patternIenvironment) :: PatternAssumptions) ->
(_patternIenvironment .===. _lhsIassumptions) _cinfoBind
{-# INLINE rule3674 #-}
rule3674 = \ _parentTree ->
childConstraint 1 "generator" _parentTree
[]
{-# INLINE rule3675 #-}
rule3675 = \ _parentTree ((_patternIenvironment) :: PatternAssumptions) ->
\name -> variableConstraint "variable" (nameToUHA_Expr name)
[ FolkloreConstraint
, makeUnifier name "generator" _patternIenvironment _parentTree
]
{-# INLINE rule3676 #-}
rule3676 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Stat _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule3677 #-}
rule3677 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternIinfoTree) :: InfoTree) ->
node _lhsIparentTree _localInfo [_patternIinfoTree, _expressionIinfoTree]
{-# INLINE rule3678 #-}
rule3678 = \ _parentTree ->
_parentTree
{-# INLINE rule3679 #-}
rule3679 = \ ((_expressionIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ((_lhsIunboundNames) :: Names) ((_patternIpatVarNames) :: Names) ->
changeOfScope _patternIpatVarNames (_expressionIunboundNames ++ _lhsIunboundNames) _lhsInamesInScope
{-# INLINE rule3680 #-}
rule3680 = \ _namesInScope ->
_namesInScope
{-# INLINE rule3681 #-}
rule3681 = \ _unboundNames ->
_unboundNames
{-# INLINE rule3682 #-}
rule3682 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3683 #-}
rule3683 = \ (_ :: ()) ->
[]
{-# INLINE rule3684 #-}
rule3684 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_patternIbeta) :: Tp) ((_patternIelements) :: [PatternElement] ) ((_rangeIself) :: Range) ->
patternMatchWarnings _lhsIimportEnvironment
_lhsIsubstitution
_patternIbeta
(:[])
[(_patternIelements, False)]
_rangeIself
Nothing
False
[]
"generator"
"<-"
++ _expressionIpatternMatchWarnings
{-# INLINE rule3685 #-}
rule3685 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
_expressionIcollectInstances
{-# INLINE rule3686 #-}
rule3686 = \ ((_expressionIself) :: Expression) ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
Statement_Generator _rangeIself _patternIself _expressionIself
{-# INLINE rule3687 #-}
rule3687 = \ _self ->
_self
{-# INLINE rule3688 #-}
rule3688 = \ ((_expressionIbetaUnique) :: Int) ->
_expressionIbetaUnique
{-# INLINE rule3689 #-}
rule3689 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
_expressionIcollectErrors
{-# INLINE rule3690 #-}
rule3690 = \ ((_expressionIcollectWarnings) :: Warnings) ->
_expressionIcollectWarnings
{-# INLINE rule3691 #-}
rule3691 = \ ((_expressionIcounter) :: Int) ->
_expressionIcounter
{-# INLINE rule3692 #-}
rule3692 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
_expressionIdictionaryEnvironment
{-# INLINE rule3693 #-}
rule3693 = \ ((_expressionImatchIO) :: IO ()) ->
_expressionImatchIO
{-# INLINE rule3694 #-}
rule3694 = \ ((_expressionIuniqueChunk) :: Int) ->
_expressionIuniqueChunk
{-# INLINE rule3695 #-}
rule3695 = \ ((_expressionIuniqueSecondRound) :: Int) ->
_expressionIuniqueSecondRound
{-# INLINE rule3696 #-}
rule3696 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3697 #-}
rule3697 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3698 #-}
rule3698 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3699 #-}
rule3699 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3700 #-}
rule3700 = \ _namesInScope ->
_namesInScope
{-# INLINE rule3701 #-}
rule3701 = \ _parentTree ->
_parentTree
{-# INLINE rule3702 #-}
rule3702 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3703 #-}
rule3703 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3704 #-}
rule3704 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule3705 #-}
rule3705 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3706 #-}
rule3706 = \ ((_patternIbetaUnique) :: Int) ->
_patternIbetaUnique
{-# INLINE rule3707 #-}
rule3707 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3708 #-}
rule3708 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3709 #-}
rule3709 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3710 #-}
rule3710 = \ ((_patternIcounter) :: Int) ->
_patternIcounter
{-# INLINE rule3711 #-}
rule3711 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3712 #-}
rule3712 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3713 #-}
rule3713 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3714 #-}
rule3714 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3715 #-}
rule3715 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3716 #-}
rule3716 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3717 #-}
rule3717 = \ _parentTree ->
_parentTree
{-# INLINE rule3718 #-}
rule3718 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
_patternIpatternMatchWarnings
{-# INLINE rule3719 #-}
rule3719 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3720 #-}
rule3720 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3721 #-}
rule3721 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3722 #-}
rule3722 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# NOINLINE sem_Statement_Empty #-}
sem_Statement_Empty :: T_Range -> T_Statement
sem_Statement_Empty arg_range_ = T_Statement (return st155) where
{-# NOINLINE st155 #-}
st155 = let
v154 :: T_Statement_v154
v154 = \ (T_Statement_vIn154 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
_localInfo = rule3723 _lhsImonos _self
_parentTree = rule3724 _lhsIparentTree _localInfo
_lhsOinfoTree :: InfoTree
_lhsOinfoTree = rule3725 _parentTree
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3726 ()
_self = rule3727 _rangeIself
_lhsOself :: Statement
_lhsOself = rule3728 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule3729 _lhsIassumptions
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3730 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3731 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3732 _lhsIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3733 _lhsIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule3734 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3735 _lhsIdictionaryEnvironment
_lhsOgeneratorBeta :: Maybe Tp
_lhsOgeneratorBeta = rule3736 _lhsIgeneratorBeta
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3737 _lhsImatchIO
_lhsOmonos :: Monos
_lhsOmonos = rule3738 _lhsImonos
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule3739 _lhsInamesInScope
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3740 _lhsIpatternMatchWarnings
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3741 _lhsIunboundNames
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3742 _lhsIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule3743 _lhsIuniqueSecondRound
__result_ = T_Statement_vOut154 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Statement_s155 v154
{-# INLINE rule3723 #-}
rule3723 = \ ((_lhsImonos) :: Monos) _self ->
LocalInfo { self = UHA_Stat _self
, assignedType = Nothing
, monos = _lhsImonos
}
{-# INLINE rule3724 #-}
rule3724 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
node _lhsIparentTree _localInfo []
{-# INLINE rule3725 #-}
rule3725 = \ _parentTree ->
_parentTree
{-# INLINE rule3726 #-}
rule3726 = \ (_ :: ()) ->
[]
{-# INLINE rule3727 #-}
rule3727 = \ ((_rangeIself) :: Range) ->
Statement_Empty _rangeIself
{-# INLINE rule3728 #-}
rule3728 = \ _self ->
_self
{-# INLINE rule3729 #-}
rule3729 = \ ((_lhsIassumptions) :: Assumptions) ->
_lhsIassumptions
{-# INLINE rule3730 #-}
rule3730 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3731 #-}
rule3731 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3732 #-}
rule3732 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3733 #-}
rule3733 = \ ((_lhsIconstraints) :: ConstraintSet) ->
_lhsIconstraints
{-# INLINE rule3734 #-}
rule3734 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3735 #-}
rule3735 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3736 #-}
rule3736 = \ ((_lhsIgeneratorBeta) :: Maybe Tp) ->
_lhsIgeneratorBeta
{-# INLINE rule3737 #-}
rule3737 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3738 #-}
rule3738 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3739 #-}
rule3739 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3740 #-}
rule3740 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3741 #-}
rule3741 = \ ((_lhsIunboundNames) :: Names) ->
_lhsIunboundNames
{-# INLINE rule3742 #-}
rule3742 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3743 #-}
rule3743 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
-- Statements --------------------------------------------------
-- wrapper
data Inh_Statements = Inh_Statements { allPatterns_Inh_Statements :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Statements :: (M.Map NameWithRange TpScheme), assumptions_Inh_Statements :: (Assumptions), availablePredicates_Inh_Statements :: (Predicates), betaUnique_Inh_Statements :: (Int), classEnvironment_Inh_Statements :: (ClassEnvironment), collectErrors_Inh_Statements :: (TypeErrors), collectWarnings_Inh_Statements :: (Warnings), constraints_Inh_Statements :: (ConstraintSet), counter_Inh_Statements :: (Int), currentChunk_Inh_Statements :: (Int), dictionaryEnvironment_Inh_Statements :: (DictionaryEnvironment), generatorBeta_Inh_Statements :: (Maybe Tp), importEnvironment_Inh_Statements :: (ImportEnvironment), matchIO_Inh_Statements :: (IO ()), monos_Inh_Statements :: (Monos), namesInScope_Inh_Statements :: (Names), orderedTypeSynonyms_Inh_Statements :: (OrderedTypeSynonyms), parentTree_Inh_Statements :: (InfoTree), patternMatchWarnings_Inh_Statements :: ([Warning]), substitution_Inh_Statements :: (FixpointSubstitution), typeschemeMap_Inh_Statements :: (M.Map Int (Scheme Predicates)), unboundNames_Inh_Statements :: (Names), uniqueChunk_Inh_Statements :: (Int), uniqueSecondRound_Inh_Statements :: (Int) }
data Syn_Statements = Syn_Statements { assumptions_Syn_Statements :: (Assumptions), betaUnique_Syn_Statements :: (Int), collectErrors_Syn_Statements :: (TypeErrors), collectInstances_Syn_Statements :: ([(Name, Instance)]), collectWarnings_Syn_Statements :: (Warnings), constraints_Syn_Statements :: (ConstraintSet), counter_Syn_Statements :: (Int), dictionaryEnvironment_Syn_Statements :: (DictionaryEnvironment), generatorBeta_Syn_Statements :: (Maybe Tp), infoTrees_Syn_Statements :: (InfoTrees), matchIO_Syn_Statements :: (IO ()), namesInScope_Syn_Statements :: (Names), patternMatchWarnings_Syn_Statements :: ([Warning]), self_Syn_Statements :: (Statements), unboundNames_Syn_Statements :: (Names), uniqueChunk_Syn_Statements :: (Int), uniqueSecondRound_Syn_Statements :: (Int) }
{-# INLINABLE wrap_Statements #-}
wrap_Statements :: T_Statements -> Inh_Statements -> (Syn_Statements )
wrap_Statements (T_Statements act) (Inh_Statements _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Statements_vIn157 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound
(T_Statements_vOut157 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTrees _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_Statements_s158 sem arg)
return (Syn_Statements _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTrees _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
)
-- cata
{-# NOINLINE sem_Statements #-}
sem_Statements :: Statements -> T_Statements
sem_Statements list = Prelude.foldr sem_Statements_Cons sem_Statements_Nil (Prelude.map sem_Statement list)
-- semantic domain
newtype T_Statements = T_Statements {
attach_T_Statements :: Identity (T_Statements_s158 )
}
newtype T_Statements_s158 = C_Statements_s158 {
inv_Statements_s158 :: (T_Statements_v157 )
}
data T_Statements_s159 = C_Statements_s159
type T_Statements_v157 = (T_Statements_vIn157 ) -> (T_Statements_vOut157 )
data T_Statements_vIn157 = T_Statements_vIn157 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Assumptions) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (ConstraintSet) (Int) (Int) (DictionaryEnvironment) (Maybe Tp) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Names) (Int) (Int)
data T_Statements_vOut157 = T_Statements_vOut157 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (Maybe Tp) (InfoTrees) (IO ()) (Names) ([Warning]) (Statements) (Names) (Int) (Int)
{-# NOINLINE sem_Statements_Cons #-}
sem_Statements_Cons :: T_Statement -> T_Statements -> T_Statements
sem_Statements_Cons arg_hd_ arg_tl_ = T_Statements (return st158) where
{-# NOINLINE st158 #-}
st158 = let
v157 :: T_Statements_v157
v157 = \ (T_Statements_vIn157 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_hdX155 = Control.Monad.Identity.runIdentity (attach_T_Statement (arg_hd_))
_tlX158 = Control.Monad.Identity.runIdentity (attach_T_Statements (arg_tl_))
(T_Statement_vOut154 _hdIassumptions _hdIbetaUnique _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIconstraints _hdIcounter _hdIdictionaryEnvironment _hdIgeneratorBeta _hdIinfoTree _hdImatchIO _hdImonos _hdInamesInScope _hdIpatternMatchWarnings _hdIself _hdIunboundNames _hdIuniqueChunk _hdIuniqueSecondRound) = inv_Statement_s155 _hdX155 (T_Statement_vIn154 _hdOallPatterns _hdOallTypeSchemes _hdOassumptions _hdOavailablePredicates _hdObetaUnique _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOconstraints _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOgeneratorBeta _hdOimportEnvironment _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeschemeMap _hdOunboundNames _hdOuniqueChunk _hdOuniqueSecondRound)
(T_Statements_vOut157 _tlIassumptions _tlIbetaUnique _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIconstraints _tlIcounter _tlIdictionaryEnvironment _tlIgeneratorBeta _tlIinfoTrees _tlImatchIO _tlInamesInScope _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk _tlIuniqueSecondRound) = inv_Statements_s158 _tlX158 (T_Statements_vIn157 _tlOallPatterns _tlOallTypeSchemes _tlOassumptions _tlOavailablePredicates _tlObetaUnique _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOconstraints _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOgeneratorBeta _tlOimportEnvironment _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeschemeMap _tlOunboundNames _tlOuniqueChunk _tlOuniqueSecondRound)
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule3744 _hdIassumptions
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3745 _hdIconstraints
_hdOassumptions = rule3746 _tlIassumptions
_hdOconstraints = rule3747 _tlIconstraints
_tlOassumptions = rule3748 _lhsIassumptions
_tlOconstraints = rule3749 _lhsIconstraints
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule3750 _hdIinfoTree _tlIinfoTrees
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3751 _hdIunboundNames
_tlOunboundNames = rule3752 _lhsIunboundNames
_hdOunboundNames = rule3753 _tlIunboundNames
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3754 _hdIcollectInstances _tlIcollectInstances
_self = rule3755 _hdIself _tlIself
_lhsOself :: Statements
_lhsOself = rule3756 _self
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3757 _tlIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3758 _tlIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3759 _tlIcollectWarnings
_lhsOcounter :: Int
_lhsOcounter = rule3760 _tlIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3761 _tlIdictionaryEnvironment
_lhsOgeneratorBeta :: Maybe Tp
_lhsOgeneratorBeta = rule3762 _tlIgeneratorBeta
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3763 _tlImatchIO
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule3764 _tlInamesInScope
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3765 _tlIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3766 _tlIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule3767 _tlIuniqueSecondRound
_hdOallPatterns = rule3768 _lhsIallPatterns
_hdOallTypeSchemes = rule3769 _lhsIallTypeSchemes
_hdOavailablePredicates = rule3770 _lhsIavailablePredicates
_hdObetaUnique = rule3771 _lhsIbetaUnique
_hdOclassEnvironment = rule3772 _lhsIclassEnvironment
_hdOcollectErrors = rule3773 _lhsIcollectErrors
_hdOcollectWarnings = rule3774 _lhsIcollectWarnings
_hdOcounter = rule3775 _lhsIcounter
_hdOcurrentChunk = rule3776 _lhsIcurrentChunk
_hdOdictionaryEnvironment = rule3777 _lhsIdictionaryEnvironment
_hdOgeneratorBeta = rule3778 _lhsIgeneratorBeta
_hdOimportEnvironment = rule3779 _lhsIimportEnvironment
_hdOmatchIO = rule3780 _lhsImatchIO
_hdOmonos = rule3781 _lhsImonos
_hdOnamesInScope = rule3782 _lhsInamesInScope
_hdOorderedTypeSynonyms = rule3783 _lhsIorderedTypeSynonyms
_hdOparentTree = rule3784 _lhsIparentTree
_hdOpatternMatchWarnings = rule3785 _lhsIpatternMatchWarnings
_hdOsubstitution = rule3786 _lhsIsubstitution
_hdOtypeschemeMap = rule3787 _lhsItypeschemeMap
_hdOuniqueChunk = rule3788 _lhsIuniqueChunk
_hdOuniqueSecondRound = rule3789 _lhsIuniqueSecondRound
_tlOallPatterns = rule3790 _lhsIallPatterns
_tlOallTypeSchemes = rule3791 _lhsIallTypeSchemes
_tlOavailablePredicates = rule3792 _lhsIavailablePredicates
_tlObetaUnique = rule3793 _hdIbetaUnique
_tlOclassEnvironment = rule3794 _lhsIclassEnvironment
_tlOcollectErrors = rule3795 _hdIcollectErrors
_tlOcollectWarnings = rule3796 _hdIcollectWarnings
_tlOcounter = rule3797 _hdIcounter
_tlOcurrentChunk = rule3798 _lhsIcurrentChunk
_tlOdictionaryEnvironment = rule3799 _hdIdictionaryEnvironment
_tlOgeneratorBeta = rule3800 _hdIgeneratorBeta
_tlOimportEnvironment = rule3801 _lhsIimportEnvironment
_tlOmatchIO = rule3802 _hdImatchIO
_tlOmonos = rule3803 _hdImonos
_tlOnamesInScope = rule3804 _hdInamesInScope
_tlOorderedTypeSynonyms = rule3805 _lhsIorderedTypeSynonyms
_tlOparentTree = rule3806 _lhsIparentTree
_tlOpatternMatchWarnings = rule3807 _hdIpatternMatchWarnings
_tlOsubstitution = rule3808 _lhsIsubstitution
_tlOtypeschemeMap = rule3809 _lhsItypeschemeMap
_tlOuniqueChunk = rule3810 _hdIuniqueChunk
_tlOuniqueSecondRound = rule3811 _hdIuniqueSecondRound
__result_ = T_Statements_vOut157 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTrees _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Statements_s158 v157
{-# INLINE rule3744 #-}
rule3744 = \ ((_hdIassumptions) :: Assumptions) ->
_hdIassumptions
{-# INLINE rule3745 #-}
rule3745 = \ ((_hdIconstraints) :: ConstraintSet) ->
_hdIconstraints
{-# INLINE rule3746 #-}
rule3746 = \ ((_tlIassumptions) :: Assumptions) ->
_tlIassumptions
{-# INLINE rule3747 #-}
rule3747 = \ ((_tlIconstraints) :: ConstraintSet) ->
_tlIconstraints
{-# INLINE rule3748 #-}
rule3748 = \ ((_lhsIassumptions) :: Assumptions) ->
_lhsIassumptions
{-# INLINE rule3749 #-}
rule3749 = \ ((_lhsIconstraints) :: ConstraintSet) ->
_lhsIconstraints
{-# INLINE rule3750 #-}
rule3750 = \ ((_hdIinfoTree) :: InfoTree) ((_tlIinfoTrees) :: InfoTrees) ->
_hdIinfoTree : _tlIinfoTrees
{-# INLINE rule3751 #-}
rule3751 = \ ((_hdIunboundNames) :: Names) ->
_hdIunboundNames
{-# INLINE rule3752 #-}
rule3752 = \ ((_lhsIunboundNames) :: Names) ->
_lhsIunboundNames
{-# INLINE rule3753 #-}
rule3753 = \ ((_tlIunboundNames) :: Names) ->
_tlIunboundNames
{-# INLINE rule3754 #-}
rule3754 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
_hdIcollectInstances ++ _tlIcollectInstances
{-# INLINE rule3755 #-}
rule3755 = \ ((_hdIself) :: Statement) ((_tlIself) :: Statements) ->
(:) _hdIself _tlIself
{-# INLINE rule3756 #-}
rule3756 = \ _self ->
_self
{-# INLINE rule3757 #-}
rule3757 = \ ((_tlIbetaUnique) :: Int) ->
_tlIbetaUnique
{-# INLINE rule3758 #-}
rule3758 = \ ((_tlIcollectErrors) :: TypeErrors) ->
_tlIcollectErrors
{-# INLINE rule3759 #-}
rule3759 = \ ((_tlIcollectWarnings) :: Warnings) ->
_tlIcollectWarnings
{-# INLINE rule3760 #-}
rule3760 = \ ((_tlIcounter) :: Int) ->
_tlIcounter
{-# INLINE rule3761 #-}
rule3761 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
_tlIdictionaryEnvironment
{-# INLINE rule3762 #-}
rule3762 = \ ((_tlIgeneratorBeta) :: Maybe Tp) ->
_tlIgeneratorBeta
{-# INLINE rule3763 #-}
rule3763 = \ ((_tlImatchIO) :: IO ()) ->
_tlImatchIO
{-# INLINE rule3764 #-}
rule3764 = \ ((_tlInamesInScope) :: Names) ->
_tlInamesInScope
{-# INLINE rule3765 #-}
rule3765 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
_tlIpatternMatchWarnings
{-# INLINE rule3766 #-}
rule3766 = \ ((_tlIuniqueChunk) :: Int) ->
_tlIuniqueChunk
{-# INLINE rule3767 #-}
rule3767 = \ ((_tlIuniqueSecondRound) :: Int) ->
_tlIuniqueSecondRound
{-# INLINE rule3768 #-}
rule3768 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3769 #-}
rule3769 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule3770 #-}
rule3770 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3771 #-}
rule3771 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3772 #-}
rule3772 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3773 #-}
rule3773 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3774 #-}
rule3774 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3775 #-}
rule3775 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3776 #-}
rule3776 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3777 #-}
rule3777 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3778 #-}
rule3778 = \ ((_lhsIgeneratorBeta) :: Maybe Tp) ->
_lhsIgeneratorBeta
{-# INLINE rule3779 #-}
rule3779 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3780 #-}
rule3780 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3781 #-}
rule3781 = \ ((_lhsImonos) :: Monos) ->
_lhsImonos
{-# INLINE rule3782 #-}
rule3782 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3783 #-}
rule3783 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3784 #-}
rule3784 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule3785 #-}
rule3785 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3786 #-}
rule3786 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3787 #-}
rule3787 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3788 #-}
rule3788 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3789 #-}
rule3789 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
{-# INLINE rule3790 #-}
rule3790 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
_lhsIallPatterns
{-# INLINE rule3791 #-}
rule3791 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
_lhsIallTypeSchemes
{-# INLINE rule3792 #-}
rule3792 = \ ((_lhsIavailablePredicates) :: Predicates) ->
_lhsIavailablePredicates
{-# INLINE rule3793 #-}
rule3793 = \ ((_hdIbetaUnique) :: Int) ->
_hdIbetaUnique
{-# INLINE rule3794 #-}
rule3794 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
_lhsIclassEnvironment
{-# INLINE rule3795 #-}
rule3795 = \ ((_hdIcollectErrors) :: TypeErrors) ->
_hdIcollectErrors
{-# INLINE rule3796 #-}
rule3796 = \ ((_hdIcollectWarnings) :: Warnings) ->
_hdIcollectWarnings
{-# INLINE rule3797 #-}
rule3797 = \ ((_hdIcounter) :: Int) ->
_hdIcounter
{-# INLINE rule3798 #-}
rule3798 = \ ((_lhsIcurrentChunk) :: Int) ->
_lhsIcurrentChunk
{-# INLINE rule3799 #-}
rule3799 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
_hdIdictionaryEnvironment
{-# INLINE rule3800 #-}
rule3800 = \ ((_hdIgeneratorBeta) :: Maybe Tp) ->
_hdIgeneratorBeta
{-# INLINE rule3801 #-}
rule3801 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
_lhsIimportEnvironment
{-# INLINE rule3802 #-}
rule3802 = \ ((_hdImatchIO) :: IO ()) ->
_hdImatchIO
{-# INLINE rule3803 #-}
rule3803 = \ ((_hdImonos) :: Monos) ->
_hdImonos
{-# INLINE rule3804 #-}
rule3804 = \ ((_hdInamesInScope) :: Names) ->
_hdInamesInScope
{-# INLINE rule3805 #-}
rule3805 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
_lhsIorderedTypeSynonyms
{-# INLINE rule3806 #-}
rule3806 = \ ((_lhsIparentTree) :: InfoTree) ->
_lhsIparentTree
{-# INLINE rule3807 #-}
rule3807 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
_hdIpatternMatchWarnings
{-# INLINE rule3808 #-}
rule3808 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
_lhsIsubstitution
{-# INLINE rule3809 #-}
rule3809 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
_lhsItypeschemeMap
{-# INLINE rule3810 #-}
rule3810 = \ ((_hdIuniqueChunk) :: Int) ->
_hdIuniqueChunk
{-# INLINE rule3811 #-}
rule3811 = \ ((_hdIuniqueSecondRound) :: Int) ->
_hdIuniqueSecondRound
{-# NOINLINE sem_Statements_Nil #-}
sem_Statements_Nil :: T_Statements
sem_Statements_Nil = T_Statements (return st158) where
{-# NOINLINE st158 #-}
st158 = let
v157 :: T_Statements_v157
v157 = \ (T_Statements_vIn157 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
_lhsOinfoTrees :: InfoTrees
_lhsOinfoTrees = rule3812 ()
_lhsOunboundNames :: Names
_lhsOunboundNames = rule3813 _lhsIunboundNames
_lhsOcollectInstances :: [(Name, Instance)]
_lhsOcollectInstances = rule3814 ()
_self = rule3815 ()
_lhsOself :: Statements
_lhsOself = rule3816 _self
_lhsOassumptions :: Assumptions
_lhsOassumptions = rule3817 _lhsIassumptions
_lhsObetaUnique :: Int
_lhsObetaUnique = rule3818 _lhsIbetaUnique
_lhsOcollectErrors :: TypeErrors
_lhsOcollectErrors = rule3819 _lhsIcollectErrors
_lhsOcollectWarnings :: Warnings
_lhsOcollectWarnings = rule3820 _lhsIcollectWarnings
_lhsOconstraints :: ConstraintSet
_lhsOconstraints = rule3821 _lhsIconstraints
_lhsOcounter :: Int
_lhsOcounter = rule3822 _lhsIcounter
_lhsOdictionaryEnvironment :: DictionaryEnvironment
_lhsOdictionaryEnvironment = rule3823 _lhsIdictionaryEnvironment
_lhsOgeneratorBeta :: Maybe Tp
_lhsOgeneratorBeta = rule3824 _lhsIgeneratorBeta
_lhsOmatchIO :: IO ()
_lhsOmatchIO = rule3825 _lhsImatchIO
_lhsOnamesInScope :: Names
_lhsOnamesInScope = rule3826 _lhsInamesInScope
_lhsOpatternMatchWarnings :: [Warning]
_lhsOpatternMatchWarnings = rule3827 _lhsIpatternMatchWarnings
_lhsOuniqueChunk :: Int
_lhsOuniqueChunk = rule3828 _lhsIuniqueChunk
_lhsOuniqueSecondRound :: Int
_lhsOuniqueSecondRound = rule3829 _lhsIuniqueSecondRound
__result_ = T_Statements_vOut157 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTrees _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
in __result_ )
in C_Statements_s158 v157
{-# INLINE rule3812 #-}
rule3812 = \ (_ :: ()) ->
[]
{-# INLINE rule3813 #-}
rule3813 = \ ((_lhsIunboundNames) :: Names) ->
_lhsIunboundNames
{-# INLINE rule3814 #-}
rule3814 = \ (_ :: ()) ->
[]
{-# INLINE rule3815 #-}
rule3815 = \ (_ :: ()) ->
[]
{-# INLINE rule3816 #-}
rule3816 = \ _self ->
_self
{-# INLINE rule3817 #-}
rule3817 = \ ((_lhsIassumptions) :: Assumptions) ->
_lhsIassumptions
{-# INLINE rule3818 #-}
rule3818 = \ ((_lhsIbetaUnique) :: Int) ->
_lhsIbetaUnique
{-# INLINE rule3819 #-}
rule3819 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
_lhsIcollectErrors
{-# INLINE rule3820 #-}
rule3820 = \ ((_lhsIcollectWarnings) :: Warnings) ->
_lhsIcollectWarnings
{-# INLINE rule3821 #-}
rule3821 = \ ((_lhsIconstraints) :: ConstraintSet) ->
_lhsIconstraints
{-# INLINE rule3822 #-}
rule3822 = \ ((_lhsIcounter) :: Int) ->
_lhsIcounter
{-# INLINE rule3823 #-}
rule3823 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
_lhsIdictionaryEnvironment
{-# INLINE rule3824 #-}
rule3824 = \ ((_lhsIgeneratorBeta) :: Maybe Tp) ->
_lhsIgeneratorBeta
{-# INLINE rule3825 #-}
rule3825 = \ ((_lhsImatchIO) :: IO ()) ->
_lhsImatchIO
{-# INLINE rule3826 #-}
rule3826 = \ ((_lhsInamesInScope) :: Names) ->
_lhsInamesInScope
{-# INLINE rule3827 #-}
rule3827 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
_lhsIpatternMatchWarnings
{-# INLINE rule3828 #-}
rule3828 = \ ((_lhsIuniqueChunk) :: Int) ->
_lhsIuniqueChunk
{-# INLINE rule3829 #-}
rule3829 = \ ((_lhsIuniqueSecondRound) :: Int) ->
_lhsIuniqueSecondRound
-- Strings -----------------------------------------------------
-- wrapper
data Inh_Strings = Inh_Strings { }
data Syn_Strings = Syn_Strings { self_Syn_Strings :: (Strings) }
{-# INLINABLE wrap_Strings #-}
wrap_Strings :: T_Strings -> Inh_Strings -> (Syn_Strings )
wrap_Strings (T_Strings act) (Inh_Strings ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Strings_vIn160
(T_Strings_vOut160 _lhsOself) <- return (inv_Strings_s161 sem arg)
return (Syn_Strings _lhsOself)
)
-- cata
{-# NOINLINE sem_Strings #-}
sem_Strings :: Strings -> T_Strings
sem_Strings list = Prelude.foldr sem_Strings_Cons sem_Strings_Nil list
-- semantic domain
newtype T_Strings = T_Strings {
attach_T_Strings :: Identity (T_Strings_s161 )
}
newtype T_Strings_s161 = C_Strings_s161 {
inv_Strings_s161 :: (T_Strings_v160 )
}
data T_Strings_s162 = C_Strings_s162
type T_Strings_v160 = (T_Strings_vIn160 ) -> (T_Strings_vOut160 )
data T_Strings_vIn160 = T_Strings_vIn160
data T_Strings_vOut160 = T_Strings_vOut160 (Strings)
{-# NOINLINE sem_Strings_Cons #-}
sem_Strings_Cons :: (String) -> T_Strings -> T_Strings
sem_Strings_Cons arg_hd_ arg_tl_ = T_Strings (return st161) where
{-# NOINLINE st161 #-}
st161 = let
v160 :: T_Strings_v160
v160 = \ (T_Strings_vIn160 ) -> ( let
_tlX161 = Control.Monad.Identity.runIdentity (attach_T_Strings (arg_tl_))
(T_Strings_vOut160 _tlIself) = inv_Strings_s161 _tlX161 (T_Strings_vIn160 )
_self = rule3830 _tlIself arg_hd_
_lhsOself :: Strings
_lhsOself = rule3831 _self
__result_ = T_Strings_vOut160 _lhsOself
in __result_ )
in C_Strings_s161 v160
{-# INLINE rule3830 #-}
rule3830 = \ ((_tlIself) :: Strings) hd_ ->
(:) hd_ _tlIself
{-# INLINE rule3831 #-}
rule3831 = \ _self ->
_self
{-# NOINLINE sem_Strings_Nil #-}
sem_Strings_Nil :: T_Strings
sem_Strings_Nil = T_Strings (return st161) where
{-# NOINLINE st161 #-}
st161 = let
v160 :: T_Strings_v160
v160 = \ (T_Strings_vIn160 ) -> ( let
_self = rule3832 ()
_lhsOself :: Strings
_lhsOself = rule3833 _self
__result_ = T_Strings_vOut160 _lhsOself
in __result_ )
in C_Strings_s161 v160
{-# INLINE rule3832 #-}
rule3832 = \ (_ :: ()) ->
[]
{-# INLINE rule3833 #-}
rule3833 = \ _self ->
_self
-- Type --------------------------------------------------------
-- wrapper
data Inh_Type = Inh_Type { }
data Syn_Type = Syn_Type { self_Syn_Type :: (Type) }
{-# INLINABLE wrap_Type #-}
wrap_Type :: T_Type -> Inh_Type -> (Syn_Type )
wrap_Type (T_Type act) (Inh_Type ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Type_vIn163
(T_Type_vOut163 _lhsOself) <- return (inv_Type_s164 sem arg)
return (Syn_Type _lhsOself)
)
-- cata
{-# NOINLINE sem_Type #-}
sem_Type :: Type -> T_Type
sem_Type ( Type_Application range_ prefix_ function_ arguments_ ) = sem_Type_Application ( sem_Range range_ ) prefix_ ( sem_Type function_ ) ( sem_Types arguments_ )
sem_Type ( Type_Variable range_ name_ ) = sem_Type_Variable ( sem_Range range_ ) ( sem_Name name_ )
sem_Type ( Type_Constructor range_ name_ ) = sem_Type_Constructor ( sem_Range range_ ) ( sem_Name name_ )
sem_Type ( Type_Qualified range_ context_ type_ ) = sem_Type_Qualified ( sem_Range range_ ) ( sem_ContextItems context_ ) ( sem_Type type_ )
sem_Type ( Type_Forall range_ typevariables_ type_ ) = sem_Type_Forall ( sem_Range range_ ) ( sem_Names typevariables_ ) ( sem_Type type_ )
sem_Type ( Type_Exists range_ typevariables_ type_ ) = sem_Type_Exists ( sem_Range range_ ) ( sem_Names typevariables_ ) ( sem_Type type_ )
sem_Type ( Type_Parenthesized range_ type_ ) = sem_Type_Parenthesized ( sem_Range range_ ) ( sem_Type type_ )
-- semantic domain
newtype T_Type = T_Type {
attach_T_Type :: Identity (T_Type_s164 )
}
newtype T_Type_s164 = C_Type_s164 {
inv_Type_s164 :: (T_Type_v163 )
}
data T_Type_s165 = C_Type_s165
type T_Type_v163 = (T_Type_vIn163 ) -> (T_Type_vOut163 )
data T_Type_vIn163 = T_Type_vIn163
data T_Type_vOut163 = T_Type_vOut163 (Type)
{-# NOINLINE sem_Type_Application #-}
sem_Type_Application :: T_Range -> (Bool) -> T_Type -> T_Types -> T_Type
sem_Type_Application arg_range_ arg_prefix_ arg_function_ arg_arguments_ = T_Type (return st164) where
{-# NOINLINE st164 #-}
st164 = let
v163 :: T_Type_v163
v163 = \ (T_Type_vIn163 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_functionX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_function_))
_argumentsX167 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_arguments_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Type_vOut163 _functionIself) = inv_Type_s164 _functionX164 (T_Type_vIn163 )
(T_Types_vOut166 _argumentsIself) = inv_Types_s167 _argumentsX167 (T_Types_vIn166 )
_self = rule3834 _argumentsIself _functionIself _rangeIself arg_prefix_
_lhsOself :: Type
_lhsOself = rule3835 _self
__result_ = T_Type_vOut163 _lhsOself
in __result_ )
in C_Type_s164 v163
{-# INLINE rule3834 #-}
rule3834 = \ ((_argumentsIself) :: Types) ((_functionIself) :: Type) ((_rangeIself) :: Range) prefix_ ->
Type_Application _rangeIself prefix_ _functionIself _argumentsIself
{-# INLINE rule3835 #-}
rule3835 = \ _self ->
_self
{-# NOINLINE sem_Type_Variable #-}
sem_Type_Variable :: T_Range -> T_Name -> T_Type
sem_Type_Variable arg_range_ arg_name_ = T_Type (return st164) where
{-# NOINLINE st164 #-}
st164 = let
v163 :: T_Type_v163
v163 = \ (T_Type_vIn163 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
_self = rule3836 _nameIself _rangeIself
_lhsOself :: Type
_lhsOself = rule3837 _self
__result_ = T_Type_vOut163 _lhsOself
in __result_ )
in C_Type_s164 v163
{-# INLINE rule3836 #-}
rule3836 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
Type_Variable _rangeIself _nameIself
{-# INLINE rule3837 #-}
rule3837 = \ _self ->
_self
{-# NOINLINE sem_Type_Constructor #-}
sem_Type_Constructor :: T_Range -> T_Name -> T_Type
sem_Type_Constructor arg_range_ arg_name_ = T_Type (return st164) where
{-# NOINLINE st164 #-}
st164 = let
v163 :: T_Type_v163
v163 = \ (T_Type_vIn163 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
_self = rule3838 _nameIself _rangeIself
_lhsOself :: Type
_lhsOself = rule3839 _self
__result_ = T_Type_vOut163 _lhsOself
in __result_ )
in C_Type_s164 v163
{-# INLINE rule3838 #-}
rule3838 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
Type_Constructor _rangeIself _nameIself
{-# INLINE rule3839 #-}
rule3839 = \ _self ->
_self
{-# NOINLINE sem_Type_Qualified #-}
sem_Type_Qualified :: T_Range -> T_ContextItems -> T_Type -> T_Type
sem_Type_Qualified arg_range_ arg_context_ arg_type_ = T_Type (return st164) where
{-# NOINLINE st164 #-}
st164 = let
v163 :: T_Type_v163
v163 = \ (T_Type_vIn163 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_contextX26 = Control.Monad.Identity.runIdentity (attach_T_ContextItems (arg_context_))
_typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_ContextItems_vOut25 _contextIself) = inv_ContextItems_s26 _contextX26 (T_ContextItems_vIn25 )
(T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
_self = rule3840 _contextIself _rangeIself _typeIself
_lhsOself :: Type
_lhsOself = rule3841 _self
__result_ = T_Type_vOut163 _lhsOself
in __result_ )
in C_Type_s164 v163
{-# INLINE rule3840 #-}
rule3840 = \ ((_contextIself) :: ContextItems) ((_rangeIself) :: Range) ((_typeIself) :: Type) ->
Type_Qualified _rangeIself _contextIself _typeIself
{-# INLINE rule3841 #-}
rule3841 = \ _self ->
_self
{-# NOINLINE sem_Type_Forall #-}
sem_Type_Forall :: T_Range -> T_Names -> T_Type -> T_Type
sem_Type_Forall arg_range_ arg_typevariables_ arg_type_ = T_Type (return st164) where
{-# NOINLINE st164 #-}
st164 = let
v163 :: T_Type_v163
v163 = \ (T_Type_vIn163 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_typevariablesX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_typevariables_))
_typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Names_vOut115 _typevariablesIself) = inv_Names_s116 _typevariablesX116 (T_Names_vIn115 )
(T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
_self = rule3842 _rangeIself _typeIself _typevariablesIself
_lhsOself :: Type
_lhsOself = rule3843 _self
__result_ = T_Type_vOut163 _lhsOself
in __result_ )
in C_Type_s164 v163
{-# INLINE rule3842 #-}
rule3842 = \ ((_rangeIself) :: Range) ((_typeIself) :: Type) ((_typevariablesIself) :: Names) ->
Type_Forall _rangeIself _typevariablesIself _typeIself
{-# INLINE rule3843 #-}
rule3843 = \ _self ->
_self
{-# NOINLINE sem_Type_Exists #-}
sem_Type_Exists :: T_Range -> T_Names -> T_Type -> T_Type
sem_Type_Exists arg_range_ arg_typevariables_ arg_type_ = T_Type (return st164) where
{-# NOINLINE st164 #-}
st164 = let
v163 :: T_Type_v163
v163 = \ (T_Type_vIn163 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_typevariablesX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_typevariables_))
_typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Names_vOut115 _typevariablesIself) = inv_Names_s116 _typevariablesX116 (T_Names_vIn115 )
(T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
_self = rule3844 _rangeIself _typeIself _typevariablesIself
_lhsOself :: Type
_lhsOself = rule3845 _self
__result_ = T_Type_vOut163 _lhsOself
in __result_ )
in C_Type_s164 v163
{-# INLINE rule3844 #-}
rule3844 = \ ((_rangeIself) :: Range) ((_typeIself) :: Type) ((_typevariablesIself) :: Names) ->
Type_Exists _rangeIself _typevariablesIself _typeIself
{-# INLINE rule3845 #-}
rule3845 = \ _self ->
_self
{-# NOINLINE sem_Type_Parenthesized #-}
sem_Type_Parenthesized :: T_Range -> T_Type -> T_Type
sem_Type_Parenthesized arg_range_ arg_type_ = T_Type (return st164) where
{-# NOINLINE st164 #-}
st164 = let
v163 :: T_Type_v163
v163 = \ (T_Type_vIn163 ) -> ( let
_rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
_typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
(T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
(T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
_self = rule3846 _rangeIself _typeIself
_lhsOself :: Type
_lhsOself = rule3847 _self
__result_ = T_Type_vOut163 _lhsOself
in __result_ )
in C_Type_s164 v163
{-# INLINE rule3846 #-}
rule3846 = \ ((_rangeIself) :: Range) ((_typeIself) :: Type) ->
Type_Parenthesized _rangeIself _typeIself
{-# INLINE rule3847 #-}
rule3847 = \ _self ->
_self
-- Types -------------------------------------------------------
-- wrapper
data Inh_Types = Inh_Types { }
data Syn_Types = Syn_Types { self_Syn_Types :: (Types) }
{-# INLINABLE wrap_Types #-}
wrap_Types :: T_Types -> Inh_Types -> (Syn_Types )
wrap_Types (T_Types act) (Inh_Types ) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg = T_Types_vIn166
(T_Types_vOut166 _lhsOself) <- return (inv_Types_s167 sem arg)
return (Syn_Types _lhsOself)
)
-- cata
{-# NOINLINE sem_Types #-}
sem_Types :: Types -> T_Types
sem_Types list = Prelude.foldr sem_Types_Cons sem_Types_Nil (Prelude.map sem_Type list)
-- semantic domain
newtype T_Types = T_Types {
attach_T_Types :: Identity (T_Types_s167 )
}
newtype T_Types_s167 = C_Types_s167 {
inv_Types_s167 :: (T_Types_v166 )
}
data T_Types_s168 = C_Types_s168
type T_Types_v166 = (T_Types_vIn166 ) -> (T_Types_vOut166 )
data T_Types_vIn166 = T_Types_vIn166
data T_Types_vOut166 = T_Types_vOut166 (Types)
{-# NOINLINE sem_Types_Cons #-}
sem_Types_Cons :: T_Type -> T_Types -> T_Types
sem_Types_Cons arg_hd_ arg_tl_ = T_Types (return st167) where
{-# NOINLINE st167 #-}
st167 = let
v166 :: T_Types_v166
v166 = \ (T_Types_vIn166 ) -> ( let
_hdX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_hd_))
_tlX167 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_tl_))
(T_Type_vOut163 _hdIself) = inv_Type_s164 _hdX164 (T_Type_vIn163 )
(T_Types_vOut166 _tlIself) = inv_Types_s167 _tlX167 (T_Types_vIn166 )
_self = rule3848 _hdIself _tlIself
_lhsOself :: Types
_lhsOself = rule3849 _self
__result_ = T_Types_vOut166 _lhsOself
in __result_ )
in C_Types_s167 v166
{-# INLINE rule3848 #-}
rule3848 = \ ((_hdIself) :: Type) ((_tlIself) :: Types) ->
(:) _hdIself _tlIself
{-# INLINE rule3849 #-}
rule3849 = \ _self ->
_self
{-# NOINLINE sem_Types_Nil #-}
sem_Types_Nil :: T_Types
sem_Types_Nil = T_Types (return st167) where
{-# NOINLINE st167 #-}
st167 = let
v166 :: T_Types_v166
v166 = \ (T_Types_vIn166 ) -> ( let
_self = rule3850 ()
_lhsOself :: Types
_lhsOself = rule3851 _self
__result_ = T_Types_vOut166 _lhsOself
in __result_ )
in C_Types_s167 v166
{-# INLINE rule3850 #-}
rule3850 = \ (_ :: ()) ->
[]
{-# INLINE rule3851 #-}
rule3851 = \ _self ->
_self