{-# Language BlockArguments #-}
{-# Language RecordWildCards #-}
{-# Language FlexibleInstances #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveTraversable #-}
module Cryptol.ModuleSystem.Binds
  ( BindsNames
  , TopDef(..)
  , Mod(..)
  , ModKind(..)
  , modNested
  , modBuilder
  , topModuleDefs
  , topDeclsDefs
  , newModParam
  , InModule(..)
  , ifaceToMod
  , ifaceSigToMod
  , modToMap
  , defsOf
  ) where

import Data.Map(Map)
import qualified Data.Map as Map
import Data.Set(Set)
import qualified Data.Set as Set
import Data.Maybe(fromMaybe)
import Control.Monad(foldM)
import qualified MonadLib as M

import Cryptol.Utils.Panic (panic)
import Cryptol.Utils.Ident(allNamespaces)
import Cryptol.Parser.Position
import Cryptol.Parser.Name(isGeneratedName)
import Cryptol.Parser.AST
import Cryptol.ModuleSystem.Exports(exportedDecls,exported)
import Cryptol.ModuleSystem.Renamer.Error
import Cryptol.ModuleSystem.Name
import Cryptol.ModuleSystem.Names
import Cryptol.ModuleSystem.NamingEnv
import Cryptol.ModuleSystem.Interface
import Cryptol.TypeCheck.Type(ModParamNames(..))



data TopDef = TopMod ModName (Mod ())
            | TopInst ModName (ImpName PName) (ModuleInstanceArgs PName)

-- | Things defined by a module
data Mod a = Mod
  { forall a. Mod a -> [ImportG (ImpName PName)]
modImports   :: [ ImportG (ImpName PName) ]
  , forall a. Mod a -> ModKind
modKind      :: ModKind
  , forall a.
Mod a -> Map Name (ImpName PName, ModuleInstanceArgs PName)
modInstances :: Map Name (ImpName PName, ModuleInstanceArgs PName)
  , forall a. Mod a -> Map Name (Mod a)
modMods      :: Map Name (Mod a) -- ^ this includes signatures

  , forall a. Mod a -> NamingEnv
modDefines   :: NamingEnv
    {- ^ Things defined by this module.  Note the for normal modules we
    really just need the public names, however for things within
    functors we need all defined names, so that we can generate fresh
    names in instantiations -}

  , forall a. Mod a -> Set Name
modPublic    :: !(Set Name)
    -- ^ These are the exported names

  , forall a. Mod a -> a
modState     :: a
    {- ^ Used in the import loop to track the current state of processing.
         The reason this is here, rather than just having a pair in the
         other algorithm is because this type is recursive (for nested modules)
         and it is conveninet to keep track for all modules at once -}
  }

modNested :: Mod a -> Set Name
modNested :: forall a. Mod a -> Set Name
modNested Mod a
m = forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions [ forall k a. Map k a -> Set k
Map.keysSet (forall a.
Mod a -> Map Name (ImpName PName, ModuleInstanceArgs PName)
modInstances Mod a
m)
                         , forall k a. Map k a -> Set k
Map.keysSet (forall a. Mod a -> Map Name (Mod a)
modMods Mod a
m)
                         ]

instance Functor Mod where
  fmap :: forall a b. (a -> b) -> Mod a -> Mod b
fmap a -> b
f Mod a
m = Mod a
m { modState :: b
modState = a -> b
f (forall a. Mod a -> a
modState Mod a
m)
               , modMods :: Map Name (Mod b)
modMods  = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Mod a -> Map Name (Mod a)
modMods Mod a
m
               }

-- | Generate a map from this module and all modules nested in it.
modToMap ::
  ImpName Name -> Mod () ->
  Map (ImpName Name) (Mod ()) -> Map (ImpName Name) (Mod ())
modToMap :: ImpName Name
-> Mod ()
-> Map (ImpName Name) (Mod ())
-> Map (ImpName Name) (Mod ())
modToMap ImpName Name
x Mod ()
m Map (ImpName Name) (Mod ())
mp = forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ImpName Name
x Mod ()
m (forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
Map.foldrWithKey Name
-> Mod ()
-> Map (ImpName Name) (Mod ())
-> Map (ImpName Name) (Mod ())
add Map (ImpName Name) (Mod ())
mp (forall a. Mod a -> Map Name (Mod a)
modMods Mod ()
m))
  where
  add :: Name
-> Mod ()
-> Map (ImpName Name) (Mod ())
-> Map (ImpName Name) (Mod ())
add Name
n = ImpName Name
-> Mod ()
-> Map (ImpName Name) (Mod ())
-> Map (ImpName Name) (Mod ())
modToMap (forall name. name -> ImpName name
ImpNested Name
n)

-- | Make a `Mod` from the public declarations in an interface.
-- This is used to handle imports.
ifaceToMod :: IfaceG name -> Mod ()
ifaceToMod :: forall name. IfaceG name -> Mod ()
ifaceToMod IfaceG name
iface = forall topname name.
IfaceG topname -> Bool -> IfaceNames name -> Mod ()
ifaceNamesToMod IfaceG name
iface (forall name. IfaceG name -> Bool
ifaceIsFunctor IfaceG name
iface) (forall name. IfaceG name -> IfaceNames name
ifNames IfaceG name
iface)

ifaceNamesToMod :: IfaceG topname -> Bool -> IfaceNames name -> Mod ()
ifaceNamesToMod :: forall topname name.
IfaceG topname -> Bool -> IfaceNames name -> Mod ()
ifaceNamesToMod IfaceG topname
iface Bool
params IfaceNames name
names =
  Mod
    { modKind :: ModKind
modKind    = if Bool
params then ModKind
AFunctor else ModKind
AModule
    , modMods :: Map Name (Mod ())
modMods    = (forall topname name.
IfaceG topname -> Bool -> IfaceNames name -> Mod ()
ifaceNamesToMod IfaceG topname
iface Bool
False forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IfaceDecls -> Map Name (IfaceNames Name)
ifModules IfaceDecls
decls)
                   forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union`
                   (forall name. IfaceG name -> Mod ()
ifaceToMod forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IfaceDecls -> Map Name (IfaceG Name)
ifFunctors IfaceDecls
decls)
                   forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union`
                   (ModParamNames -> Mod ()
ifaceSigToMod forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IfaceDecls -> Map Name ModParamNames
ifSignatures IfaceDecls
decls)
    , modDefines :: NamingEnv
modDefines = Set Name -> NamingEnv
namingEnvFromNames Set Name
defs
    , modPublic :: Set Name
modPublic  = forall name. IfaceNames name -> Set Name
ifsPublic IfaceNames name
names

    , modImports :: [ImportG (ImpName PName)]
modImports   = []
    , modInstances :: Map Name (ImpName PName, ModuleInstanceArgs PName)
modInstances = forall a. Monoid a => a
mempty
    , modState :: ()
modState     = ()
    }
  where
  defs :: Set Name
defs      = forall name. IfaceNames name -> Set Name
ifsDefines IfaceNames name
names
  isLocal :: Name -> Bool
isLocal Name
x = Name
x forall a. Ord a => a -> Set a -> Bool
`Set.member` Set Name
defs
  decls :: IfaceDecls
decls     = (Name -> Bool) -> IfaceDecls -> IfaceDecls
filterIfaceDecls Name -> Bool
isLocal (forall name. IfaceG name -> IfaceDecls
ifDefines IfaceG topname
iface)


ifaceSigToMod :: ModParamNames -> Mod ()
ifaceSigToMod :: ModParamNames -> Mod ()
ifaceSigToMod ModParamNames
ps = Mod
  { modImports :: [ImportG (ImpName PName)]
modImports   = []
  , modKind :: ModKind
modKind      = ModKind
ASignature
  , modInstances :: Map Name (ImpName PName, ModuleInstanceArgs PName)
modInstances = forall a. Monoid a => a
mempty
  , modMods :: Map Name (Mod ())
modMods      = forall a. Monoid a => a
mempty
  , modDefines :: NamingEnv
modDefines   = NamingEnv
env
  , modPublic :: Set Name
modPublic    = NamingEnv -> Set Name
namingEnvNames NamingEnv
env
  , modState :: ()
modState     = ()
  }
  where
  env :: NamingEnv
env = ModParamNames -> NamingEnv
modParamsNamingEnv ModParamNames
ps






type ModBuilder = SupplyT (M.StateT [RenamerError] M.Id)

modBuilder :: ModBuilder a -> Supply -> ((a, [RenamerError]),Supply)
modBuilder :: forall a. ModBuilder a -> Supply -> ((a, [RenamerError]), Supply)
modBuilder ModBuilder a
m Supply
s = ((a
a,[RenamerError]
errs),Supply
s1)
  where ((a
a,Supply
s1),[RenamerError]
errs) = forall a. Id a -> a
M.runId (forall i (m :: * -> *) a. i -> StateT i m a -> m (a, i)
M.runStateT [] (forall (m :: * -> *) a.
Monad m =>
Supply -> SupplyT m a -> m (a, Supply)
runSupplyT Supply
s ModBuilder a
m))

defErr :: RenamerError -> ModBuilder ()
defErr :: RenamerError -> ModBuilder ()
defErr RenamerError
a = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadT t, Monad m) =>
m a -> t m a
M.lift (forall (m :: * -> *) s. StateM m s => (s -> s) -> m ()
M.sets_ (RenamerError
aforall a. a -> [a] -> [a]
:))

defNames :: BuildNamingEnv -> ModBuilder NamingEnv
defNames :: BuildNamingEnv -> ModBuilder NamingEnv
defNames BuildNamingEnv
b = forall (m :: * -> *) a. FreshM m => (Supply -> (a, Supply)) -> m a
liftSupply \Supply
s -> forall a. Id a -> a
M.runId (forall (m :: * -> *) a.
Monad m =>
Supply -> SupplyT m a -> m (a, Supply)
runSupplyT Supply
s (BuildNamingEnv -> SupplyT Id NamingEnv
runBuild BuildNamingEnv
b))


topModuleDefs :: Module PName -> ModBuilder TopDef
topModuleDefs :: Module PName -> ModBuilder TopDef
topModuleDefs Module PName
m =
  case forall mname name. ModuleG mname name -> ModuleDefinition name
mDef Module PName
m of
    NormalModule [TopDecl PName]
ds -> ModName -> Mod () -> TopDef
TopMod ModName
mname forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ModPath -> [TopDecl PName] -> ModBuilder (Mod ())
declsToMod (forall a. a -> Maybe a
Just (ModName -> ModPath
TopModule ModName
mname)) [TopDecl PName]
ds
    FunctorInstance Located (ImpName PName)
f ModuleInstanceArgs PName
as ModuleInstance PName
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure (ModName -> ImpName PName -> ModuleInstanceArgs PName -> TopDef
TopInst ModName
mname (forall a. Located a -> a
thing Located (ImpName PName)
f) ModuleInstanceArgs PName
as)
    InterfaceModule Signature PName
s -> ModName -> Mod () -> TopDef
TopMod ModName
mname forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ModPath -> Signature PName -> ModBuilder (Mod ())
sigToMod (ModName -> ModPath
TopModule ModName
mname) Signature PName
s
  where
  mname :: ModName
mname = forall a. Located a -> a
thing (forall mname name. ModuleG mname name -> Located mname
mName Module PName
m)

topDeclsDefs :: ModPath -> [TopDecl PName] -> ModBuilder (Mod ())
topDeclsDefs :: ModPath -> [TopDecl PName] -> ModBuilder (Mod ())
topDeclsDefs = Maybe ModPath -> [TopDecl PName] -> ModBuilder (Mod ())
declsToMod forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just

sigToMod :: ModPath -> Signature PName -> ModBuilder (Mod ())
sigToMod :: ModPath -> Signature PName -> ModBuilder (Mod ())
sigToMod ModPath
mp Signature PName
sig =
  do NamingEnv
env <- BuildNamingEnv -> ModBuilder NamingEnv
defNames (ModPath -> Signature PName -> BuildNamingEnv
signatureDefs ModPath
mp Signature PName
sig)
     forall (f :: * -> *) a. Applicative f => a -> f a
pure Mod { modImports :: [ImportG (ImpName PName)]
modImports   = forall a b. (a -> b) -> [a] -> [b]
map forall a. Located a -> a
thing (forall name. Signature name -> [Located (ImportG (ImpName name))]
sigImports Signature PName
sig)
              , modKind :: ModKind
modKind      = ModKind
ASignature
              , modInstances :: Map Name (ImpName PName, ModuleInstanceArgs PName)
modInstances = forall a. Monoid a => a
mempty
              , modMods :: Map Name (Mod ())
modMods      = forall a. Monoid a => a
mempty
              , modDefines :: NamingEnv
modDefines   = NamingEnv
env
              , modPublic :: Set Name
modPublic    = NamingEnv -> Set Name
namingEnvNames NamingEnv
env
              , modState :: ()
modState     = ()
              }



declsToMod :: Maybe ModPath -> [TopDecl PName] -> ModBuilder (Mod ())
declsToMod :: Maybe ModPath -> [TopDecl PName] -> ModBuilder (Mod ())
declsToMod Maybe ModPath
mbPath [TopDecl PName]
ds =
  do NamingEnv
defs <- BuildNamingEnv -> ModBuilder NamingEnv
defNames (forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (forall a. BindsNames a => a -> BuildNamingEnv
namingEnv forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Maybe ModPath -> a -> InModule a
InModule Maybe ModPath
mbPath) [TopDecl PName]
ds)
     let expSpec :: ExportSpec PName
expSpec = forall name. Ord name => [TopDecl name] -> ExportSpec name
exportedDecls [TopDecl PName]
ds
     let pub :: Set Name
pub     = forall a. Ord a => [a] -> Set a
Set.fromList
                     [ Name
name
                     | Namespace
ns    <- [Namespace]
allNamespaces
                     , PName
pname <- forall a. Set a -> [a]
Set.toList (forall name. Namespace -> ExportSpec name -> Set name
exported Namespace
ns ExportSpec PName
expSpec)
                     , Name
name  <- Namespace -> PName -> NamingEnv -> [Name]
lookupListNS Namespace
ns PName
pname NamingEnv
defs
                     ]

     case NamingEnv -> [[Name]]
findAmbig NamingEnv
defs of
       bad :: [Name]
bad@(Name
_ : [Name]
_) : [[Name]]
_ ->
         -- defErr (MultipleDefinitions mbPath (nameIdent f) (map nameLoc bad))
         RenamerError -> ModBuilder ()
defErr ([Name] -> RenamerError
OverlappingSyms [Name]
bad)
       [[Name]]
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

     let mo :: Mod ()
mo = Mod { modImports :: [ImportG (ImpName PName)]
modImports      = [ forall a. Located a -> a
thing Located (ImportG (ImpName PName))
i | DImport Located (ImportG (ImpName PName))
i <- [TopDecl PName]
ds ]
                  , modKind :: ModKind
modKind         = if forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any forall a. TopDecl a -> Bool
isParamDecl [TopDecl PName]
ds
                                         then ModKind
AFunctor else ModKind
AModule
                  , modInstances :: Map Name (ImpName PName, ModuleInstanceArgs PName)
modInstances    = forall a. Monoid a => a
mempty
                  , modMods :: Map Name (Mod ())
modMods         = forall a. Monoid a => a
mempty
                  , modDefines :: NamingEnv
modDefines      = NamingEnv
defs
                  , modPublic :: Set Name
modPublic       = Set Name
pub
                  , modState :: ()
modState        = ()
                  }

     forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM (NamingEnv -> Mod () -> TopDecl PName -> ModBuilder (Mod ())
checkNest NamingEnv
defs) Mod ()
mo [TopDecl PName]
ds

  where
  checkNest :: NamingEnv -> Mod () -> TopDecl PName -> ModBuilder (Mod ())
checkNest NamingEnv
defs Mod ()
mo TopDecl PName
d =
    case TopDecl PName
d of
      DModule TopLevel (NestedModule PName)
tl ->
        do let NestedModule ModuleG PName PName
nmod = forall a. TopLevel a -> a
tlValue TopLevel (NestedModule PName)
tl
               pname :: PName
pname = forall a. Located a -> a
thing (forall mname name. ModuleG mname name -> Located mname
mName ModuleG PName PName
nmod)
               name :: Name
name  = case Namespace -> PName -> NamingEnv -> Maybe Names
lookupNS Namespace
NSModule PName
pname NamingEnv
defs of
                         Just Names
xs -> Names -> Name
anyOne Names
xs
                         Maybe Names
_ -> forall a. HasCallStack => String -> [String] -> a
panic String
"declsToMod" [String
"undefined name", forall a. Show a => a -> String
show PName
pname]
           case Maybe ModPath
mbPath of
             Maybe ModPath
Nothing ->
               do RenamerError -> ModBuilder ()
defErr (Range -> PName -> RenamerError
UnexpectedNest (forall a. Located a -> Range
srcRange (forall mname name. ModuleG mname name -> Located mname
mName ModuleG PName PName
nmod)) PName
pname)
                  forall (f :: * -> *) a. Applicative f => a -> f a
pure Mod ()
mo
             Just ModPath
path ->
                case forall mname name. ModuleG mname name -> ModuleDefinition name
mDef ModuleG PName PName
nmod of

                   NormalModule [TopDecl PName]
xs ->
                     do Mod ()
m <- Maybe ModPath -> [TopDecl PName] -> ModBuilder (Mod ())
declsToMod (forall a. a -> Maybe a
Just (ModPath -> Ident -> ModPath
Nested ModPath
path (Name -> Ident
nameIdent Name
name))) [TopDecl PName]
xs
                        forall (f :: * -> *) a. Applicative f => a -> f a
pure Mod ()
mo { modMods :: Map Name (Mod ())
modMods = forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Name
name Mod ()
m (forall a. Mod a -> Map Name (Mod a)
modMods Mod ()
mo) }

                   FunctorInstance Located (ImpName PName)
f ModuleInstanceArgs PName
args ModuleInstance PName
_ ->
                      forall (f :: * -> *) a. Applicative f => a -> f a
pure Mod ()
mo { modInstances :: Map Name (ImpName PName, ModuleInstanceArgs PName)
modInstances = forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Name
name (forall a. Located a -> a
thing Located (ImpName PName)
f, ModuleInstanceArgs PName
args)
                                                    (forall a.
Mod a -> Map Name (ImpName PName, ModuleInstanceArgs PName)
modInstances Mod ()
mo) }

                   InterfaceModule Signature PName
sig ->
                      do Mod ()
m <- ModPath -> Signature PName -> ModBuilder (Mod ())
sigToMod (ModPath -> Ident -> ModPath
Nested ModPath
path (Name -> Ident
nameIdent Name
name)) Signature PName
sig
                         forall (f :: * -> *) a. Applicative f => a -> f a
pure Mod ()
mo { modMods :: Map Name (Mod ())
modMods = forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Name
name Mod ()
m (forall a. Mod a -> Map Name (Mod a)
modMods Mod ()
mo) }


      TopDecl PName
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Mod ()
mo



-- | These are the names "owned" by the signature.  These names are
-- used when resolving the signature.  They are also used to figure out what
-- names to instantuate when the signature is used.
signatureDefs :: ModPath -> Signature PName -> BuildNamingEnv
signatureDefs :: ModPath -> Signature PName -> BuildNamingEnv
signatureDefs ModPath
m Signature PName
sig =
     forall a. Monoid a => [a] -> a
mconcat [ forall a. BindsNames a => a -> BuildNamingEnv
namingEnv (forall a. Maybe ModPath -> a -> InModule a
InModule Maybe ModPath
loc ParameterType PName
p) | ParameterType PName
p <- forall name. Signature name -> [ParameterType name]
sigTypeParams Signature PName
sig ]
  forall a. Semigroup a => a -> a -> a
<> forall a. Monoid a => [a] -> a
mconcat [ forall a. BindsNames a => a -> BuildNamingEnv
namingEnv (forall a. Maybe ModPath -> a -> InModule a
InModule Maybe ModPath
loc ParameterFun PName
p) | ParameterFun PName
p <- forall name. Signature name -> [ParameterFun name]
sigFunParams Signature PName
sig ]
  forall a. Semigroup a => a -> a -> a
<> forall a. Monoid a => [a] -> a
mconcat [ forall a. BindsNames a => a -> BuildNamingEnv
namingEnv (forall a. Maybe ModPath -> a -> InModule a
InModule Maybe ModPath
loc SigDecl PName
p) | SigDecl PName
p <- forall name. Signature name -> [SigDecl name]
sigDecls Signature PName
sig ]
  where
  loc :: Maybe ModPath
loc = forall a. a -> Maybe a
Just ModPath
m
--------------------------------------------------------------------------------




--------------------------------------------------------------------------------
-- Computes the names introduced by various declarations.

-- | Things that define exported names.
class BindsNames a where
  namingEnv :: a -> BuildNamingEnv

newtype BuildNamingEnv = BuildNamingEnv { BuildNamingEnv -> SupplyT Id NamingEnv
runBuild :: SupplyT M.Id NamingEnv }

buildNamingEnv :: BuildNamingEnv -> Supply -> (NamingEnv,Supply)
buildNamingEnv :: BuildNamingEnv -> Supply -> (NamingEnv, Supply)
buildNamingEnv BuildNamingEnv
b Supply
supply = forall a. Id a -> a
M.runId forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
Supply -> SupplyT m a -> m (a, Supply)
runSupplyT Supply
supply forall a b. (a -> b) -> a -> b
$ BuildNamingEnv -> SupplyT Id NamingEnv
runBuild BuildNamingEnv
b

-- | Generate a 'NamingEnv' using an explicit supply.
defsOf :: BindsNames a => a -> Supply -> (NamingEnv,Supply)
defsOf :: forall a. BindsNames a => a -> Supply -> (NamingEnv, Supply)
defsOf = BuildNamingEnv -> Supply -> (NamingEnv, Supply)
buildNamingEnv forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. BindsNames a => a -> BuildNamingEnv
namingEnv

instance Semigroup BuildNamingEnv where
  BuildNamingEnv SupplyT Id NamingEnv
a <> :: BuildNamingEnv -> BuildNamingEnv -> BuildNamingEnv
<> BuildNamingEnv SupplyT Id NamingEnv
b = SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv forall a b. (a -> b) -> a -> b
$
    do NamingEnv
x <- SupplyT Id NamingEnv
a
       NamingEnv
y <- SupplyT Id NamingEnv
b
       forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. Monoid a => a -> a -> a
mappend NamingEnv
x NamingEnv
y)

instance Monoid BuildNamingEnv where
  mempty :: BuildNamingEnv
mempty = SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Monoid a => a
mempty)

  mappend :: BuildNamingEnv -> BuildNamingEnv -> BuildNamingEnv
mappend = forall a. Semigroup a => a -> a -> a
(<>)

  mconcat :: [BuildNamingEnv] -> BuildNamingEnv
mconcat [BuildNamingEnv]
bs = SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv forall a b. (a -> b) -> a -> b
$
    do [NamingEnv]
ns <- forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence (forall a b. (a -> b) -> [a] -> [b]
map BuildNamingEnv -> SupplyT Id NamingEnv
runBuild [BuildNamingEnv]
bs)
       forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. Monoid a => [a] -> a
mconcat [NamingEnv]
ns)

instance BindsNames NamingEnv where
  namingEnv :: NamingEnv -> BuildNamingEnv
namingEnv NamingEnv
env = SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv (forall (m :: * -> *) a. Monad m => a -> m a
return NamingEnv
env)
  {-# INLINE namingEnv #-}

instance BindsNames a => BindsNames (Maybe a) where
  namingEnv :: Maybe a -> BuildNamingEnv
namingEnv = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall a. BindsNames a => a -> BuildNamingEnv
namingEnv
  {-# INLINE namingEnv #-}

instance BindsNames a => BindsNames [a] where
  namingEnv :: [a] -> BuildNamingEnv
namingEnv = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall a. BindsNames a => a -> BuildNamingEnv
namingEnv
  {-# INLINE namingEnv #-}

-- | Generate a type renaming environment from the parameters that are bound by
-- this schema.
instance BindsNames (Schema PName) where
  namingEnv :: Schema PName -> BuildNamingEnv
namingEnv (Forall [TParam PName]
ps [Prop PName]
_ Type PName
_ Maybe Range
_) = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall a. BindsNames a => a -> BuildNamingEnv
namingEnv [TParam PName]
ps
  {-# INLINE namingEnv #-}



-- | Introduce the name
instance BindsNames (InModule (Bind PName)) where
  namingEnv :: InModule (Bind PName) -> BuildNamingEnv
namingEnv (InModule Maybe ModPath
mb Bind PName
b) = SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv forall a b. (a -> b) -> a -> b
$
    do let Located { Range
PName
thing :: PName
srcRange :: Range
srcRange :: forall a. Located a -> Range
thing :: forall a. Located a -> a
.. } = forall name. Bind name -> Located name
bName Bind PName
b
       Name
n <- case Maybe ModPath
mb of
              Just ModPath
m  -> forall (m :: * -> *).
FreshM m =>
Namespace -> ModPath -> PName -> Maybe Fixity -> Range -> m Name
newTop Namespace
NSValue ModPath
m PName
thing (forall name. Bind name -> Maybe Fixity
bFixity Bind PName
b) Range
srcRange
              Maybe ModPath
Nothing -> forall (m :: * -> *).
FreshM m =>
Namespace -> PName -> Range -> m Name
newLocal Namespace
NSValue PName
thing Range
srcRange -- local fixitiies?

       forall (m :: * -> *) a. Monad m => a -> m a
return (Namespace -> PName -> Name -> NamingEnv
singletonNS Namespace
NSValue PName
thing Name
n)

-- | Generate the naming environment for a type parameter.
instance BindsNames (TParam PName) where
  namingEnv :: TParam PName -> BuildNamingEnv
namingEnv TParam { Maybe Range
Maybe Kind
PName
tpRange :: forall n. TParam n -> Maybe Range
tpKind :: forall n. TParam n -> Maybe Kind
tpName :: forall n. TParam n -> n
tpRange :: Maybe Range
tpKind :: Maybe Kind
tpName :: PName
.. } = SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv forall a b. (a -> b) -> a -> b
$
    do let range :: Range
range = forall a. a -> Maybe a -> a
fromMaybe Range
emptyRange Maybe Range
tpRange
       Name
n <- forall (m :: * -> *).
FreshM m =>
Namespace -> PName -> Range -> m Name
newLocal Namespace
NSType PName
tpName Range
range
       forall (m :: * -> *) a. Monad m => a -> m a
return (Namespace -> PName -> Name -> NamingEnv
singletonNS Namespace
NSType PName
tpName Name
n)


instance BindsNames (InModule (TopDecl PName)) where
  namingEnv :: InModule (TopDecl PName) -> BuildNamingEnv
namingEnv (InModule Maybe ModPath
ns TopDecl PName
td) =
    case TopDecl PName
td of
      Decl TopLevel (Decl PName)
d           -> forall a. BindsNames a => a -> BuildNamingEnv
namingEnv (forall a. Maybe ModPath -> a -> InModule a
InModule Maybe ModPath
ns (forall a. TopLevel a -> a
tlValue TopLevel (Decl PName)
d))
      DPrimType TopLevel (PrimType PName)
d      -> forall a. BindsNames a => a -> BuildNamingEnv
namingEnv (forall a. Maybe ModPath -> a -> InModule a
InModule Maybe ModPath
ns (forall a. TopLevel a -> a
tlValue TopLevel (PrimType PName)
d))
      TDNewtype TopLevel (Newtype PName)
d      -> forall a. BindsNames a => a -> BuildNamingEnv
namingEnv (forall a. Maybe ModPath -> a -> InModule a
InModule Maybe ModPath
ns (forall a. TopLevel a -> a
tlValue TopLevel (Newtype PName)
d))
      DParamDecl {}    -> forall a. Monoid a => a
mempty
      Include Located String
_        -> forall a. Monoid a => a
mempty
      DImport {}       -> forall a. Monoid a => a
mempty -- see 'openLoop' in the renamer
      DModule TopLevel (NestedModule PName)
m        -> forall a. BindsNames a => a -> BuildNamingEnv
namingEnv (forall a. Maybe ModPath -> a -> InModule a
InModule Maybe ModPath
ns (forall a. TopLevel a -> a
tlValue TopLevel (NestedModule PName)
m))
      DModParam {}     -> forall a. Monoid a => a
mempty -- shouldn't happen
      DInterfaceConstraint {} -> forall a. Monoid a => a
mempty
        -- handled in the renamer as we need to resolve
        -- the signature name first (similar to import)


instance BindsNames (InModule (NestedModule PName)) where
  namingEnv :: InModule (NestedModule PName) -> BuildNamingEnv
namingEnv (InModule ~(Just ModPath
m) (NestedModule ModuleG PName PName
mdef)) = SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv forall a b. (a -> b) -> a -> b
$
    do let pnmame :: Located PName
pnmame = forall mname name. ModuleG mname name -> Located mname
mName ModuleG PName PName
mdef
       Name
nm   <- forall (m :: * -> *).
FreshM m =>
Namespace -> ModPath -> PName -> Maybe Fixity -> Range -> m Name
newTop Namespace
NSModule ModPath
m (forall a. Located a -> a
thing Located PName
pnmame) forall a. Maybe a
Nothing (forall a. Located a -> Range
srcRange Located PName
pnmame)
       forall (f :: * -> *) a. Applicative f => a -> f a
pure (Namespace -> PName -> Name -> NamingEnv
singletonNS Namespace
NSModule (forall a. Located a -> a
thing Located PName
pnmame) Name
nm)

instance BindsNames (InModule (PrimType PName)) where
  namingEnv :: InModule (PrimType PName) -> BuildNamingEnv
namingEnv (InModule ~(Just ModPath
m) PrimType { Maybe Fixity
([TParam PName], [Prop PName])
Located PName
Located Kind
primTFixity :: forall name. PrimType name -> Maybe Fixity
primTCts :: forall name. PrimType name -> ([TParam name], [Prop name])
primTKind :: forall name. PrimType name -> Located Kind
primTName :: forall name. PrimType name -> Located name
primTFixity :: Maybe Fixity
primTCts :: ([TParam PName], [Prop PName])
primTKind :: Located Kind
primTName :: Located PName
.. }) =
    SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv forall a b. (a -> b) -> a -> b
$
      do let Located { Range
PName
thing :: PName
srcRange :: Range
srcRange :: forall a. Located a -> Range
thing :: forall a. Located a -> a
.. } = Located PName
primTName
         Name
nm <- forall (m :: * -> *).
FreshM m =>
Namespace -> ModPath -> PName -> Maybe Fixity -> Range -> m Name
newTop Namespace
NSType ModPath
m PName
thing Maybe Fixity
primTFixity Range
srcRange
         forall (f :: * -> *) a. Applicative f => a -> f a
pure (Namespace -> PName -> Name -> NamingEnv
singletonNS Namespace
NSType PName
thing Name
nm)

instance BindsNames (InModule (ParameterFun PName)) where
  namingEnv :: InModule (ParameterFun PName) -> BuildNamingEnv
namingEnv (InModule ~(Just ModPath
ns) ParameterFun { Maybe Text
Maybe Fixity
Located PName
Schema PName
pfFixity :: forall name. ParameterFun name -> Maybe Fixity
pfDoc :: forall name. ParameterFun name -> Maybe Text
pfSchema :: forall name. ParameterFun name -> Schema name
pfName :: forall name. ParameterFun name -> Located name
pfFixity :: Maybe Fixity
pfDoc :: Maybe Text
pfSchema :: Schema PName
pfName :: Located PName
.. }) = SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv forall a b. (a -> b) -> a -> b
$
    do let Located { Range
PName
thing :: PName
srcRange :: Range
srcRange :: forall a. Located a -> Range
thing :: forall a. Located a -> a
.. } = Located PName
pfName
       Name
ntName <- forall (m :: * -> *).
FreshM m =>
Namespace -> ModPath -> PName -> Maybe Fixity -> Range -> m Name
newTop Namespace
NSValue ModPath
ns PName
thing Maybe Fixity
pfFixity Range
srcRange
       forall (m :: * -> *) a. Monad m => a -> m a
return (Namespace -> PName -> Name -> NamingEnv
singletonNS Namespace
NSValue PName
thing Name
ntName)

instance BindsNames (InModule (ParameterType PName)) where
  namingEnv :: InModule (ParameterType PName) -> BuildNamingEnv
namingEnv (InModule ~(Just ModPath
ns) ParameterType { Int
Maybe Text
Maybe Fixity
Located PName
Kind
ptNumber :: forall name. ParameterType name -> Int
ptFixity :: forall name. ParameterType name -> Maybe Fixity
ptDoc :: forall name. ParameterType name -> Maybe Text
ptKind :: forall name. ParameterType name -> Kind
ptName :: forall name. ParameterType name -> Located name
ptNumber :: Int
ptFixity :: Maybe Fixity
ptDoc :: Maybe Text
ptKind :: Kind
ptName :: Located PName
.. }) = SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv forall a b. (a -> b) -> a -> b
$
    -- XXX: we don't seem to have a fixity environment at the type level
    do let Located { Range
PName
thing :: PName
srcRange :: Range
srcRange :: forall a. Located a -> Range
thing :: forall a. Located a -> a
.. } = Located PName
ptName
       Name
ntName <- forall (m :: * -> *).
FreshM m =>
Namespace -> ModPath -> PName -> Maybe Fixity -> Range -> m Name
newTop Namespace
NSType ModPath
ns PName
thing forall a. Maybe a
Nothing Range
srcRange
       forall (m :: * -> *) a. Monad m => a -> m a
return (Namespace -> PName -> Name -> NamingEnv
singletonNS Namespace
NSType PName
thing Name
ntName)

instance BindsNames (InModule (Newtype PName)) where
  namingEnv :: InModule (Newtype PName) -> BuildNamingEnv
namingEnv (InModule ~(Just ModPath
ns) Newtype { [TParam PName]
Located PName
PName
Rec (Type PName)
nBody :: forall name. Newtype name -> Rec (Type name)
nConName :: forall name. Newtype name -> name
nParams :: forall name. Newtype name -> [TParam name]
nName :: forall name. Newtype name -> Located name
nBody :: Rec (Type PName)
nConName :: PName
nParams :: [TParam PName]
nName :: Located PName
.. }) = SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv forall a b. (a -> b) -> a -> b
$
    do let Located { Range
PName
thing :: PName
srcRange :: Range
srcRange :: forall a. Located a -> Range
thing :: forall a. Located a -> a
.. } = Located PName
nName
       Name
ntName    <- forall (m :: * -> *).
FreshM m =>
Namespace -> ModPath -> PName -> Maybe Fixity -> Range -> m Name
newTop Namespace
NSType  ModPath
ns PName
thing forall a. Maybe a
Nothing Range
srcRange
       Name
ntConName <- forall (m :: * -> *).
FreshM m =>
Namespace -> ModPath -> PName -> Maybe Fixity -> Range -> m Name
newTop Namespace
NSValue ModPath
ns PName
thing forall a. Maybe a
Nothing Range
srcRange
       forall (m :: * -> *) a. Monad m => a -> m a
return (Namespace -> PName -> Name -> NamingEnv
singletonNS Namespace
NSType PName
thing Name
ntName forall a. Monoid a => a -> a -> a
`mappend`
               Namespace -> PName -> Name -> NamingEnv
singletonNS Namespace
NSValue PName
thing Name
ntConName)

-- | The naming environment for a single declaration.
instance BindsNames (InModule (Decl PName)) where
  namingEnv :: InModule (Decl PName) -> BuildNamingEnv
namingEnv (InModule Maybe ModPath
pfx Decl PName
d) = case Decl PName
d of
    DBind Bind PName
b                 -> forall a. BindsNames a => a -> BuildNamingEnv
namingEnv (forall a. Maybe ModPath -> a -> InModule a
InModule Maybe ModPath
pfx Bind PName
b)
    DSignature [Located PName]
ns Schema PName
_sig      -> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Located PName -> BuildNamingEnv
qualBind [Located PName]
ns
    DPragma [Located PName]
ns Pragma
_p           -> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Located PName -> BuildNamingEnv
qualBind [Located PName]
ns
    DType TySyn PName
syn               -> Located PName -> Maybe Fixity -> BuildNamingEnv
qualType (forall name. TySyn name -> Located name
tsName TySyn PName
syn) (forall name. TySyn name -> Maybe Fixity
tsFixity TySyn PName
syn)
    DProp PropSyn PName
syn               -> Located PName -> Maybe Fixity -> BuildNamingEnv
qualType (forall name. PropSyn name -> Located name
psName PropSyn PName
syn) (forall name. PropSyn name -> Maybe Fixity
psFixity PropSyn PName
syn)
    DLocated Decl PName
d' Range
_           -> forall a. BindsNames a => a -> BuildNamingEnv
namingEnv (forall a. Maybe ModPath -> a -> InModule a
InModule Maybe ModPath
pfx Decl PName
d')
    DRec {}                 -> forall a. HasCallStack => String -> [String] -> a
panic String
"namingEnv" [ String
"DRec" ]
    DPatBind Pattern PName
_pat Expr PName
_e        -> forall a. HasCallStack => String -> [String] -> a
panic String
"namingEnv" [String
"Unexpected pattern binding"]
    DFixity{}               -> forall a. HasCallStack => String -> [String] -> a
panic String
"namingEnv" [String
"Unexpected fixity declaration"]

    where

    mkName :: Namespace -> Located PName -> Maybe Fixity -> m Name
mkName Namespace
ns Located PName
ln Maybe Fixity
fx = case Maybe ModPath
pfx of
                        Just ModPath
m  -> forall (m :: * -> *).
FreshM m =>
Namespace -> ModPath -> PName -> Maybe Fixity -> Range -> m Name
newTop Namespace
ns ModPath
m (forall a. Located a -> a
thing Located PName
ln) Maybe Fixity
fx (forall a. Located a -> Range
srcRange Located PName
ln)
                        Maybe ModPath
Nothing -> forall (m :: * -> *).
FreshM m =>
Namespace -> PName -> Range -> m Name
newLocal Namespace
ns (forall a. Located a -> a
thing Located PName
ln) (forall a. Located a -> Range
srcRange Located PName
ln)

    qualBind :: Located PName -> BuildNamingEnv
qualBind Located PName
ln = SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv forall a b. (a -> b) -> a -> b
$
      do Name
n <- forall {m :: * -> *}.
FreshM m =>
Namespace -> Located PName -> Maybe Fixity -> m Name
mkName Namespace
NSValue Located PName
ln forall a. Maybe a
Nothing
         forall (m :: * -> *) a. Monad m => a -> m a
return (Namespace -> PName -> Name -> NamingEnv
singletonNS Namespace
NSValue (forall a. Located a -> a
thing Located PName
ln) Name
n)

    qualType :: Located PName -> Maybe Fixity -> BuildNamingEnv
qualType Located PName
ln Maybe Fixity
f = SupplyT Id NamingEnv -> BuildNamingEnv
BuildNamingEnv forall a b. (a -> b) -> a -> b
$
      do Name
n <- forall {m :: * -> *}.
FreshM m =>
Namespace -> Located PName -> Maybe Fixity -> m Name
mkName Namespace
NSType Located PName
ln Maybe Fixity
f
         forall (m :: * -> *) a. Monad m => a -> m a
return (Namespace -> PName -> Name -> NamingEnv
singletonNS Namespace
NSType (forall a. Located a -> a
thing Located PName
ln) Name
n)

instance BindsNames (InModule (SigDecl PName)) where
  namingEnv :: InModule (SigDecl PName) -> BuildNamingEnv
namingEnv (InModule Maybe ModPath
m SigDecl PName
d) =
    case SigDecl PName
d of
      SigTySyn TySyn PName
ts Maybe Text
_    -> forall a. BindsNames a => a -> BuildNamingEnv
namingEnv (forall a. Maybe ModPath -> a -> InModule a
InModule Maybe ModPath
m (forall name. TySyn name -> Decl name
DType TySyn PName
ts))
      SigPropSyn PropSyn PName
ps Maybe Text
_  -> forall a. BindsNames a => a -> BuildNamingEnv
namingEnv (forall a. Maybe ModPath -> a -> InModule a
InModule Maybe ModPath
m (forall name. PropSyn name -> Decl name
DProp PropSyn PName
ps))




--------------------------------------------------------------------------------
-- Helpers

newTop ::
  FreshM m => Namespace -> ModPath -> PName -> Maybe Fixity -> Range -> m Name
newTop :: forall (m :: * -> *).
FreshM m =>
Namespace -> ModPath -> PName -> Maybe Fixity -> Range -> m Name
newTop Namespace
ns ModPath
m PName
thing Maybe Fixity
fx Range
rng =
  forall (m :: * -> *) a. FreshM m => (Supply -> (a, Supply)) -> m a
liftSupply (Namespace
-> ModPath
-> NameSource
-> Ident
-> Maybe Fixity
-> Range
-> Supply
-> (Name, Supply)
mkDeclared Namespace
ns ModPath
m NameSource
src (PName -> Ident
getIdent PName
thing) Maybe Fixity
fx Range
rng)
  where src :: NameSource
src = if PName -> Bool
isGeneratedName PName
thing then NameSource
SystemName else NameSource
UserName

newLocal :: FreshM m => Namespace -> PName -> Range -> m Name
newLocal :: forall (m :: * -> *).
FreshM m =>
Namespace -> PName -> Range -> m Name
newLocal Namespace
ns PName
thing Range
rng = forall (m :: * -> *) a. FreshM m => (Supply -> (a, Supply)) -> m a
liftSupply (Namespace -> Ident -> Range -> Supply -> (Name, Supply)
mkLocal Namespace
ns (PName -> Ident
getIdent PName
thing) Range
rng)

-- | Given a name in a signature, make a name for the parameter corresponding
-- to the signature.
newModParam :: FreshM m => ModPath -> Ident -> Range -> Name -> m Name
newModParam :: forall (m :: * -> *).
FreshM m =>
ModPath -> Ident -> Range -> Name -> m Name
newModParam ModPath
m Ident
i Range
rng Name
n = forall (m :: * -> *) a. FreshM m => (Supply -> (a, Supply)) -> m a
liftSupply (ModPath -> Ident -> Range -> Name -> Supply -> (Name, Supply)
mkModParam ModPath
m Ident
i Range
rng Name
n)


{- | Do something in the context of a module.
If `Nothing` than we are working with a local declaration.
Otherwise we are at the top-level of the given module.

By wrapping types with this, we can pass the module path
to methods that need the extra information. -}
data InModule a = InModule (Maybe ModPath) a
                  deriving (forall a b. a -> InModule b -> InModule a
forall a b. (a -> b) -> InModule a -> InModule b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> InModule b -> InModule a
$c<$ :: forall a b. a -> InModule b -> InModule a
fmap :: forall a b. (a -> b) -> InModule a -> InModule b
$cfmap :: forall a b. (a -> b) -> InModule a -> InModule b
Functor,Functor InModule
Foldable InModule
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => InModule (m a) -> m (InModule a)
forall (f :: * -> *) a.
Applicative f =>
InModule (f a) -> f (InModule a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InModule a -> m (InModule b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InModule a -> f (InModule b)
sequence :: forall (m :: * -> *) a. Monad m => InModule (m a) -> m (InModule a)
$csequence :: forall (m :: * -> *) a. Monad m => InModule (m a) -> m (InModule a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InModule a -> m (InModule b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InModule a -> m (InModule b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
InModule (f a) -> f (InModule a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
InModule (f a) -> f (InModule a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InModule a -> f (InModule b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InModule a -> f (InModule b)
Traversable,forall a. Eq a => a -> InModule a -> Bool
forall a. Num a => InModule a -> a
forall a. Ord a => InModule a -> a
forall m. Monoid m => InModule m -> m
forall a. InModule a -> Bool
forall a. InModule a -> Int
forall a. InModule a -> [a]
forall a. (a -> a -> a) -> InModule a -> a
forall m a. Monoid m => (a -> m) -> InModule a -> m
forall b a. (b -> a -> b) -> b -> InModule a -> b
forall a b. (a -> b -> b) -> b -> InModule a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => InModule a -> a
$cproduct :: forall a. Num a => InModule a -> a
sum :: forall a. Num a => InModule a -> a
$csum :: forall a. Num a => InModule a -> a
minimum :: forall a. Ord a => InModule a -> a
$cminimum :: forall a. Ord a => InModule a -> a
maximum :: forall a. Ord a => InModule a -> a
$cmaximum :: forall a. Ord a => InModule a -> a
elem :: forall a. Eq a => a -> InModule a -> Bool
$celem :: forall a. Eq a => a -> InModule a -> Bool
length :: forall a. InModule a -> Int
$clength :: forall a. InModule a -> Int
null :: forall a. InModule a -> Bool
$cnull :: forall a. InModule a -> Bool
toList :: forall a. InModule a -> [a]
$ctoList :: forall a. InModule a -> [a]
foldl1 :: forall a. (a -> a -> a) -> InModule a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> InModule a -> a
foldr1 :: forall a. (a -> a -> a) -> InModule a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> InModule a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> InModule a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> InModule a -> b
foldl :: forall b a. (b -> a -> b) -> b -> InModule a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> InModule a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> InModule a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> InModule a -> b
foldr :: forall a b. (a -> b -> b) -> b -> InModule a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> InModule a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> InModule a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> InModule a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> InModule a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> InModule a -> m
fold :: forall m. Monoid m => InModule m -> m
$cfold :: forall m. Monoid m => InModule m -> m
Foldable,Int -> InModule a -> ShowS
forall a. Show a => Int -> InModule a -> ShowS
forall a. Show a => [InModule a] -> ShowS
forall a. Show a => InModule a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InModule a] -> ShowS
$cshowList :: forall a. Show a => [InModule a] -> ShowS
show :: InModule a -> String
$cshow :: forall a. Show a => InModule a -> String
showsPrec :: Int -> InModule a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> InModule a -> ShowS
Show)