{- |
    Module      :  $Header$
    Description :  Proper Qualification
    Copyright   :  (c) 2001 - 2004 Wolfgang Lux
                       2005        Martin Engelke
                       2011 - 2015 Björn Peemöller
                       2016 - 2017 Finn Teegen
    License     :  BSD-3-clause

    Maintainer  :  bjp@informatik.uni-kiel.de
    Stability   :  experimental
    Portability :  portable

    After checking the module and before starting the translation into the
    intermediate language, the compiler properly qualifies all type
    constructors, data constructors and (global) functions
    occurring in a pattern or expression such that their module prefix
    matches the module of their definition.
    This is done also for functions and constructors declared
    in the current module.
    Only functions and variables declared in local declarations groups
    as well as function arguments remain unchanged.
-}
{-# LANGUAGE CPP #-}
module Transformations.Qual (qual) where

#if __GLASGOW_HASKELL__ < 710
import           Control.Applicative       ((<$>), (<*>), pure)
#endif
import qualified Control.Monad.Reader as R (Reader, asks, runReader)
import           Data.Traversable
import           Prelude hiding            (mapM)

import Curry.Base.Ident
import Curry.Syntax

import Base.TopEnv         (origName)

import Env.TypeConstructor (TCEnv   , qualLookupTypeInfo)
import Env.Value           (ValueEnv, qualLookupValue)

data QualEnv = QualEnv
  { QualEnv -> ModuleIdent
moduleIdent :: ModuleIdent
  , QualEnv -> TCEnv
tyConsEnv   :: TCEnv
  , QualEnv -> ValueEnv
valueEnv    :: ValueEnv
  }

type Qual a = a -> R.Reader QualEnv a

qual :: ModuleIdent -> TCEnv -> ValueEnv -> Module a -> Module a
qual :: ModuleIdent -> TCEnv -> ValueEnv -> Module a -> Module a
qual m :: ModuleIdent
m tcEnv :: TCEnv
tcEnv tyEnv :: ValueEnv
tyEnv mdl :: Module a
mdl = Reader QualEnv (Module a) -> QualEnv -> Module a
forall r a. Reader r a -> r -> a
R.runReader (Qual (Module a)
forall a. Qual (Module a)
qModule Module a
mdl) (ModuleIdent -> TCEnv -> ValueEnv -> QualEnv
QualEnv ModuleIdent
m TCEnv
tcEnv ValueEnv
tyEnv)

qModule :: Qual (Module a)
qModule :: Qual (Module a)
qModule (Module spi :: SpanInfo
spi ps :: [ModulePragma]
ps m :: ModuleIdent
m es :: Maybe ExportSpec
es is :: [ImportDecl]
is ds :: [Decl a]
ds) = do
  Maybe ExportSpec
es' <- Qual (Maybe ExportSpec)
qExportSpec Maybe ExportSpec
es
  [Decl a]
ds' <- (Decl a -> ReaderT QualEnv Identity (Decl a))
-> [Decl a] -> ReaderT QualEnv Identity [Decl a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Decl a -> ReaderT QualEnv Identity (Decl a)
forall a. Qual (Decl a)
qDecl  [Decl a]
ds
  Qual (Module a)
forall (m :: * -> *) a. Monad m => a -> m a
return (SpanInfo
-> [ModulePragma]
-> ModuleIdent
-> Maybe ExportSpec
-> [ImportDecl]
-> [Decl a]
-> Module a
forall a.
SpanInfo
-> [ModulePragma]
-> ModuleIdent
-> Maybe ExportSpec
-> [ImportDecl]
-> [Decl a]
-> Module a
Module SpanInfo
spi [ModulePragma]
ps ModuleIdent
m Maybe ExportSpec
es' [ImportDecl]
is [Decl a]
ds')

qExportSpec :: Qual (Maybe ExportSpec)
qExportSpec :: Qual (Maybe ExportSpec)
qExportSpec Nothing                 = Qual (Maybe ExportSpec)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ExportSpec
forall a. Maybe a
Nothing
qExportSpec (Just (Exporting p :: SpanInfo
p es :: [Export]
es)) = (ExportSpec -> Maybe ExportSpec
forall a. a -> Maybe a
Just (ExportSpec -> Maybe ExportSpec)
-> ([Export] -> ExportSpec) -> [Export] -> Maybe ExportSpec
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpanInfo -> [Export] -> ExportSpec
Exporting SpanInfo
p) ([Export] -> Maybe ExportSpec)
-> ReaderT QualEnv Identity [Export]
-> ReaderT QualEnv Identity (Maybe ExportSpec)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Export -> ReaderT QualEnv Identity Export)
-> [Export] -> ReaderT QualEnv Identity [Export]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Export -> ReaderT QualEnv Identity Export
qExport [Export]
es

qExport :: Qual Export
qExport :: Export -> ReaderT QualEnv Identity Export
qExport (Export            spi :: SpanInfo
spi x :: QualIdent
x) = SpanInfo -> QualIdent -> Export
Export SpanInfo
spi (QualIdent -> Export)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity Export
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qIdent QualIdent
x
qExport (ExportTypeWith spi :: SpanInfo
spi t :: QualIdent
t cs :: [Ident]
cs) = (QualIdent -> [Ident] -> Export) -> [Ident] -> QualIdent -> Export
forall a b c. (a -> b -> c) -> b -> a -> c
flip (SpanInfo -> QualIdent -> [Ident] -> Export
ExportTypeWith SpanInfo
spi) [Ident]
cs (QualIdent -> Export)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity Export
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qConstr QualIdent
t
qExport (ExportTypeAll     spi :: SpanInfo
spi t :: QualIdent
t) = SpanInfo -> QualIdent -> Export
ExportTypeAll SpanInfo
spi (QualIdent -> Export)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity Export
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qConstr QualIdent
t
qExport m :: Export
m@(ExportModule      _ _) = Export -> ReaderT QualEnv Identity Export
forall (m :: * -> *) a. Monad m => a -> m a
return Export
m

qDecl :: Qual (Decl a)
qDecl :: Qual (Decl a)
qDecl i :: Decl a
i@(InfixDecl          _ _ _ _) = Qual (Decl a)
forall (m :: * -> *) a. Monad m => a -> m a
return Decl a
i
qDecl (DataDecl      p :: SpanInfo
p n :: Ident
n vs :: [Ident]
vs cs :: [ConstrDecl]
cs clss :: [QualIdent]
clss) = SpanInfo
-> Ident -> [Ident] -> [ConstrDecl] -> [QualIdent] -> Decl a
forall a.
SpanInfo
-> Ident -> [Ident] -> [ConstrDecl] -> [QualIdent] -> Decl a
DataDecl SpanInfo
p Ident
n [Ident]
vs ([ConstrDecl] -> [QualIdent] -> Decl a)
-> ReaderT QualEnv Identity [ConstrDecl]
-> ReaderT QualEnv Identity ([QualIdent] -> Decl a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
  (ConstrDecl -> ReaderT QualEnv Identity ConstrDecl)
-> [ConstrDecl] -> ReaderT QualEnv Identity [ConstrDecl]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ConstrDecl -> ReaderT QualEnv Identity ConstrDecl
qConstrDecl [ConstrDecl]
cs ReaderT QualEnv Identity ([QualIdent] -> Decl a)
-> ReaderT QualEnv Identity [QualIdent]
-> ReaderT QualEnv Identity (Decl a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual QualIdent
-> [QualIdent] -> ReaderT QualEnv Identity [QualIdent]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual QualIdent
qClass [QualIdent]
clss
qDecl e :: Decl a
e@(ExternalDataDecl     _ _ _) = Qual (Decl a)
forall (m :: * -> *) a. Monad m => a -> m a
return Decl a
e
qDecl (NewtypeDecl   p :: SpanInfo
p n :: Ident
n vs :: [Ident]
vs nc :: NewConstrDecl
nc clss :: [QualIdent]
clss) = SpanInfo
-> Ident -> [Ident] -> NewConstrDecl -> [QualIdent] -> Decl a
forall a.
SpanInfo
-> Ident -> [Ident] -> NewConstrDecl -> [QualIdent] -> Decl a
NewtypeDecl SpanInfo
p Ident
n [Ident]
vs (NewConstrDecl -> [QualIdent] -> Decl a)
-> ReaderT QualEnv Identity NewConstrDecl
-> ReaderT QualEnv Identity ([QualIdent] -> Decl a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
  Qual NewConstrDecl
qNewConstrDecl NewConstrDecl
nc ReaderT QualEnv Identity ([QualIdent] -> Decl a)
-> ReaderT QualEnv Identity [QualIdent]
-> ReaderT QualEnv Identity (Decl a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual QualIdent
-> [QualIdent] -> ReaderT QualEnv Identity [QualIdent]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual QualIdent
qClass [QualIdent]
clss
qDecl (TypeDecl           p :: SpanInfo
p n :: Ident
n vs :: [Ident]
vs ty :: TypeExpr
ty) = SpanInfo -> Ident -> [Ident] -> TypeExpr -> Decl a
forall a. SpanInfo -> Ident -> [Ident] -> TypeExpr -> Decl a
TypeDecl SpanInfo
p Ident
n [Ident]
vs (TypeExpr -> Decl a)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity (Decl a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr
qTypeExpr TypeExpr
ty
qDecl (TypeSig             p :: SpanInfo
p fs :: [Ident]
fs qty :: QualTypeExpr
qty) = SpanInfo -> [Ident] -> QualTypeExpr -> Decl a
forall a. SpanInfo -> [Ident] -> QualTypeExpr -> Decl a
TypeSig SpanInfo
p [Ident]
fs (QualTypeExpr -> Decl a)
-> ReaderT QualEnv Identity QualTypeExpr
-> ReaderT QualEnv Identity (Decl a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualTypeExpr
qQualTypeExpr QualTypeExpr
qty
qDecl (FunctionDecl       a :: SpanInfo
a p :: a
p f :: Ident
f eqs :: [Equation a]
eqs) = SpanInfo -> a -> Ident -> [Equation a] -> Decl a
forall a. SpanInfo -> a -> Ident -> [Equation a] -> Decl a
FunctionDecl SpanInfo
a a
p Ident
f ([Equation a] -> Decl a)
-> ReaderT QualEnv Identity [Equation a]
-> ReaderT QualEnv Identity (Decl a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Equation a -> ReaderT QualEnv Identity (Equation a))
-> [Equation a] -> ReaderT QualEnv Identity [Equation a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Equation a -> ReaderT QualEnv Identity (Equation a)
forall a. Qual (Equation a)
qEquation [Equation a]
eqs
qDecl e :: Decl a
e@(ExternalDecl           _ _) = Qual (Decl a)
forall (m :: * -> *) a. Monad m => a -> m a
return Decl a
e
qDecl (PatternDecl          p :: SpanInfo
p t :: Pattern a
t rhs :: Rhs a
rhs) = SpanInfo -> Pattern a -> Rhs a -> Decl a
forall a. SpanInfo -> Pattern a -> Rhs a -> Decl a
PatternDecl SpanInfo
p (Pattern a -> Rhs a -> Decl a)
-> ReaderT QualEnv Identity (Pattern a)
-> ReaderT QualEnv Identity (Rhs a -> Decl a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern Pattern a
t ReaderT QualEnv Identity (Rhs a -> Decl a)
-> ReaderT QualEnv Identity (Rhs a)
-> ReaderT QualEnv Identity (Decl a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Rhs a)
forall a. Qual (Rhs a)
qRhs Rhs a
rhs
qDecl vs :: Decl a
vs@(FreeDecl              _ _) = Qual (Decl a)
forall (m :: * -> *) a. Monad m => a -> m a
return Decl a
vs
qDecl (DefaultDecl            p :: SpanInfo
p tys :: [TypeExpr]
tys) = SpanInfo -> [TypeExpr] -> Decl a
forall a. SpanInfo -> [TypeExpr] -> Decl a
DefaultDecl SpanInfo
p ([TypeExpr] -> Decl a)
-> ReaderT QualEnv Identity [TypeExpr]
-> ReaderT QualEnv Identity (Decl a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr -> [TypeExpr] -> ReaderT QualEnv Identity [TypeExpr]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual TypeExpr
qTypeExpr [TypeExpr]
tys
qDecl (ClassDecl     p :: SpanInfo
p cx :: Context
cx cls :: Ident
cls tv :: Ident
tv ds :: [Decl a]
ds) = SpanInfo -> Context -> Ident -> Ident -> [Decl a] -> Decl a
forall a.
SpanInfo -> Context -> Ident -> Ident -> [Decl a] -> Decl a
ClassDecl SpanInfo
p (Context -> Ident -> Ident -> [Decl a] -> Decl a)
-> ReaderT QualEnv Identity Context
-> ReaderT QualEnv Identity (Ident -> Ident -> [Decl a] -> Decl a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
  Qual Context
qContext Context
cx ReaderT QualEnv Identity (Ident -> Ident -> [Decl a] -> Decl a)
-> ReaderT QualEnv Identity Ident
-> ReaderT QualEnv Identity (Ident -> [Decl a] -> Decl a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ident -> ReaderT QualEnv Identity Ident
forall (f :: * -> *) a. Applicative f => a -> f a
pure Ident
cls ReaderT QualEnv Identity (Ident -> [Decl a] -> Decl a)
-> ReaderT QualEnv Identity Ident
-> ReaderT QualEnv Identity ([Decl a] -> Decl a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ident -> ReaderT QualEnv Identity Ident
forall (f :: * -> *) a. Applicative f => a -> f a
pure Ident
tv ReaderT QualEnv Identity ([Decl a] -> Decl a)
-> ReaderT QualEnv Identity [Decl a]
-> ReaderT QualEnv Identity (Decl a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Decl a) -> [Decl a] -> ReaderT QualEnv Identity [Decl a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual (Decl a)
forall a. Qual (Decl a)
qDecl [Decl a]
ds
qDecl (InstanceDecl p :: SpanInfo
p cx :: Context
cx qcls :: QualIdent
qcls ty :: TypeExpr
ty ds :: [Decl a]
ds) = SpanInfo -> Context -> QualIdent -> TypeExpr -> [Decl a] -> Decl a
forall a.
SpanInfo -> Context -> QualIdent -> TypeExpr -> [Decl a] -> Decl a
InstanceDecl SpanInfo
p (Context -> QualIdent -> TypeExpr -> [Decl a] -> Decl a)
-> ReaderT QualEnv Identity Context
-> ReaderT
     QualEnv Identity (QualIdent -> TypeExpr -> [Decl a] -> Decl a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
  Qual Context
qContext Context
cx ReaderT
  QualEnv Identity (QualIdent -> TypeExpr -> [Decl a] -> Decl a)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity (TypeExpr -> [Decl a] -> Decl a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual QualIdent
qClass QualIdent
qcls ReaderT QualEnv Identity (TypeExpr -> [Decl a] -> Decl a)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity ([Decl a] -> Decl a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual TypeExpr
qTypeExpr TypeExpr
ty ReaderT QualEnv Identity ([Decl a] -> Decl a)
-> ReaderT QualEnv Identity [Decl a]
-> ReaderT QualEnv Identity (Decl a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Decl a) -> [Decl a] -> ReaderT QualEnv Identity [Decl a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual (Decl a)
forall a. Qual (Decl a)
qDecl [Decl a]
ds

qConstrDecl :: Qual ConstrDecl
qConstrDecl :: ConstrDecl -> ReaderT QualEnv Identity ConstrDecl
qConstrDecl (ConstrDecl p :: SpanInfo
p      n :: Ident
n tys :: [TypeExpr]
tys) =
  SpanInfo -> Ident -> [TypeExpr] -> ConstrDecl
ConstrDecl SpanInfo
p Ident
n ([TypeExpr] -> ConstrDecl)
-> ReaderT QualEnv Identity [TypeExpr]
-> ReaderT QualEnv Identity ConstrDecl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr -> [TypeExpr] -> ReaderT QualEnv Identity [TypeExpr]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual TypeExpr
qTypeExpr [TypeExpr]
tys
qConstrDecl (ConOpDecl  p :: SpanInfo
p ty1 :: TypeExpr
ty1 op :: Ident
op ty2 :: TypeExpr
ty2) =
  SpanInfo -> TypeExpr -> Ident -> TypeExpr -> ConstrDecl
ConOpDecl SpanInfo
p (TypeExpr -> Ident -> TypeExpr -> ConstrDecl)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity (Ident -> TypeExpr -> ConstrDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr
qTypeExpr TypeExpr
ty1 ReaderT QualEnv Identity (Ident -> TypeExpr -> ConstrDecl)
-> ReaderT QualEnv Identity Ident
-> ReaderT QualEnv Identity (TypeExpr -> ConstrDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ident -> ReaderT QualEnv Identity Ident
forall (f :: * -> *) a. Applicative f => a -> f a
pure Ident
op ReaderT QualEnv Identity (TypeExpr -> ConstrDecl)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity ConstrDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual TypeExpr
qTypeExpr TypeExpr
ty2
qConstrDecl (RecordDecl p :: SpanInfo
p       c :: Ident
c fs :: [FieldDecl]
fs) =
  SpanInfo -> Ident -> [FieldDecl] -> ConstrDecl
RecordDecl SpanInfo
p Ident
c ([FieldDecl] -> ConstrDecl)
-> ReaderT QualEnv Identity [FieldDecl]
-> ReaderT QualEnv Identity ConstrDecl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldDecl -> ReaderT QualEnv Identity FieldDecl)
-> [FieldDecl] -> ReaderT QualEnv Identity [FieldDecl]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM FieldDecl -> ReaderT QualEnv Identity FieldDecl
qFieldDecl [FieldDecl]
fs

qNewConstrDecl :: Qual NewConstrDecl
qNewConstrDecl :: Qual NewConstrDecl
qNewConstrDecl (NewConstrDecl p :: SpanInfo
p n :: Ident
n ty :: TypeExpr
ty)
  = SpanInfo -> Ident -> TypeExpr -> NewConstrDecl
NewConstrDecl SpanInfo
p Ident
n (TypeExpr -> NewConstrDecl)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity NewConstrDecl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr
qTypeExpr TypeExpr
ty
qNewConstrDecl (NewRecordDecl p :: SpanInfo
p n :: Ident
n (f :: Ident
f, ty :: TypeExpr
ty))
  = (\ty' :: TypeExpr
ty' -> SpanInfo -> Ident -> (Ident, TypeExpr) -> NewConstrDecl
NewRecordDecl SpanInfo
p Ident
n (Ident
f, TypeExpr
ty')) (TypeExpr -> NewConstrDecl)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity NewConstrDecl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr
qTypeExpr TypeExpr
ty

qFieldDecl :: Qual FieldDecl
qFieldDecl :: FieldDecl -> ReaderT QualEnv Identity FieldDecl
qFieldDecl (FieldDecl p :: SpanInfo
p fs :: [Ident]
fs ty :: TypeExpr
ty) = SpanInfo -> [Ident] -> TypeExpr -> FieldDecl
FieldDecl SpanInfo
p [Ident]
fs (TypeExpr -> FieldDecl)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity FieldDecl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr
qTypeExpr TypeExpr
ty

qConstraint :: Qual Constraint
qConstraint :: Qual Constraint
qConstraint (Constraint spi :: SpanInfo
spi cls :: QualIdent
cls ty :: TypeExpr
ty) =
  SpanInfo -> QualIdent -> TypeExpr -> Constraint
Constraint SpanInfo
spi (QualIdent -> TypeExpr -> Constraint)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity (TypeExpr -> Constraint)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qClass QualIdent
cls ReaderT QualEnv Identity (TypeExpr -> Constraint)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity Constraint
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual TypeExpr
qTypeExpr TypeExpr
ty

qContext :: Qual Context
qContext :: Qual Context
qContext = Qual Constraint -> Qual Context
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual Constraint
qConstraint

qTypeExpr :: Qual TypeExpr
qTypeExpr :: Qual TypeExpr
qTypeExpr (ConstructorType     spi :: SpanInfo
spi c :: QualIdent
c) = SpanInfo -> QualIdent -> TypeExpr
ConstructorType SpanInfo
spi (QualIdent -> TypeExpr)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity TypeExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qConstr QualIdent
c
qTypeExpr (ApplyType     spi :: SpanInfo
spi ty1 :: TypeExpr
ty1 ty2 :: TypeExpr
ty2) = SpanInfo -> TypeExpr -> TypeExpr -> TypeExpr
ApplyType SpanInfo
spi (TypeExpr -> TypeExpr -> TypeExpr)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity (TypeExpr -> TypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr
qTypeExpr TypeExpr
ty1
                                              ReaderT QualEnv Identity (TypeExpr -> TypeExpr)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity TypeExpr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual TypeExpr
qTypeExpr TypeExpr
ty2
qTypeExpr v :: TypeExpr
v@(VariableType        _ _) = Qual TypeExpr
forall (m :: * -> *) a. Monad m => a -> m a
return TypeExpr
v
qTypeExpr (TupleType         spi :: SpanInfo
spi tys :: [TypeExpr]
tys) = SpanInfo -> [TypeExpr] -> TypeExpr
TupleType SpanInfo
spi ([TypeExpr] -> TypeExpr)
-> ReaderT QualEnv Identity [TypeExpr]
-> ReaderT QualEnv Identity TypeExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr -> [TypeExpr] -> ReaderT QualEnv Identity [TypeExpr]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual TypeExpr
qTypeExpr [TypeExpr]
tys
qTypeExpr (ListType           spi :: SpanInfo
spi ty :: TypeExpr
ty) = SpanInfo -> TypeExpr -> TypeExpr
ListType SpanInfo
spi  (TypeExpr -> TypeExpr)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity TypeExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr
qTypeExpr TypeExpr
ty
qTypeExpr (ArrowType     spi :: SpanInfo
spi ty1 :: TypeExpr
ty1 ty2 :: TypeExpr
ty2) = SpanInfo -> TypeExpr -> TypeExpr -> TypeExpr
ArrowType SpanInfo
spi (TypeExpr -> TypeExpr -> TypeExpr)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity (TypeExpr -> TypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr
qTypeExpr TypeExpr
ty1
                                              ReaderT QualEnv Identity (TypeExpr -> TypeExpr)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity TypeExpr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual TypeExpr
qTypeExpr TypeExpr
ty2
qTypeExpr (ParenType          spi :: SpanInfo
spi ty :: TypeExpr
ty) = SpanInfo -> TypeExpr -> TypeExpr
ParenType SpanInfo
spi (TypeExpr -> TypeExpr)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity TypeExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr
qTypeExpr TypeExpr
ty
qTypeExpr (ForallType      spi :: SpanInfo
spi vs :: [Ident]
vs ty :: TypeExpr
ty) = SpanInfo -> [Ident] -> TypeExpr -> TypeExpr
ForallType SpanInfo
spi [Ident]
vs (TypeExpr -> TypeExpr)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity TypeExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual TypeExpr
qTypeExpr TypeExpr
ty

qQualTypeExpr :: Qual QualTypeExpr
qQualTypeExpr :: Qual QualTypeExpr
qQualTypeExpr (QualTypeExpr spi :: SpanInfo
spi cx :: Context
cx ty :: TypeExpr
ty) = SpanInfo -> Context -> TypeExpr -> QualTypeExpr
QualTypeExpr SpanInfo
spi (Context -> TypeExpr -> QualTypeExpr)
-> ReaderT QualEnv Identity Context
-> ReaderT QualEnv Identity (TypeExpr -> QualTypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual Context
qContext Context
cx
                                                          ReaderT QualEnv Identity (TypeExpr -> QualTypeExpr)
-> ReaderT QualEnv Identity TypeExpr
-> ReaderT QualEnv Identity QualTypeExpr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual TypeExpr
qTypeExpr TypeExpr
ty

qEquation :: Qual (Equation a)
qEquation :: Qual (Equation a)
qEquation (Equation p :: SpanInfo
p lhs :: Lhs a
lhs rhs :: Rhs a
rhs) = SpanInfo -> Lhs a -> Rhs a -> Equation a
forall a. SpanInfo -> Lhs a -> Rhs a -> Equation a
Equation SpanInfo
p (Lhs a -> Rhs a -> Equation a)
-> ReaderT QualEnv Identity (Lhs a)
-> ReaderT QualEnv Identity (Rhs a -> Equation a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Lhs a)
forall a. Qual (Lhs a)
qLhs Lhs a
lhs ReaderT QualEnv Identity (Rhs a -> Equation a)
-> ReaderT QualEnv Identity (Rhs a)
-> ReaderT QualEnv Identity (Equation a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Rhs a)
forall a. Qual (Rhs a)
qRhs Rhs a
rhs

qLhs :: Qual (Lhs a)
qLhs :: Qual (Lhs a)
qLhs (FunLhs sp :: SpanInfo
sp    f :: Ident
f ts :: [Pattern a]
ts) = SpanInfo -> Ident -> [Pattern a] -> Lhs a
forall a. SpanInfo -> Ident -> [Pattern a] -> Lhs a
FunLhs SpanInfo
sp       Ident
f  ([Pattern a] -> Lhs a)
-> ReaderT QualEnv Identity [Pattern a]
-> ReaderT QualEnv Identity (Lhs a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Pattern a -> ReaderT QualEnv Identity (Pattern a))
-> [Pattern a] -> ReaderT QualEnv Identity [Pattern a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Pattern a -> ReaderT QualEnv Identity (Pattern a)
forall a. Qual (Pattern a)
qPattern [Pattern a]
ts
qLhs (OpLhs sp :: SpanInfo
sp t1 :: Pattern a
t1 op :: Ident
op t2 :: Pattern a
t2) = (Pattern a -> Ident -> Pattern a -> Lhs a)
-> Ident -> Pattern a -> Pattern a -> Lhs a
forall a b c. (a -> b -> c) -> b -> a -> c
flip (SpanInfo -> Pattern a -> Ident -> Pattern a -> Lhs a
forall a. SpanInfo -> Pattern a -> Ident -> Pattern a -> Lhs a
OpLhs SpanInfo
sp) Ident
op (Pattern a -> Pattern a -> Lhs a)
-> ReaderT QualEnv Identity (Pattern a)
-> ReaderT QualEnv Identity (Pattern a -> Lhs a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a -> ReaderT QualEnv Identity (Pattern a)
forall a. Qual (Pattern a)
qPattern Pattern a
t1 ReaderT QualEnv Identity (Pattern a -> Lhs a)
-> ReaderT QualEnv Identity (Pattern a)
-> ReaderT QualEnv Identity (Lhs a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Pattern a -> ReaderT QualEnv Identity (Pattern a)
forall a. Qual (Pattern a)
qPattern Pattern a
t2
qLhs (ApLhs sp :: SpanInfo
sp   lhs :: Lhs a
lhs ts :: [Pattern a]
ts) = SpanInfo -> Lhs a -> [Pattern a] -> Lhs a
forall a. SpanInfo -> Lhs a -> [Pattern a] -> Lhs a
ApLhs SpanInfo
sp           (Lhs a -> [Pattern a] -> Lhs a)
-> ReaderT QualEnv Identity (Lhs a)
-> ReaderT QualEnv Identity ([Pattern a] -> Lhs a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Lhs a)
forall a. Qual (Lhs a)
qLhs Lhs a
lhs ReaderT QualEnv Identity ([Pattern a] -> Lhs a)
-> ReaderT QualEnv Identity [Pattern a]
-> ReaderT QualEnv Identity (Lhs a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Pattern a -> ReaderT QualEnv Identity (Pattern a))
-> [Pattern a] -> ReaderT QualEnv Identity [Pattern a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Pattern a -> ReaderT QualEnv Identity (Pattern a)
forall a. Qual (Pattern a)
qPattern [Pattern a]
ts

qPattern :: Qual (Pattern a)
qPattern :: Qual (Pattern a)
qPattern l :: Pattern a
l@(LiteralPattern          _ _ _) = Qual (Pattern a)
forall (m :: * -> *) a. Monad m => a -> m a
return Pattern a
l
qPattern n :: Pattern a
n@(NegativePattern         _ _ _) = Qual (Pattern a)
forall (m :: * -> *) a. Monad m => a -> m a
return Pattern a
n
qPattern v :: Pattern a
v@(VariablePattern         _ _ _) = Qual (Pattern a)
forall (m :: * -> *) a. Monad m => a -> m a
return Pattern a
v
qPattern (ConstructorPattern   spi :: SpanInfo
spi a :: a
a c :: QualIdent
c ts :: [Pattern a]
ts) =
  SpanInfo -> a -> QualIdent -> [Pattern a] -> Pattern a
forall a. SpanInfo -> a -> QualIdent -> [Pattern a] -> Pattern a
ConstructorPattern SpanInfo
spi a
a (QualIdent -> [Pattern a] -> Pattern a)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity ([Pattern a] -> Pattern a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qIdent QualIdent
c ReaderT QualEnv Identity ([Pattern a] -> Pattern a)
-> ReaderT QualEnv Identity [Pattern a]
-> ReaderT QualEnv Identity (Pattern a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Pattern a)
-> [Pattern a] -> ReaderT QualEnv Identity [Pattern a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern [Pattern a]
ts
qPattern (InfixPattern     spi :: SpanInfo
spi a :: a
a t1 :: Pattern a
t1 op :: QualIdent
op t2 :: Pattern a
t2) =
  SpanInfo -> a -> Pattern a -> QualIdent -> Pattern a -> Pattern a
forall a.
SpanInfo -> a -> Pattern a -> QualIdent -> Pattern a -> Pattern a
InfixPattern SpanInfo
spi a
a (Pattern a -> QualIdent -> Pattern a -> Pattern a)
-> ReaderT QualEnv Identity (Pattern a)
-> ReaderT QualEnv Identity (QualIdent -> Pattern a -> Pattern a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern Pattern a
t1 ReaderT QualEnv Identity (QualIdent -> Pattern a -> Pattern a)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity (Pattern a -> Pattern a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual QualIdent
qIdent QualIdent
op ReaderT QualEnv Identity (Pattern a -> Pattern a)
-> ReaderT QualEnv Identity (Pattern a)
-> ReaderT QualEnv Identity (Pattern a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern Pattern a
t2
qPattern (ParenPattern              spi :: SpanInfo
spi t :: Pattern a
t) = SpanInfo -> Pattern a -> Pattern a
forall a. SpanInfo -> Pattern a -> Pattern a
ParenPattern SpanInfo
spi (Pattern a -> Pattern a)
-> ReaderT QualEnv Identity (Pattern a)
-> ReaderT QualEnv Identity (Pattern a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern Pattern a
t
qPattern (RecordPattern        spi :: SpanInfo
spi a :: a
a c :: QualIdent
c fs :: [Field (Pattern a)]
fs) = SpanInfo -> a -> QualIdent -> [Field (Pattern a)] -> Pattern a
forall a.
SpanInfo -> a -> QualIdent -> [Field (Pattern a)] -> Pattern a
RecordPattern SpanInfo
spi a
a (QualIdent -> [Field (Pattern a)] -> Pattern a)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity ([Field (Pattern a)] -> Pattern a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qIdent QualIdent
c
                                          ReaderT QualEnv Identity ([Field (Pattern a)] -> Pattern a)
-> ReaderT QualEnv Identity [Field (Pattern a)]
-> ReaderT QualEnv Identity (Pattern a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Field (Pattern a) -> ReaderT QualEnv Identity (Field (Pattern a)))
-> [Field (Pattern a)]
-> ReaderT QualEnv Identity [Field (Pattern a)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Qual (Pattern a)
-> Field (Pattern a)
-> ReaderT QualEnv Identity (Field (Pattern a))
forall a. Qual a -> Qual (Field a)
qField Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern) [Field (Pattern a)]
fs
qPattern (TuplePattern             spi :: SpanInfo
spi ts :: [Pattern a]
ts) =
  SpanInfo -> [Pattern a] -> Pattern a
forall a. SpanInfo -> [Pattern a] -> Pattern a
TuplePattern SpanInfo
spi ([Pattern a] -> Pattern a)
-> ReaderT QualEnv Identity [Pattern a]
-> ReaderT QualEnv Identity (Pattern a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Pattern a)
-> [Pattern a] -> ReaderT QualEnv Identity [Pattern a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern [Pattern a]
ts
qPattern (ListPattern            spi :: SpanInfo
spi a :: a
a ts :: [Pattern a]
ts) =
  SpanInfo -> a -> [Pattern a] -> Pattern a
forall a. SpanInfo -> a -> [Pattern a] -> Pattern a
ListPattern SpanInfo
spi a
a ([Pattern a] -> Pattern a)
-> ReaderT QualEnv Identity [Pattern a]
-> ReaderT QualEnv Identity (Pattern a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Pattern a)
-> [Pattern a] -> ReaderT QualEnv Identity [Pattern a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern [Pattern a]
ts
qPattern (AsPattern               spi :: SpanInfo
spi v :: Ident
v t :: Pattern a
t) = SpanInfo -> Ident -> Pattern a -> Pattern a
forall a. SpanInfo -> Ident -> Pattern a -> Pattern a
AsPattern SpanInfo
spi Ident
v (Pattern a -> Pattern a)
-> ReaderT QualEnv Identity (Pattern a)
-> ReaderT QualEnv Identity (Pattern a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern Pattern a
t
qPattern (LazyPattern               spi :: SpanInfo
spi t :: Pattern a
t) = SpanInfo -> Pattern a -> Pattern a
forall a. SpanInfo -> Pattern a -> Pattern a
LazyPattern SpanInfo
spi (Pattern a -> Pattern a)
-> ReaderT QualEnv Identity (Pattern a)
-> ReaderT QualEnv Identity (Pattern a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern Pattern a
t
qPattern (FunctionPattern      spi :: SpanInfo
spi a :: a
a f :: QualIdent
f ts :: [Pattern a]
ts) =
  SpanInfo -> a -> QualIdent -> [Pattern a] -> Pattern a
forall a. SpanInfo -> a -> QualIdent -> [Pattern a] -> Pattern a
FunctionPattern SpanInfo
spi a
a (QualIdent -> [Pattern a] -> Pattern a)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity ([Pattern a] -> Pattern a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qIdent QualIdent
f ReaderT QualEnv Identity ([Pattern a] -> Pattern a)
-> ReaderT QualEnv Identity [Pattern a]
-> ReaderT QualEnv Identity (Pattern a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Pattern a)
-> [Pattern a] -> ReaderT QualEnv Identity [Pattern a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern [Pattern a]
ts
qPattern (InfixFuncPattern spi :: SpanInfo
spi a :: a
a t1 :: Pattern a
t1 op :: QualIdent
op t2 :: Pattern a
t2) =
  SpanInfo -> a -> Pattern a -> QualIdent -> Pattern a -> Pattern a
forall a.
SpanInfo -> a -> Pattern a -> QualIdent -> Pattern a -> Pattern a
InfixFuncPattern SpanInfo
spi a
a (Pattern a -> QualIdent -> Pattern a -> Pattern a)
-> ReaderT QualEnv Identity (Pattern a)
-> ReaderT QualEnv Identity (QualIdent -> Pattern a -> Pattern a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern Pattern a
t1 ReaderT QualEnv Identity (QualIdent -> Pattern a -> Pattern a)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity (Pattern a -> Pattern a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual QualIdent
qIdent QualIdent
op ReaderT QualEnv Identity (Pattern a -> Pattern a)
-> ReaderT QualEnv Identity (Pattern a)
-> ReaderT QualEnv Identity (Pattern a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern Pattern a
t2

qRhs :: Qual (Rhs a)
qRhs :: Qual (Rhs a)
qRhs (SimpleRhs spi :: SpanInfo
spi e :: Expression a
e ds :: [Decl a]
ds) =
  SpanInfo -> Expression a -> [Decl a] -> Rhs a
forall a. SpanInfo -> Expression a -> [Decl a] -> Rhs a
SimpleRhs  SpanInfo
spi (Expression a -> [Decl a] -> Rhs a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity ([Decl a] -> Rhs a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e           ReaderT QualEnv Identity ([Decl a] -> Rhs a)
-> ReaderT QualEnv Identity [Decl a]
-> ReaderT QualEnv Identity (Rhs a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Decl a -> ReaderT QualEnv Identity (Decl a))
-> [Decl a] -> ReaderT QualEnv Identity [Decl a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Decl a -> ReaderT QualEnv Identity (Decl a)
forall a. Qual (Decl a)
qDecl [Decl a]
ds
qRhs (GuardedRhs spi :: SpanInfo
spi es :: [CondExpr a]
es ds :: [Decl a]
ds) =
  SpanInfo -> [CondExpr a] -> [Decl a] -> Rhs a
forall a. SpanInfo -> [CondExpr a] -> [Decl a] -> Rhs a
GuardedRhs SpanInfo
spi ([CondExpr a] -> [Decl a] -> Rhs a)
-> ReaderT QualEnv Identity [CondExpr a]
-> ReaderT QualEnv Identity ([Decl a] -> Rhs a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CondExpr a -> ReaderT QualEnv Identity (CondExpr a))
-> [CondExpr a] -> ReaderT QualEnv Identity [CondExpr a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM CondExpr a -> ReaderT QualEnv Identity (CondExpr a)
forall a. Qual (CondExpr a)
qCondExpr [CondExpr a]
es ReaderT QualEnv Identity ([Decl a] -> Rhs a)
-> ReaderT QualEnv Identity [Decl a]
-> ReaderT QualEnv Identity (Rhs a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Decl a -> ReaderT QualEnv Identity (Decl a))
-> [Decl a] -> ReaderT QualEnv Identity [Decl a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Decl a -> ReaderT QualEnv Identity (Decl a)
forall a. Qual (Decl a)
qDecl [Decl a]
ds

qCondExpr :: Qual (CondExpr a)
qCondExpr :: Qual (CondExpr a)
qCondExpr (CondExpr p :: SpanInfo
p g :: Expression a
g e :: Expression a
e) = SpanInfo -> Expression a -> Expression a -> CondExpr a
forall a. SpanInfo -> Expression a -> Expression a -> CondExpr a
CondExpr SpanInfo
p (Expression a -> Expression a -> CondExpr a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a -> CondExpr a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
g ReaderT QualEnv Identity (Expression a -> CondExpr a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (CondExpr a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e

qExpr :: Qual (Expression a)
qExpr :: Qual (Expression a)
qExpr l :: Expression a
l@(Literal             _ _ _) = Qual (Expression a)
forall (m :: * -> *) a. Monad m => a -> m a
return Expression a
l
qExpr (Variable            spi :: SpanInfo
spi a :: a
a v :: QualIdent
v) = SpanInfo -> a -> QualIdent -> Expression a
forall a. SpanInfo -> a -> QualIdent -> Expression a
Variable     SpanInfo
spi a
a (QualIdent -> Expression a)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qIdent QualIdent
v
qExpr (Constructor         spi :: SpanInfo
spi a :: a
a c :: QualIdent
c) = SpanInfo -> a -> QualIdent -> Expression a
forall a. SpanInfo -> a -> QualIdent -> Expression a
Constructor  SpanInfo
spi a
a (QualIdent -> Expression a)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qIdent QualIdent
c
qExpr (Paren                 spi :: SpanInfo
spi e :: Expression a
e) = SpanInfo -> Expression a -> Expression a
forall a. SpanInfo -> Expression a -> Expression a
Paren        SpanInfo
spi   (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e
qExpr (Typed             spi :: SpanInfo
spi e :: Expression a
e qty :: QualTypeExpr
qty) = SpanInfo -> Expression a -> QualTypeExpr -> Expression a
forall a. SpanInfo -> Expression a -> QualTypeExpr -> Expression a
Typed        SpanInfo
spi   (Expression a -> QualTypeExpr -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (QualTypeExpr -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e
                                                         ReaderT QualEnv Identity (QualTypeExpr -> Expression a)
-> ReaderT QualEnv Identity QualTypeExpr
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual QualTypeExpr
qQualTypeExpr QualTypeExpr
qty
qExpr (Record           spi :: SpanInfo
spi a :: a
a c :: QualIdent
c fs :: [Field (Expression a)]
fs) =
  SpanInfo
-> a -> QualIdent -> [Field (Expression a)] -> Expression a
forall a.
SpanInfo
-> a -> QualIdent -> [Field (Expression a)] -> Expression a
Record SpanInfo
spi a
a (QualIdent -> [Field (Expression a)] -> Expression a)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT
     QualEnv Identity ([Field (Expression a)] -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qIdent QualIdent
c ReaderT QualEnv Identity ([Field (Expression a)] -> Expression a)
-> ReaderT QualEnv Identity [Field (Expression a)]
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Field (Expression a)
 -> ReaderT QualEnv Identity (Field (Expression a)))
-> [Field (Expression a)]
-> ReaderT QualEnv Identity [Field (Expression a)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Qual (Expression a)
-> Field (Expression a)
-> ReaderT QualEnv Identity (Field (Expression a))
forall a. Qual a -> Qual (Field a)
qField Qual (Expression a)
forall a. Qual (Expression a)
qExpr) [Field (Expression a)]
fs
qExpr (RecordUpdate       spi :: SpanInfo
spi e :: Expression a
e fs :: [Field (Expression a)]
fs) =
  SpanInfo -> Expression a -> [Field (Expression a)] -> Expression a
forall a.
SpanInfo -> Expression a -> [Field (Expression a)] -> Expression a
RecordUpdate SpanInfo
spi (Expression a -> [Field (Expression a)] -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT
     QualEnv Identity ([Field (Expression a)] -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e ReaderT QualEnv Identity ([Field (Expression a)] -> Expression a)
-> ReaderT QualEnv Identity [Field (Expression a)]
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Field (Expression a)
 -> ReaderT QualEnv Identity (Field (Expression a)))
-> [Field (Expression a)]
-> ReaderT QualEnv Identity [Field (Expression a)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Qual (Expression a)
-> Field (Expression a)
-> ReaderT QualEnv Identity (Field (Expression a))
forall a. Qual a -> Qual (Field a)
qField Qual (Expression a)
forall a. Qual (Expression a)
qExpr) [Field (Expression a)]
fs
qExpr (Tuple                spi :: SpanInfo
spi es :: [Expression a]
es) = SpanInfo -> [Expression a] -> Expression a
forall a. SpanInfo -> [Expression a] -> Expression a
Tuple          SpanInfo
spi ([Expression a] -> Expression a)
-> ReaderT QualEnv Identity [Expression a]
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
-> [Expression a] -> ReaderT QualEnv Identity [Expression a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual (Expression a)
forall a. Qual (Expression a)
qExpr [Expression a]
es
qExpr (List               spi :: SpanInfo
spi a :: a
a es :: [Expression a]
es) = SpanInfo -> a -> [Expression a] -> Expression a
forall a. SpanInfo -> a -> [Expression a] -> Expression a
List           SpanInfo
spi a
a ([Expression a] -> Expression a)
-> ReaderT QualEnv Identity [Expression a]
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
-> [Expression a] -> ReaderT QualEnv Identity [Expression a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Qual (Expression a)
forall a. Qual (Expression a)
qExpr [Expression a]
es
qExpr (ListCompr          spi :: SpanInfo
spi e :: Expression a
e qs :: [Statement a]
qs) = SpanInfo -> Expression a -> [Statement a] -> Expression a
forall a. SpanInfo -> Expression a -> [Statement a] -> Expression a
ListCompr      SpanInfo
spi (Expression a -> [Statement a] -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity ([Statement a] -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e
                                                         ReaderT QualEnv Identity ([Statement a] -> Expression a)
-> ReaderT QualEnv Identity [Statement a]
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Statement a -> ReaderT QualEnv Identity (Statement a))
-> [Statement a] -> ReaderT QualEnv Identity [Statement a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Statement a -> ReaderT QualEnv Identity (Statement a)
forall a. Qual (Statement a)
qStmt [Statement a]
qs
qExpr (EnumFrom              spi :: SpanInfo
spi e :: Expression a
e) = SpanInfo -> Expression a -> Expression a
forall a. SpanInfo -> Expression a -> Expression a
EnumFrom       SpanInfo
spi (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e
qExpr (EnumFromThen      spi :: SpanInfo
spi e1 :: Expression a
e1 e2 :: Expression a
e2) = SpanInfo -> Expression a -> Expression a -> Expression a
forall a. SpanInfo -> Expression a -> Expression a -> Expression a
EnumFromThen   SpanInfo
spi (Expression a -> Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e1
                                                         ReaderT QualEnv Identity (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e2
qExpr (EnumFromTo        spi :: SpanInfo
spi e1 :: Expression a
e1 e2 :: Expression a
e2) = SpanInfo -> Expression a -> Expression a -> Expression a
forall a. SpanInfo -> Expression a -> Expression a -> Expression a
EnumFromTo     SpanInfo
spi (Expression a -> Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e1
                                                         ReaderT QualEnv Identity (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e2
qExpr (EnumFromThenTo spi :: SpanInfo
spi e1 :: Expression a
e1 e2 :: Expression a
e2 e3 :: Expression a
e3) = SpanInfo
-> Expression a -> Expression a -> Expression a -> Expression a
forall a.
SpanInfo
-> Expression a -> Expression a -> Expression a -> Expression a
EnumFromThenTo SpanInfo
spi (Expression a -> Expression a -> Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT
     QualEnv Identity (Expression a -> Expression a -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e1
                                                         ReaderT
  QualEnv Identity (Expression a -> Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a -> Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e2
                                                         ReaderT QualEnv Identity (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e3
qExpr (UnaryMinus            spi :: SpanInfo
spi e :: Expression a
e) = SpanInfo -> Expression a -> Expression a
forall a. SpanInfo -> Expression a -> Expression a
UnaryMinus     SpanInfo
spi (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e
qExpr (Apply             spi :: SpanInfo
spi e1 :: Expression a
e1 e2 :: Expression a
e2) = SpanInfo -> Expression a -> Expression a -> Expression a
forall a. SpanInfo -> Expression a -> Expression a -> Expression a
Apply          SpanInfo
spi (Expression a -> Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e1
                                                         ReaderT QualEnv Identity (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e2
qExpr (InfixApply     spi :: SpanInfo
spi e1 :: Expression a
e1 op :: InfixOp a
op e2 :: Expression a
e2) = SpanInfo
-> Expression a -> InfixOp a -> Expression a -> Expression a
forall a.
SpanInfo
-> Expression a -> InfixOp a -> Expression a -> Expression a
InfixApply     SpanInfo
spi (Expression a -> InfixOp a -> Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT
     QualEnv Identity (InfixOp a -> Expression a -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e1
                                                         ReaderT
  QualEnv Identity (InfixOp a -> Expression a -> Expression a)
-> ReaderT QualEnv Identity (InfixOp a)
-> ReaderT QualEnv Identity (Expression a -> Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (InfixOp a)
forall a. Qual (InfixOp a)
qInfixOp InfixOp a
op
                                                         ReaderT QualEnv Identity (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e2
qExpr (LeftSection        spi :: SpanInfo
spi e :: Expression a
e op :: InfixOp a
op) = SpanInfo -> Expression a -> InfixOp a -> Expression a
forall a. SpanInfo -> Expression a -> InfixOp a -> Expression a
LeftSection  SpanInfo
spi (Expression a -> InfixOp a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (InfixOp a -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e
                                                       ReaderT QualEnv Identity (InfixOp a -> Expression a)
-> ReaderT QualEnv Identity (InfixOp a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (InfixOp a)
forall a. Qual (InfixOp a)
qInfixOp InfixOp a
op
qExpr (RightSection       spi :: SpanInfo
spi op :: InfixOp a
op e :: Expression a
e) = SpanInfo -> InfixOp a -> Expression a -> Expression a
forall a. SpanInfo -> InfixOp a -> Expression a -> Expression a
RightSection SpanInfo
spi (InfixOp a -> Expression a -> Expression a)
-> ReaderT QualEnv Identity (InfixOp a)
-> ReaderT QualEnv Identity (Expression a -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (InfixOp a)
forall a. Qual (InfixOp a)
qInfixOp InfixOp a
op
                                                       ReaderT QualEnv Identity (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e
qExpr (Lambda             spi :: SpanInfo
spi ts :: [Pattern a]
ts e :: Expression a
e) = SpanInfo -> [Pattern a] -> Expression a -> Expression a
forall a. SpanInfo -> [Pattern a] -> Expression a -> Expression a
Lambda       SpanInfo
spi ([Pattern a] -> Expression a -> Expression a)
-> ReaderT QualEnv Identity [Pattern a]
-> ReaderT QualEnv Identity (Expression a -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Pattern a -> ReaderT QualEnv Identity (Pattern a))
-> [Pattern a] -> ReaderT QualEnv Identity [Pattern a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Pattern a -> ReaderT QualEnv Identity (Pattern a)
forall a. Qual (Pattern a)
qPattern [Pattern a]
ts
                                                       ReaderT QualEnv Identity (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e
qExpr (Let                spi :: SpanInfo
spi ds :: [Decl a]
ds e :: Expression a
e) = SpanInfo -> [Decl a] -> Expression a -> Expression a
forall a. SpanInfo -> [Decl a] -> Expression a -> Expression a
Let SpanInfo
spi ([Decl a] -> Expression a -> Expression a)
-> ReaderT QualEnv Identity [Decl a]
-> ReaderT QualEnv Identity (Expression a -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Decl a -> ReaderT QualEnv Identity (Decl a))
-> [Decl a] -> ReaderT QualEnv Identity [Decl a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Decl a -> ReaderT QualEnv Identity (Decl a)
forall a. Qual (Decl a)
qDecl [Decl a]
ds  ReaderT QualEnv Identity (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e
qExpr (Do                spi :: SpanInfo
spi sts :: [Statement a]
sts e :: Expression a
e) = SpanInfo -> [Statement a] -> Expression a -> Expression a
forall a. SpanInfo -> [Statement a] -> Expression a -> Expression a
Do  SpanInfo
spi ([Statement a] -> Expression a -> Expression a)
-> ReaderT QualEnv Identity [Statement a]
-> ReaderT QualEnv Identity (Expression a -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Statement a -> ReaderT QualEnv Identity (Statement a))
-> [Statement a] -> ReaderT QualEnv Identity [Statement a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Statement a -> ReaderT QualEnv Identity (Statement a)
forall a. Qual (Statement a)
qStmt [Statement a]
sts ReaderT QualEnv Identity (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e
qExpr (IfThenElse     spi :: SpanInfo
spi e1 :: Expression a
e1 e2 :: Expression a
e2 e3 :: Expression a
e3) = SpanInfo
-> Expression a -> Expression a -> Expression a -> Expression a
forall a.
SpanInfo
-> Expression a -> Expression a -> Expression a -> Expression a
IfThenElse SpanInfo
spi (Expression a -> Expression a -> Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT
     QualEnv Identity (Expression a -> Expression a -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e1 ReaderT
  QualEnv Identity (Expression a -> Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a -> Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e2
                                                     ReaderT QualEnv Identity (Expression a -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e3
qExpr (Case            spi :: SpanInfo
spi ct :: CaseType
ct e :: Expression a
e as :: [Alt a]
as) = SpanInfo -> CaseType -> Expression a -> [Alt a] -> Expression a
forall a.
SpanInfo -> CaseType -> Expression a -> [Alt a] -> Expression a
Case SpanInfo
spi CaseType
ct   (Expression a -> [Alt a] -> Expression a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity ([Alt a] -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e ReaderT QualEnv Identity ([Alt a] -> Expression a)
-> ReaderT QualEnv Identity [Alt a]
-> ReaderT QualEnv Identity (Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Alt a -> ReaderT QualEnv Identity (Alt a))
-> [Alt a] -> ReaderT QualEnv Identity [Alt a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Alt a -> ReaderT QualEnv Identity (Alt a)
forall a. Qual (Alt a)
qAlt [Alt a]
as

qStmt :: Qual (Statement a)
qStmt :: Qual (Statement a)
qStmt (StmtExpr spi :: SpanInfo
spi   e :: Expression a
e) = SpanInfo -> Expression a -> Statement a
forall a. SpanInfo -> Expression a -> Statement a
StmtExpr SpanInfo
spi (Expression a -> Statement a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Statement a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e
qStmt (StmtBind spi :: SpanInfo
spi t :: Pattern a
t e :: Expression a
e) = SpanInfo -> Pattern a -> Expression a -> Statement a
forall a. SpanInfo -> Pattern a -> Expression a -> Statement a
StmtBind SpanInfo
spi (Pattern a -> Expression a -> Statement a)
-> ReaderT QualEnv Identity (Pattern a)
-> ReaderT QualEnv Identity (Expression a -> Statement a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern Pattern a
t ReaderT QualEnv Identity (Expression a -> Statement a)
-> ReaderT QualEnv Identity (Expression a)
-> ReaderT QualEnv Identity (Statement a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Expression a)
forall a. Qual (Expression a)
qExpr Expression a
e
qStmt (StmtDecl spi :: SpanInfo
spi  ds :: [Decl a]
ds) = SpanInfo -> [Decl a] -> Statement a
forall a. SpanInfo -> [Decl a] -> Statement a
StmtDecl SpanInfo
spi ([Decl a] -> Statement a)
-> ReaderT QualEnv Identity [Decl a]
-> ReaderT QualEnv Identity (Statement a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Decl a -> ReaderT QualEnv Identity (Decl a))
-> [Decl a] -> ReaderT QualEnv Identity [Decl a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Decl a -> ReaderT QualEnv Identity (Decl a)
forall a. Qual (Decl a)
qDecl [Decl a]
ds

qAlt :: Qual (Alt a)
qAlt :: Qual (Alt a)
qAlt (Alt p :: SpanInfo
p t :: Pattern a
t rhs :: Rhs a
rhs) = SpanInfo -> Pattern a -> Rhs a -> Alt a
forall a. SpanInfo -> Pattern a -> Rhs a -> Alt a
Alt SpanInfo
p (Pattern a -> Rhs a -> Alt a)
-> ReaderT QualEnv Identity (Pattern a)
-> ReaderT QualEnv Identity (Rhs a -> Alt a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual (Pattern a)
forall a. Qual (Pattern a)
qPattern Pattern a
t ReaderT QualEnv Identity (Rhs a -> Alt a)
-> ReaderT QualEnv Identity (Rhs a)
-> ReaderT QualEnv Identity (Alt a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual (Rhs a)
forall a. Qual (Rhs a)
qRhs Rhs a
rhs

qField :: Qual a -> Qual (Field a)
qField :: Qual a -> Qual (Field a)
qField q :: Qual a
q (Field p :: SpanInfo
p l :: QualIdent
l x :: a
x) = SpanInfo -> QualIdent -> a -> Field a
forall a. SpanInfo -> QualIdent -> a -> Field a
Field SpanInfo
p (QualIdent -> a -> Field a)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity (a -> Field a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qIdent QualIdent
l ReaderT QualEnv Identity (a -> Field a)
-> ReaderT QualEnv Identity a -> ReaderT QualEnv Identity (Field a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Qual a
q a
x

qInfixOp :: Qual (InfixOp a)
qInfixOp :: Qual (InfixOp a)
qInfixOp (InfixOp     a :: a
a op :: QualIdent
op) = a -> QualIdent -> InfixOp a
forall a. a -> QualIdent -> InfixOp a
InfixOp     a
a (QualIdent -> InfixOp a)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity (InfixOp a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qIdent QualIdent
op
qInfixOp (InfixConstr a :: a
a op :: QualIdent
op) = a -> QualIdent -> InfixOp a
forall a. a -> QualIdent -> InfixOp a
InfixConstr a
a (QualIdent -> InfixOp a)
-> ReaderT QualEnv Identity QualIdent
-> ReaderT QualEnv Identity (InfixOp a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Qual QualIdent
qIdent QualIdent
op

qIdent :: Qual QualIdent
qIdent :: Qual QualIdent
qIdent x :: QualIdent
x | QualIdent -> Bool
isQualified QualIdent
x                = ReaderT QualEnv Identity QualIdent
x'
         | Ident -> Bool
hasGlobalScope (QualIdent -> Ident
unqualify QualIdent
x) = ReaderT QualEnv Identity QualIdent
x'
         | Bool
otherwise                    = Qual QualIdent
forall (m :: * -> *) a. Monad m => a -> m a
return QualIdent
x
  where
  x' :: ReaderT QualEnv Identity QualIdent
x' = do
    ModuleIdent
m     <- (QualEnv -> ModuleIdent) -> ReaderT QualEnv Identity ModuleIdent
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
R.asks QualEnv -> ModuleIdent
moduleIdent
    ValueEnv
tyEnv <- (QualEnv -> ValueEnv) -> ReaderT QualEnv Identity ValueEnv
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
R.asks QualEnv -> ValueEnv
valueEnv
    Qual QualIdent
forall (m :: * -> *) a. Monad m => a -> m a
return Qual QualIdent -> Qual QualIdent
forall a b. (a -> b) -> a -> b
$ case QualIdent -> ValueEnv -> [ValueInfo]
qualLookupValue QualIdent
x ValueEnv
tyEnv of
      [y :: ValueInfo
y] -> ValueInfo -> QualIdent
forall a. Entity a => a -> QualIdent
origName ValueInfo
y
      _   -> case QualIdent -> ValueEnv -> [ValueInfo]
qualLookupValue QualIdent
qmx ValueEnv
tyEnv of
        [y :: ValueInfo
y] -> ValueInfo -> QualIdent
forall a. Entity a => a -> QualIdent
origName ValueInfo
y
        _   -> QualIdent
qmx
        where qmx :: QualIdent
qmx = ModuleIdent -> QualIdent -> QualIdent
qualQualify ModuleIdent
m QualIdent
x

qConstr :: Qual QualIdent
qConstr :: Qual QualIdent
qConstr x :: QualIdent
x = do
  ModuleIdent
m     <- (QualEnv -> ModuleIdent) -> ReaderT QualEnv Identity ModuleIdent
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
R.asks QualEnv -> ModuleIdent
moduleIdent
  TCEnv
tcEnv <- (QualEnv -> TCEnv) -> ReaderT QualEnv Identity TCEnv
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
R.asks QualEnv -> TCEnv
tyConsEnv
  Qual QualIdent
forall (m :: * -> *) a. Monad m => a -> m a
return Qual QualIdent -> Qual QualIdent
forall a b. (a -> b) -> a -> b
$ case QualIdent -> TCEnv -> [TypeInfo]
qualLookupTypeInfo QualIdent
x TCEnv
tcEnv of
    [y :: TypeInfo
y] -> TypeInfo -> QualIdent
forall a. Entity a => a -> QualIdent
origName TypeInfo
y
    _   -> case QualIdent -> TCEnv -> [TypeInfo]
qualLookupTypeInfo QualIdent
qmx TCEnv
tcEnv of
      [y :: TypeInfo
y] -> TypeInfo -> QualIdent
forall a. Entity a => a -> QualIdent
origName TypeInfo
y
      _   -> QualIdent
qmx
      where qmx :: QualIdent
qmx = ModuleIdent -> QualIdent -> QualIdent
qualQualify ModuleIdent
m QualIdent
x

qClass :: Qual QualIdent
qClass :: Qual QualIdent
qClass = Qual QualIdent
qConstr