{-# LANGUAGE DeriveAnyClass     #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE OverloadedStrings  #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Disco.Names
-- Copyright   :  disco team and contributors
-- Maintainer  :  byorgey@gmail.com
--
-- Names for modules and identifiers.
--
-----------------------------------------------------------------------------

-- SPDX-License-Identifier: BSD-3-Clause

module Disco.Names
  ( -- * Modules and their provenance
    ModuleProvenance(..), ModuleName(..)
    -- * Names and their provenance
  , NameProvenance(..), QName(..), isFree, localName, (.-)
    -- * Name-related utilities
  , fvQ, substQ, substsQ
  ) where

import           Control.Lens                     (Traversal', filtered)
import           Data.Data                        (Data)
import           Data.Data.Lens                   (template)
import           Data.Typeable                    (Typeable)
import           GHC.Generics                     (Generic)
import           Prelude                          hiding ((<>))
import           System.FilePath                  (dropExtension)
import           Unbound.Generics.LocallyNameless

import           Disco.Pretty
import           Disco.Types

------------------------------------------------------------
-- Modules
------------------------------------------------------------

-- | Where did a module come from?
data ModuleProvenance
  = Dir FilePath -- ^ From a particular directory (relative to cwd)
  | Stdlib       -- ^ From the standard library
  deriving (ModuleProvenance -> ModuleProvenance -> Bool
(ModuleProvenance -> ModuleProvenance -> Bool)
-> (ModuleProvenance -> ModuleProvenance -> Bool)
-> Eq ModuleProvenance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModuleProvenance -> ModuleProvenance -> Bool
$c/= :: ModuleProvenance -> ModuleProvenance -> Bool
== :: ModuleProvenance -> ModuleProvenance -> Bool
$c== :: ModuleProvenance -> ModuleProvenance -> Bool
Eq, Eq ModuleProvenance
Eq ModuleProvenance
-> (ModuleProvenance -> ModuleProvenance -> Ordering)
-> (ModuleProvenance -> ModuleProvenance -> Bool)
-> (ModuleProvenance -> ModuleProvenance -> Bool)
-> (ModuleProvenance -> ModuleProvenance -> Bool)
-> (ModuleProvenance -> ModuleProvenance -> Bool)
-> (ModuleProvenance -> ModuleProvenance -> ModuleProvenance)
-> (ModuleProvenance -> ModuleProvenance -> ModuleProvenance)
-> Ord ModuleProvenance
ModuleProvenance -> ModuleProvenance -> Bool
ModuleProvenance -> ModuleProvenance -> Ordering
ModuleProvenance -> ModuleProvenance -> ModuleProvenance
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ModuleProvenance -> ModuleProvenance -> ModuleProvenance
$cmin :: ModuleProvenance -> ModuleProvenance -> ModuleProvenance
max :: ModuleProvenance -> ModuleProvenance -> ModuleProvenance
$cmax :: ModuleProvenance -> ModuleProvenance -> ModuleProvenance
>= :: ModuleProvenance -> ModuleProvenance -> Bool
$c>= :: ModuleProvenance -> ModuleProvenance -> Bool
> :: ModuleProvenance -> ModuleProvenance -> Bool
$c> :: ModuleProvenance -> ModuleProvenance -> Bool
<= :: ModuleProvenance -> ModuleProvenance -> Bool
$c<= :: ModuleProvenance -> ModuleProvenance -> Bool
< :: ModuleProvenance -> ModuleProvenance -> Bool
$c< :: ModuleProvenance -> ModuleProvenance -> Bool
compare :: ModuleProvenance -> ModuleProvenance -> Ordering
$ccompare :: ModuleProvenance -> ModuleProvenance -> Ordering
$cp1Ord :: Eq ModuleProvenance
Ord, Int -> ModuleProvenance -> ShowS
[ModuleProvenance] -> ShowS
ModuleProvenance -> String
(Int -> ModuleProvenance -> ShowS)
-> (ModuleProvenance -> String)
-> ([ModuleProvenance] -> ShowS)
-> Show ModuleProvenance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModuleProvenance] -> ShowS
$cshowList :: [ModuleProvenance] -> ShowS
show :: ModuleProvenance -> String
$cshow :: ModuleProvenance -> String
showsPrec :: Int -> ModuleProvenance -> ShowS
$cshowsPrec :: Int -> ModuleProvenance -> ShowS
Show, (forall x. ModuleProvenance -> Rep ModuleProvenance x)
-> (forall x. Rep ModuleProvenance x -> ModuleProvenance)
-> Generic ModuleProvenance
forall x. Rep ModuleProvenance x -> ModuleProvenance
forall x. ModuleProvenance -> Rep ModuleProvenance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModuleProvenance x -> ModuleProvenance
$cfrom :: forall x. ModuleProvenance -> Rep ModuleProvenance x
Generic, Typeable ModuleProvenance
DataType
Constr
Typeable ModuleProvenance
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleProvenance -> c ModuleProvenance)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleProvenance)
-> (ModuleProvenance -> Constr)
-> (ModuleProvenance -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleProvenance))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ModuleProvenance))
-> ((forall b. Data b => b -> b)
    -> ModuleProvenance -> ModuleProvenance)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleProvenance -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleProvenance -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ModuleProvenance -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModuleProvenance -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ModuleProvenance -> m ModuleProvenance)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModuleProvenance -> m ModuleProvenance)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModuleProvenance -> m ModuleProvenance)
-> Data ModuleProvenance
ModuleProvenance -> DataType
ModuleProvenance -> Constr
(forall b. Data b => b -> b)
-> ModuleProvenance -> ModuleProvenance
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleProvenance -> c ModuleProvenance
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleProvenance
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ModuleProvenance -> u
forall u. (forall d. Data d => d -> u) -> ModuleProvenance -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleProvenance -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleProvenance -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ModuleProvenance -> m ModuleProvenance
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModuleProvenance -> m ModuleProvenance
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleProvenance
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleProvenance -> c ModuleProvenance
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleProvenance)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModuleProvenance)
$cStdlib :: Constr
$cDir :: Constr
$tModuleProvenance :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> ModuleProvenance -> m ModuleProvenance
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModuleProvenance -> m ModuleProvenance
gmapMp :: (forall d. Data d => d -> m d)
-> ModuleProvenance -> m ModuleProvenance
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModuleProvenance -> m ModuleProvenance
gmapM :: (forall d. Data d => d -> m d)
-> ModuleProvenance -> m ModuleProvenance
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ModuleProvenance -> m ModuleProvenance
gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleProvenance -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ModuleProvenance -> u
gmapQ :: (forall d. Data d => d -> u) -> ModuleProvenance -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleProvenance -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleProvenance -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleProvenance -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleProvenance -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleProvenance -> r
gmapT :: (forall b. Data b => b -> b)
-> ModuleProvenance -> ModuleProvenance
$cgmapT :: (forall b. Data b => b -> b)
-> ModuleProvenance -> ModuleProvenance
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModuleProvenance)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModuleProvenance)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ModuleProvenance)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleProvenance)
dataTypeOf :: ModuleProvenance -> DataType
$cdataTypeOf :: ModuleProvenance -> DataType
toConstr :: ModuleProvenance -> Constr
$ctoConstr :: ModuleProvenance -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleProvenance
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleProvenance
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleProvenance -> c ModuleProvenance
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleProvenance -> c ModuleProvenance
$cp1Data :: Typeable ModuleProvenance
Data, Show ModuleProvenance
Show ModuleProvenance
-> (AlphaCtx -> ModuleProvenance -> ModuleProvenance -> Bool)
-> (forall (f :: * -> *).
    (Contravariant f, Applicative f) =>
    AlphaCtx
    -> (AnyName -> f AnyName)
    -> ModuleProvenance
    -> f ModuleProvenance)
-> (AlphaCtx
    -> NamePatFind -> ModuleProvenance -> ModuleProvenance)
-> (AlphaCtx -> NthPatFind -> ModuleProvenance -> ModuleProvenance)
-> (ModuleProvenance -> DisjointSet AnyName)
-> (ModuleProvenance -> All)
-> (ModuleProvenance -> Bool)
-> (ModuleProvenance -> NthPatFind)
-> (ModuleProvenance -> NamePatFind)
-> (AlphaCtx
    -> Perm AnyName -> ModuleProvenance -> ModuleProvenance)
-> (forall (m :: * -> *) b.
    LFresh m =>
    AlphaCtx
    -> ModuleProvenance
    -> (ModuleProvenance -> Perm AnyName -> m b)
    -> m b)
-> (forall (m :: * -> *).
    Fresh m =>
    AlphaCtx -> ModuleProvenance -> m (ModuleProvenance, Perm AnyName))
-> (AlphaCtx -> ModuleProvenance -> ModuleProvenance -> Ordering)
-> Alpha ModuleProvenance
AlphaCtx -> NthPatFind -> ModuleProvenance -> ModuleProvenance
AlphaCtx -> NamePatFind -> ModuleProvenance -> ModuleProvenance
AlphaCtx -> Perm AnyName -> ModuleProvenance -> ModuleProvenance
AlphaCtx -> ModuleProvenance -> ModuleProvenance -> Bool
AlphaCtx -> ModuleProvenance -> ModuleProvenance -> Ordering
ModuleProvenance -> Bool
ModuleProvenance -> All
ModuleProvenance -> DisjointSet AnyName
ModuleProvenance -> NthPatFind
ModuleProvenance -> NamePatFind
forall a.
Show a
-> (AlphaCtx -> a -> a -> Bool)
-> (forall (f :: * -> *).
    (Contravariant f, Applicative f) =>
    AlphaCtx -> (AnyName -> f AnyName) -> a -> f a)
-> (AlphaCtx -> NamePatFind -> a -> a)
-> (AlphaCtx -> NthPatFind -> a -> a)
-> (a -> DisjointSet AnyName)
-> (a -> All)
-> (a -> Bool)
-> (a -> NthPatFind)
-> (a -> NamePatFind)
-> (AlphaCtx -> Perm AnyName -> a -> a)
-> (forall (m :: * -> *) b.
    LFresh m =>
    AlphaCtx -> a -> (a -> Perm AnyName -> m b) -> m b)
-> (forall (m :: * -> *).
    Fresh m =>
    AlphaCtx -> a -> m (a, Perm AnyName))
-> (AlphaCtx -> a -> a -> Ordering)
-> Alpha a
forall (f :: * -> *).
(Contravariant f, Applicative f) =>
AlphaCtx
-> (AnyName -> f AnyName) -> ModuleProvenance -> f ModuleProvenance
forall (m :: * -> *).
Fresh m =>
AlphaCtx -> ModuleProvenance -> m (ModuleProvenance, Perm AnyName)
forall (m :: * -> *) b.
LFresh m =>
AlphaCtx
-> ModuleProvenance
-> (ModuleProvenance -> Perm AnyName -> m b)
-> m b
acompare' :: AlphaCtx -> ModuleProvenance -> ModuleProvenance -> Ordering
$cacompare' :: AlphaCtx -> ModuleProvenance -> ModuleProvenance -> Ordering
freshen' :: AlphaCtx -> ModuleProvenance -> m (ModuleProvenance, Perm AnyName)
$cfreshen' :: forall (m :: * -> *).
Fresh m =>
AlphaCtx -> ModuleProvenance -> m (ModuleProvenance, Perm AnyName)
lfreshen' :: AlphaCtx
-> ModuleProvenance
-> (ModuleProvenance -> Perm AnyName -> m b)
-> m b
$clfreshen' :: forall (m :: * -> *) b.
LFresh m =>
AlphaCtx
-> ModuleProvenance
-> (ModuleProvenance -> Perm AnyName -> m b)
-> m b
swaps' :: AlphaCtx -> Perm AnyName -> ModuleProvenance -> ModuleProvenance
$cswaps' :: AlphaCtx -> Perm AnyName -> ModuleProvenance -> ModuleProvenance
namePatFind :: ModuleProvenance -> NamePatFind
$cnamePatFind :: ModuleProvenance -> NamePatFind
nthPatFind :: ModuleProvenance -> NthPatFind
$cnthPatFind :: ModuleProvenance -> NthPatFind
isEmbed :: ModuleProvenance -> Bool
$cisEmbed :: ModuleProvenance -> Bool
isTerm :: ModuleProvenance -> All
$cisTerm :: ModuleProvenance -> All
isPat :: ModuleProvenance -> DisjointSet AnyName
$cisPat :: ModuleProvenance -> DisjointSet AnyName
open :: AlphaCtx -> NthPatFind -> ModuleProvenance -> ModuleProvenance
$copen :: AlphaCtx -> NthPatFind -> ModuleProvenance -> ModuleProvenance
close :: AlphaCtx -> NamePatFind -> ModuleProvenance -> ModuleProvenance
$cclose :: AlphaCtx -> NamePatFind -> ModuleProvenance -> ModuleProvenance
fvAny' :: AlphaCtx
-> (AnyName -> f AnyName) -> ModuleProvenance -> f ModuleProvenance
$cfvAny' :: forall (f :: * -> *).
(Contravariant f, Applicative f) =>
AlphaCtx
-> (AnyName -> f AnyName) -> ModuleProvenance -> f ModuleProvenance
aeq' :: AlphaCtx -> ModuleProvenance -> ModuleProvenance -> Bool
$caeq' :: AlphaCtx -> ModuleProvenance -> ModuleProvenance -> Bool
$cp1Alpha :: Show ModuleProvenance
Alpha, Subst Type)

-- | The name of a module.
data ModuleName
  = REPLModule   -- ^ The special top-level "module" consisting of
                 -- what has been entered at the REPL.
  | Named ModuleProvenance String
                 -- ^ A named module, with its name and provenance.
  deriving (ModuleName -> ModuleName -> Bool
(ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> Bool) -> Eq ModuleName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModuleName -> ModuleName -> Bool
$c/= :: ModuleName -> ModuleName -> Bool
== :: ModuleName -> ModuleName -> Bool
$c== :: ModuleName -> ModuleName -> Bool
Eq, Eq ModuleName
Eq ModuleName
-> (ModuleName -> ModuleName -> Ordering)
-> (ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> ModuleName)
-> (ModuleName -> ModuleName -> ModuleName)
-> Ord ModuleName
ModuleName -> ModuleName -> Bool
ModuleName -> ModuleName -> Ordering
ModuleName -> ModuleName -> ModuleName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ModuleName -> ModuleName -> ModuleName
$cmin :: ModuleName -> ModuleName -> ModuleName
max :: ModuleName -> ModuleName -> ModuleName
$cmax :: ModuleName -> ModuleName -> ModuleName
>= :: ModuleName -> ModuleName -> Bool
$c>= :: ModuleName -> ModuleName -> Bool
> :: ModuleName -> ModuleName -> Bool
$c> :: ModuleName -> ModuleName -> Bool
<= :: ModuleName -> ModuleName -> Bool
$c<= :: ModuleName -> ModuleName -> Bool
< :: ModuleName -> ModuleName -> Bool
$c< :: ModuleName -> ModuleName -> Bool
compare :: ModuleName -> ModuleName -> Ordering
$ccompare :: ModuleName -> ModuleName -> Ordering
$cp1Ord :: Eq ModuleName
Ord, Int -> ModuleName -> ShowS
[ModuleName] -> ShowS
ModuleName -> String
(Int -> ModuleName -> ShowS)
-> (ModuleName -> String)
-> ([ModuleName] -> ShowS)
-> Show ModuleName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModuleName] -> ShowS
$cshowList :: [ModuleName] -> ShowS
show :: ModuleName -> String
$cshow :: ModuleName -> String
showsPrec :: Int -> ModuleName -> ShowS
$cshowsPrec :: Int -> ModuleName -> ShowS
Show, (forall x. ModuleName -> Rep ModuleName x)
-> (forall x. Rep ModuleName x -> ModuleName) -> Generic ModuleName
forall x. Rep ModuleName x -> ModuleName
forall x. ModuleName -> Rep ModuleName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModuleName x -> ModuleName
$cfrom :: forall x. ModuleName -> Rep ModuleName x
Generic, Typeable ModuleName
DataType
Constr
Typeable ModuleName
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleName -> c ModuleName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleName)
-> (ModuleName -> Constr)
-> (ModuleName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ModuleName))
-> ((forall b. Data b => b -> b) -> ModuleName -> ModuleName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleName -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModuleName -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModuleName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName)
-> Data ModuleName
ModuleName -> DataType
ModuleName -> Constr
(forall b. Data b => b -> b) -> ModuleName -> ModuleName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleName -> c ModuleName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleName
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ModuleName -> u
forall u. (forall d. Data d => d -> u) -> ModuleName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleName -> m ModuleName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleName -> m ModuleName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleName -> c ModuleName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleName)
$cNamed :: Constr
$cREPLModule :: Constr
$tModuleName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleName -> m ModuleName
gmapMp :: (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleName -> m ModuleName
gmapM :: (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleName -> m ModuleName
gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleName -> u
gmapQ :: (forall d. Data d => d -> u) -> ModuleName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleName -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName -> r
gmapT :: (forall b. Data b => b -> b) -> ModuleName -> ModuleName
$cgmapT :: (forall b. Data b => b -> b) -> ModuleName -> ModuleName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ModuleName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleName)
dataTypeOf :: ModuleName -> DataType
$cdataTypeOf :: ModuleName -> DataType
toConstr :: ModuleName -> Constr
$ctoConstr :: ModuleName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleName -> c ModuleName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleName -> c ModuleName
$cp1Data :: Typeable ModuleName
Data, Show ModuleName
Show ModuleName
-> (AlphaCtx -> ModuleName -> ModuleName -> Bool)
-> (forall (f :: * -> *).
    (Contravariant f, Applicative f) =>
    AlphaCtx -> (AnyName -> f AnyName) -> ModuleName -> f ModuleName)
-> (AlphaCtx -> NamePatFind -> ModuleName -> ModuleName)
-> (AlphaCtx -> NthPatFind -> ModuleName -> ModuleName)
-> (ModuleName -> DisjointSet AnyName)
-> (ModuleName -> All)
-> (ModuleName -> Bool)
-> (ModuleName -> NthPatFind)
-> (ModuleName -> NamePatFind)
-> (AlphaCtx -> Perm AnyName -> ModuleName -> ModuleName)
-> (forall (m :: * -> *) b.
    LFresh m =>
    AlphaCtx
    -> ModuleName -> (ModuleName -> Perm AnyName -> m b) -> m b)
-> (forall (m :: * -> *).
    Fresh m =>
    AlphaCtx -> ModuleName -> m (ModuleName, Perm AnyName))
-> (AlphaCtx -> ModuleName -> ModuleName -> Ordering)
-> Alpha ModuleName
AlphaCtx -> NthPatFind -> ModuleName -> ModuleName
AlphaCtx -> NamePatFind -> ModuleName -> ModuleName
AlphaCtx -> Perm AnyName -> ModuleName -> ModuleName
AlphaCtx -> ModuleName -> ModuleName -> Bool
AlphaCtx -> ModuleName -> ModuleName -> Ordering
ModuleName -> Bool
ModuleName -> All
ModuleName -> DisjointSet AnyName
ModuleName -> NthPatFind
ModuleName -> NamePatFind
forall a.
Show a
-> (AlphaCtx -> a -> a -> Bool)
-> (forall (f :: * -> *).
    (Contravariant f, Applicative f) =>
    AlphaCtx -> (AnyName -> f AnyName) -> a -> f a)
-> (AlphaCtx -> NamePatFind -> a -> a)
-> (AlphaCtx -> NthPatFind -> a -> a)
-> (a -> DisjointSet AnyName)
-> (a -> All)
-> (a -> Bool)
-> (a -> NthPatFind)
-> (a -> NamePatFind)
-> (AlphaCtx -> Perm AnyName -> a -> a)
-> (forall (m :: * -> *) b.
    LFresh m =>
    AlphaCtx -> a -> (a -> Perm AnyName -> m b) -> m b)
-> (forall (m :: * -> *).
    Fresh m =>
    AlphaCtx -> a -> m (a, Perm AnyName))
-> (AlphaCtx -> a -> a -> Ordering)
-> Alpha a
forall (f :: * -> *).
(Contravariant f, Applicative f) =>
AlphaCtx -> (AnyName -> f AnyName) -> ModuleName -> f ModuleName
forall (m :: * -> *).
Fresh m =>
AlphaCtx -> ModuleName -> m (ModuleName, Perm AnyName)
forall (m :: * -> *) b.
LFresh m =>
AlphaCtx
-> ModuleName -> (ModuleName -> Perm AnyName -> m b) -> m b
acompare' :: AlphaCtx -> ModuleName -> ModuleName -> Ordering
$cacompare' :: AlphaCtx -> ModuleName -> ModuleName -> Ordering
freshen' :: AlphaCtx -> ModuleName -> m (ModuleName, Perm AnyName)
$cfreshen' :: forall (m :: * -> *).
Fresh m =>
AlphaCtx -> ModuleName -> m (ModuleName, Perm AnyName)
lfreshen' :: AlphaCtx
-> ModuleName -> (ModuleName -> Perm AnyName -> m b) -> m b
$clfreshen' :: forall (m :: * -> *) b.
LFresh m =>
AlphaCtx
-> ModuleName -> (ModuleName -> Perm AnyName -> m b) -> m b
swaps' :: AlphaCtx -> Perm AnyName -> ModuleName -> ModuleName
$cswaps' :: AlphaCtx -> Perm AnyName -> ModuleName -> ModuleName
namePatFind :: ModuleName -> NamePatFind
$cnamePatFind :: ModuleName -> NamePatFind
nthPatFind :: ModuleName -> NthPatFind
$cnthPatFind :: ModuleName -> NthPatFind
isEmbed :: ModuleName -> Bool
$cisEmbed :: ModuleName -> Bool
isTerm :: ModuleName -> All
$cisTerm :: ModuleName -> All
isPat :: ModuleName -> DisjointSet AnyName
$cisPat :: ModuleName -> DisjointSet AnyName
open :: AlphaCtx -> NthPatFind -> ModuleName -> ModuleName
$copen :: AlphaCtx -> NthPatFind -> ModuleName -> ModuleName
close :: AlphaCtx -> NamePatFind -> ModuleName -> ModuleName
$cclose :: AlphaCtx -> NamePatFind -> ModuleName -> ModuleName
fvAny' :: AlphaCtx -> (AnyName -> f AnyName) -> ModuleName -> f ModuleName
$cfvAny' :: forall (f :: * -> *).
(Contravariant f, Applicative f) =>
AlphaCtx -> (AnyName -> f AnyName) -> ModuleName -> f ModuleName
aeq' :: AlphaCtx -> ModuleName -> ModuleName -> Bool
$caeq' :: AlphaCtx -> ModuleName -> ModuleName -> Bool
$cp1Alpha :: Show ModuleName
Alpha, Subst Type)

------------------------------------------------------------
-- Names
------------------------------------------------------------

-- | Where did a name come from?
data NameProvenance
  = LocalName                    -- ^ The name is locally bound
  | QualifiedName ModuleName     -- ^ The name is exported by the given module
  deriving (NameProvenance -> NameProvenance -> Bool
(NameProvenance -> NameProvenance -> Bool)
-> (NameProvenance -> NameProvenance -> Bool) -> Eq NameProvenance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NameProvenance -> NameProvenance -> Bool
$c/= :: NameProvenance -> NameProvenance -> Bool
== :: NameProvenance -> NameProvenance -> Bool
$c== :: NameProvenance -> NameProvenance -> Bool
Eq, Eq NameProvenance
Eq NameProvenance
-> (NameProvenance -> NameProvenance -> Ordering)
-> (NameProvenance -> NameProvenance -> Bool)
-> (NameProvenance -> NameProvenance -> Bool)
-> (NameProvenance -> NameProvenance -> Bool)
-> (NameProvenance -> NameProvenance -> Bool)
-> (NameProvenance -> NameProvenance -> NameProvenance)
-> (NameProvenance -> NameProvenance -> NameProvenance)
-> Ord NameProvenance
NameProvenance -> NameProvenance -> Bool
NameProvenance -> NameProvenance -> Ordering
NameProvenance -> NameProvenance -> NameProvenance
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NameProvenance -> NameProvenance -> NameProvenance
$cmin :: NameProvenance -> NameProvenance -> NameProvenance
max :: NameProvenance -> NameProvenance -> NameProvenance
$cmax :: NameProvenance -> NameProvenance -> NameProvenance
>= :: NameProvenance -> NameProvenance -> Bool
$c>= :: NameProvenance -> NameProvenance -> Bool
> :: NameProvenance -> NameProvenance -> Bool
$c> :: NameProvenance -> NameProvenance -> Bool
<= :: NameProvenance -> NameProvenance -> Bool
$c<= :: NameProvenance -> NameProvenance -> Bool
< :: NameProvenance -> NameProvenance -> Bool
$c< :: NameProvenance -> NameProvenance -> Bool
compare :: NameProvenance -> NameProvenance -> Ordering
$ccompare :: NameProvenance -> NameProvenance -> Ordering
$cp1Ord :: Eq NameProvenance
Ord, Int -> NameProvenance -> ShowS
[NameProvenance] -> ShowS
NameProvenance -> String
(Int -> NameProvenance -> ShowS)
-> (NameProvenance -> String)
-> ([NameProvenance] -> ShowS)
-> Show NameProvenance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NameProvenance] -> ShowS
$cshowList :: [NameProvenance] -> ShowS
show :: NameProvenance -> String
$cshow :: NameProvenance -> String
showsPrec :: Int -> NameProvenance -> ShowS
$cshowsPrec :: Int -> NameProvenance -> ShowS
Show, (forall x. NameProvenance -> Rep NameProvenance x)
-> (forall x. Rep NameProvenance x -> NameProvenance)
-> Generic NameProvenance
forall x. Rep NameProvenance x -> NameProvenance
forall x. NameProvenance -> Rep NameProvenance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NameProvenance x -> NameProvenance
$cfrom :: forall x. NameProvenance -> Rep NameProvenance x
Generic, Typeable NameProvenance
DataType
Constr
Typeable NameProvenance
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameProvenance -> c NameProvenance)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameProvenance)
-> (NameProvenance -> Constr)
-> (NameProvenance -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameProvenance))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NameProvenance))
-> ((forall b. Data b => b -> b)
    -> NameProvenance -> NameProvenance)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameProvenance -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameProvenance -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> NameProvenance -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NameProvenance -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> NameProvenance -> m NameProvenance)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NameProvenance -> m NameProvenance)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NameProvenance -> m NameProvenance)
-> Data NameProvenance
NameProvenance -> DataType
NameProvenance -> Constr
(forall b. Data b => b -> b) -> NameProvenance -> NameProvenance
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameProvenance -> c NameProvenance
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameProvenance
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> NameProvenance -> u
forall u. (forall d. Data d => d -> u) -> NameProvenance -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameProvenance -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameProvenance -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NameProvenance -> m NameProvenance
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameProvenance -> m NameProvenance
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameProvenance
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameProvenance -> c NameProvenance
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameProvenance)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameProvenance)
$cQualifiedName :: Constr
$cLocalName :: Constr
$tNameProvenance :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> NameProvenance -> m NameProvenance
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameProvenance -> m NameProvenance
gmapMp :: (forall d. Data d => d -> m d)
-> NameProvenance -> m NameProvenance
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameProvenance -> m NameProvenance
gmapM :: (forall d. Data d => d -> m d)
-> NameProvenance -> m NameProvenance
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NameProvenance -> m NameProvenance
gmapQi :: Int -> (forall d. Data d => d -> u) -> NameProvenance -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> NameProvenance -> u
gmapQ :: (forall d. Data d => d -> u) -> NameProvenance -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NameProvenance -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameProvenance -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameProvenance -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameProvenance -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameProvenance -> r
gmapT :: (forall b. Data b => b -> b) -> NameProvenance -> NameProvenance
$cgmapT :: (forall b. Data b => b -> b) -> NameProvenance -> NameProvenance
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameProvenance)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameProvenance)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c NameProvenance)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameProvenance)
dataTypeOf :: NameProvenance -> DataType
$cdataTypeOf :: NameProvenance -> DataType
toConstr :: NameProvenance -> Constr
$ctoConstr :: NameProvenance -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameProvenance
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameProvenance
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameProvenance -> c NameProvenance
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameProvenance -> c NameProvenance
$cp1Data :: Typeable NameProvenance
Data, Show NameProvenance
Show NameProvenance
-> (AlphaCtx -> NameProvenance -> NameProvenance -> Bool)
-> (forall (f :: * -> *).
    (Contravariant f, Applicative f) =>
    AlphaCtx
    -> (AnyName -> f AnyName) -> NameProvenance -> f NameProvenance)
-> (AlphaCtx -> NamePatFind -> NameProvenance -> NameProvenance)
-> (AlphaCtx -> NthPatFind -> NameProvenance -> NameProvenance)
-> (NameProvenance -> DisjointSet AnyName)
-> (NameProvenance -> All)
-> (NameProvenance -> Bool)
-> (NameProvenance -> NthPatFind)
-> (NameProvenance -> NamePatFind)
-> (AlphaCtx -> Perm AnyName -> NameProvenance -> NameProvenance)
-> (forall (m :: * -> *) b.
    LFresh m =>
    AlphaCtx
    -> NameProvenance
    -> (NameProvenance -> Perm AnyName -> m b)
    -> m b)
-> (forall (m :: * -> *).
    Fresh m =>
    AlphaCtx -> NameProvenance -> m (NameProvenance, Perm AnyName))
-> (AlphaCtx -> NameProvenance -> NameProvenance -> Ordering)
-> Alpha NameProvenance
AlphaCtx -> NthPatFind -> NameProvenance -> NameProvenance
AlphaCtx -> NamePatFind -> NameProvenance -> NameProvenance
AlphaCtx -> Perm AnyName -> NameProvenance -> NameProvenance
AlphaCtx -> NameProvenance -> NameProvenance -> Bool
AlphaCtx -> NameProvenance -> NameProvenance -> Ordering
NameProvenance -> Bool
NameProvenance -> All
NameProvenance -> DisjointSet AnyName
NameProvenance -> NthPatFind
NameProvenance -> NamePatFind
forall a.
Show a
-> (AlphaCtx -> a -> a -> Bool)
-> (forall (f :: * -> *).
    (Contravariant f, Applicative f) =>
    AlphaCtx -> (AnyName -> f AnyName) -> a -> f a)
-> (AlphaCtx -> NamePatFind -> a -> a)
-> (AlphaCtx -> NthPatFind -> a -> a)
-> (a -> DisjointSet AnyName)
-> (a -> All)
-> (a -> Bool)
-> (a -> NthPatFind)
-> (a -> NamePatFind)
-> (AlphaCtx -> Perm AnyName -> a -> a)
-> (forall (m :: * -> *) b.
    LFresh m =>
    AlphaCtx -> a -> (a -> Perm AnyName -> m b) -> m b)
-> (forall (m :: * -> *).
    Fresh m =>
    AlphaCtx -> a -> m (a, Perm AnyName))
-> (AlphaCtx -> a -> a -> Ordering)
-> Alpha a
forall (f :: * -> *).
(Contravariant f, Applicative f) =>
AlphaCtx
-> (AnyName -> f AnyName) -> NameProvenance -> f NameProvenance
forall (m :: * -> *).
Fresh m =>
AlphaCtx -> NameProvenance -> m (NameProvenance, Perm AnyName)
forall (m :: * -> *) b.
LFresh m =>
AlphaCtx
-> NameProvenance -> (NameProvenance -> Perm AnyName -> m b) -> m b
acompare' :: AlphaCtx -> NameProvenance -> NameProvenance -> Ordering
$cacompare' :: AlphaCtx -> NameProvenance -> NameProvenance -> Ordering
freshen' :: AlphaCtx -> NameProvenance -> m (NameProvenance, Perm AnyName)
$cfreshen' :: forall (m :: * -> *).
Fresh m =>
AlphaCtx -> NameProvenance -> m (NameProvenance, Perm AnyName)
lfreshen' :: AlphaCtx
-> NameProvenance -> (NameProvenance -> Perm AnyName -> m b) -> m b
$clfreshen' :: forall (m :: * -> *) b.
LFresh m =>
AlphaCtx
-> NameProvenance -> (NameProvenance -> Perm AnyName -> m b) -> m b
swaps' :: AlphaCtx -> Perm AnyName -> NameProvenance -> NameProvenance
$cswaps' :: AlphaCtx -> Perm AnyName -> NameProvenance -> NameProvenance
namePatFind :: NameProvenance -> NamePatFind
$cnamePatFind :: NameProvenance -> NamePatFind
nthPatFind :: NameProvenance -> NthPatFind
$cnthPatFind :: NameProvenance -> NthPatFind
isEmbed :: NameProvenance -> Bool
$cisEmbed :: NameProvenance -> Bool
isTerm :: NameProvenance -> All
$cisTerm :: NameProvenance -> All
isPat :: NameProvenance -> DisjointSet AnyName
$cisPat :: NameProvenance -> DisjointSet AnyName
open :: AlphaCtx -> NthPatFind -> NameProvenance -> NameProvenance
$copen :: AlphaCtx -> NthPatFind -> NameProvenance -> NameProvenance
close :: AlphaCtx -> NamePatFind -> NameProvenance -> NameProvenance
$cclose :: AlphaCtx -> NamePatFind -> NameProvenance -> NameProvenance
fvAny' :: AlphaCtx
-> (AnyName -> f AnyName) -> NameProvenance -> f NameProvenance
$cfvAny' :: forall (f :: * -> *).
(Contravariant f, Applicative f) =>
AlphaCtx
-> (AnyName -> f AnyName) -> NameProvenance -> f NameProvenance
aeq' :: AlphaCtx -> NameProvenance -> NameProvenance -> Bool
$caeq' :: AlphaCtx -> NameProvenance -> NameProvenance -> Bool
$cp1Alpha :: Show NameProvenance
Alpha, Subst Type)

-- | A @QName@, or qualified name, is a 'Name' paired with its
--   'NameProvenance'.
data QName a = QName { QName a -> NameProvenance
qnameProvenance :: NameProvenance, QName a -> Name a
qname :: Name a }
  deriving (QName a -> QName a -> Bool
(QName a -> QName a -> Bool)
-> (QName a -> QName a -> Bool) -> Eq (QName a)
forall a. QName a -> QName a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: QName a -> QName a -> Bool
$c/= :: forall a. QName a -> QName a -> Bool
== :: QName a -> QName a -> Bool
$c== :: forall a. QName a -> QName a -> Bool
Eq, Eq (QName a)
Eq (QName a)
-> (QName a -> QName a -> Ordering)
-> (QName a -> QName a -> Bool)
-> (QName a -> QName a -> Bool)
-> (QName a -> QName a -> Bool)
-> (QName a -> QName a -> Bool)
-> (QName a -> QName a -> QName a)
-> (QName a -> QName a -> QName a)
-> Ord (QName a)
QName a -> QName a -> Bool
QName a -> QName a -> Ordering
QName a -> QName a -> QName a
forall a. Eq (QName a)
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. QName a -> QName a -> Bool
forall a. QName a -> QName a -> Ordering
forall a. QName a -> QName a -> QName a
min :: QName a -> QName a -> QName a
$cmin :: forall a. QName a -> QName a -> QName a
max :: QName a -> QName a -> QName a
$cmax :: forall a. QName a -> QName a -> QName a
>= :: QName a -> QName a -> Bool
$c>= :: forall a. QName a -> QName a -> Bool
> :: QName a -> QName a -> Bool
$c> :: forall a. QName a -> QName a -> Bool
<= :: QName a -> QName a -> Bool
$c<= :: forall a. QName a -> QName a -> Bool
< :: QName a -> QName a -> Bool
$c< :: forall a. QName a -> QName a -> Bool
compare :: QName a -> QName a -> Ordering
$ccompare :: forall a. QName a -> QName a -> Ordering
$cp1Ord :: forall a. Eq (QName a)
Ord, Int -> QName a -> ShowS
[QName a] -> ShowS
QName a -> String
(Int -> QName a -> ShowS)
-> (QName a -> String) -> ([QName a] -> ShowS) -> Show (QName a)
forall a. Int -> QName a -> ShowS
forall a. [QName a] -> ShowS
forall a. QName a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [QName a] -> ShowS
$cshowList :: forall a. [QName a] -> ShowS
show :: QName a -> String
$cshow :: forall a. QName a -> String
showsPrec :: Int -> QName a -> ShowS
$cshowsPrec :: forall a. Int -> QName a -> ShowS
Show, (forall x. QName a -> Rep (QName a) x)
-> (forall x. Rep (QName a) x -> QName a) -> Generic (QName a)
forall x. Rep (QName a) x -> QName a
forall x. QName a -> Rep (QName a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (QName a) x -> QName a
forall a x. QName a -> Rep (QName a) x
$cto :: forall a x. Rep (QName a) x -> QName a
$cfrom :: forall a x. QName a -> Rep (QName a) x
Generic, Typeable (QName a)
DataType
Constr
Typeable (QName a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QName a -> c (QName a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QName a))
-> (QName a -> Constr)
-> (QName a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QName a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName a)))
-> ((forall b. Data b => b -> b) -> QName a -> QName a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QName a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QName a -> r)
-> (forall u. (forall d. Data d => d -> u) -> QName a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> QName a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QName a -> m (QName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QName a -> m (QName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QName a -> m (QName a))
-> Data (QName a)
QName a -> DataType
QName a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (QName a))
(forall b. Data b => b -> b) -> QName a -> QName a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QName a -> c (QName a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QName a)
forall a. Data a => Typeable (QName a)
forall a. Data a => QName a -> DataType
forall a. Data a => QName a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> QName a -> QName a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> QName a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> QName a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QName a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QName a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> QName a -> m (QName a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> QName a -> m (QName a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QName a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QName a -> c (QName a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (QName a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> QName a -> u
forall u. (forall d. Data d => d -> u) -> QName a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QName a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QName a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QName a -> m (QName a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QName a -> m (QName a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QName a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QName a -> c (QName a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (QName a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName a))
$cQName :: Constr
$tQName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> QName a -> m (QName a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> QName a -> m (QName a)
gmapMp :: (forall d. Data d => d -> m d) -> QName a -> m (QName a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> QName a -> m (QName a)
gmapM :: (forall d. Data d => d -> m d) -> QName a -> m (QName a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> QName a -> m (QName a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> QName a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> QName a -> u
gmapQ :: (forall d. Data d => d -> u) -> QName a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> QName a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QName a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QName a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QName a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QName a -> r
gmapT :: (forall b. Data b => b -> b) -> QName a -> QName a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> QName a -> QName a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (QName a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (QName a))
dataTypeOf :: QName a -> DataType
$cdataTypeOf :: forall a. Data a => QName a -> DataType
toConstr :: QName a -> Constr
$ctoConstr :: forall a. Data a => QName a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QName a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QName a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QName a -> c (QName a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QName a -> c (QName a)
$cp1Data :: forall a. Data a => Typeable (QName a)
Data, Show (QName a)
Show (QName a)
-> (AlphaCtx -> QName a -> QName a -> Bool)
-> (forall (f :: * -> *).
    (Contravariant f, Applicative f) =>
    AlphaCtx -> (AnyName -> f AnyName) -> QName a -> f (QName a))
-> (AlphaCtx -> NamePatFind -> QName a -> QName a)
-> (AlphaCtx -> NthPatFind -> QName a -> QName a)
-> (QName a -> DisjointSet AnyName)
-> (QName a -> All)
-> (QName a -> Bool)
-> (QName a -> NthPatFind)
-> (QName a -> NamePatFind)
-> (AlphaCtx -> Perm AnyName -> QName a -> QName a)
-> (forall (m :: * -> *) b.
    LFresh m =>
    AlphaCtx -> QName a -> (QName a -> Perm AnyName -> m b) -> m b)
-> (forall (m :: * -> *).
    Fresh m =>
    AlphaCtx -> QName a -> m (QName a, Perm AnyName))
-> (AlphaCtx -> QName a -> QName a -> Ordering)
-> Alpha (QName a)
AlphaCtx -> NthPatFind -> QName a -> QName a
AlphaCtx -> NamePatFind -> QName a -> QName a
AlphaCtx -> Perm AnyName -> QName a -> QName a
AlphaCtx -> QName a -> QName a -> Bool
AlphaCtx -> QName a -> QName a -> Ordering
QName a -> Bool
QName a -> All
QName a -> DisjointSet AnyName
QName a -> NthPatFind
QName a -> NamePatFind
forall a.
Show a
-> (AlphaCtx -> a -> a -> Bool)
-> (forall (f :: * -> *).
    (Contravariant f, Applicative f) =>
    AlphaCtx -> (AnyName -> f AnyName) -> a -> f a)
-> (AlphaCtx -> NamePatFind -> a -> a)
-> (AlphaCtx -> NthPatFind -> a -> a)
-> (a -> DisjointSet AnyName)
-> (a -> All)
-> (a -> Bool)
-> (a -> NthPatFind)
-> (a -> NamePatFind)
-> (AlphaCtx -> Perm AnyName -> a -> a)
-> (forall (m :: * -> *) b.
    LFresh m =>
    AlphaCtx -> a -> (a -> Perm AnyName -> m b) -> m b)
-> (forall (m :: * -> *).
    Fresh m =>
    AlphaCtx -> a -> m (a, Perm AnyName))
-> (AlphaCtx -> a -> a -> Ordering)
-> Alpha a
forall a. Typeable a => Show (QName a)
forall a.
Typeable a =>
AlphaCtx -> NthPatFind -> QName a -> QName a
forall a.
Typeable a =>
AlphaCtx -> NamePatFind -> QName a -> QName a
forall a.
Typeable a =>
AlphaCtx -> Perm AnyName -> QName a -> QName a
forall a. Typeable a => AlphaCtx -> QName a -> QName a -> Bool
forall a. Typeable a => AlphaCtx -> QName a -> QName a -> Ordering
forall a. Typeable a => QName a -> Bool
forall a. Typeable a => QName a -> All
forall a. Typeable a => QName a -> DisjointSet AnyName
forall a. Typeable a => QName a -> NthPatFind
forall a. Typeable a => QName a -> NamePatFind
forall a (f :: * -> *).
(Typeable a, Contravariant f, Applicative f) =>
AlphaCtx -> (AnyName -> f AnyName) -> QName a -> f (QName a)
forall a (m :: * -> *).
(Typeable a, Fresh m) =>
AlphaCtx -> QName a -> m (QName a, Perm AnyName)
forall a (m :: * -> *) b.
(Typeable a, LFresh m) =>
AlphaCtx -> QName a -> (QName a -> Perm AnyName -> m b) -> m b
forall (f :: * -> *).
(Contravariant f, Applicative f) =>
AlphaCtx -> (AnyName -> f AnyName) -> QName a -> f (QName a)
forall (m :: * -> *).
Fresh m =>
AlphaCtx -> QName a -> m (QName a, Perm AnyName)
forall (m :: * -> *) b.
LFresh m =>
AlphaCtx -> QName a -> (QName a -> Perm AnyName -> m b) -> m b
acompare' :: AlphaCtx -> QName a -> QName a -> Ordering
$cacompare' :: forall a. Typeable a => AlphaCtx -> QName a -> QName a -> Ordering
freshen' :: AlphaCtx -> QName a -> m (QName a, Perm AnyName)
$cfreshen' :: forall a (m :: * -> *).
(Typeable a, Fresh m) =>
AlphaCtx -> QName a -> m (QName a, Perm AnyName)
lfreshen' :: AlphaCtx -> QName a -> (QName a -> Perm AnyName -> m b) -> m b
$clfreshen' :: forall a (m :: * -> *) b.
(Typeable a, LFresh m) =>
AlphaCtx -> QName a -> (QName a -> Perm AnyName -> m b) -> m b
swaps' :: AlphaCtx -> Perm AnyName -> QName a -> QName a
$cswaps' :: forall a.
Typeable a =>
AlphaCtx -> Perm AnyName -> QName a -> QName a
namePatFind :: QName a -> NamePatFind
$cnamePatFind :: forall a. Typeable a => QName a -> NamePatFind
nthPatFind :: QName a -> NthPatFind
$cnthPatFind :: forall a. Typeable a => QName a -> NthPatFind
isEmbed :: QName a -> Bool
$cisEmbed :: forall a. Typeable a => QName a -> Bool
isTerm :: QName a -> All
$cisTerm :: forall a. Typeable a => QName a -> All
isPat :: QName a -> DisjointSet AnyName
$cisPat :: forall a. Typeable a => QName a -> DisjointSet AnyName
open :: AlphaCtx -> NthPatFind -> QName a -> QName a
$copen :: forall a.
Typeable a =>
AlphaCtx -> NthPatFind -> QName a -> QName a
close :: AlphaCtx -> NamePatFind -> QName a -> QName a
$cclose :: forall a.
Typeable a =>
AlphaCtx -> NamePatFind -> QName a -> QName a
fvAny' :: AlphaCtx -> (AnyName -> f AnyName) -> QName a -> f (QName a)
$cfvAny' :: forall a (f :: * -> *).
(Typeable a, Contravariant f, Applicative f) =>
AlphaCtx -> (AnyName -> f AnyName) -> QName a -> f (QName a)
aeq' :: AlphaCtx -> QName a -> QName a -> Bool
$caeq' :: forall a. Typeable a => AlphaCtx -> QName a -> QName a -> Bool
$cp1Alpha :: forall a. Typeable a => Show (QName a)
Alpha, Subst Type)

-- | Does this name correspond to a free variable?
isFree :: QName a -> Bool
isFree :: QName a -> Bool
isFree (QName (QualifiedName ModuleName
_) Name a
_) = Bool
True
isFree (QName NameProvenance
LocalName Name a
n)         = Name a -> Bool
forall a. Name a -> Bool
isFreeName Name a
n

-- | Create a locally bound qualified name.
localName :: Name a -> QName a
localName :: Name a -> QName a
localName = NameProvenance -> Name a -> QName a
forall a. NameProvenance -> Name a -> QName a
QName NameProvenance
LocalName

-- | Create a module-bound qualified name.
(.-) :: ModuleName -> Name a -> QName a
ModuleName
m .- :: ModuleName -> Name a -> QName a
.- Name a
x = NameProvenance -> Name a -> QName a
forall a. NameProvenance -> Name a -> QName a
QName (ModuleName -> NameProvenance
QualifiedName ModuleName
m) Name a
x

------------------------------------------------------------
-- Free variables and substitution
------------------------------------------------------------

-- | The @unbound-generics@ library gives us free variables for free.
--   But when dealing with typed and desugared ASTs, we want all the
--   free 'QName's instead of just 'Name's.
fvQ :: (Data t, Typeable e)  => Traversal' t (QName e)
fvQ :: Traversal' t (QName e)
fvQ = (QName e -> f (QName e)) -> t -> f t
forall s a. (Data s, Typeable a) => Traversal' s a
template ((QName e -> f (QName e)) -> t -> f t)
-> ((QName e -> f (QName e)) -> QName e -> f (QName e))
-> (QName e -> f (QName e))
-> t
-> f t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (QName e -> Bool)
-> (QName e -> f (QName e)) -> QName e -> f (QName e)
forall (p :: * -> * -> *) (f :: * -> *) a.
(Choice p, Applicative f) =>
(a -> Bool) -> Optic' p f a a
filtered QName e -> Bool
forall a. QName a -> Bool
isFree

substQ :: Subst b a => QName b -> b -> a -> a
substQ :: QName b -> b -> a -> a
substQ = QName b -> b -> a -> a
forall a. HasCallStack => a
undefined

substsQ :: Subst b a => [(QName b, b)] -> a -> a
substsQ :: [(QName b, b)] -> a -> a
substsQ = [(QName b, b)] -> a -> a
forall a. HasCallStack => a
undefined

------------------------------------------------------------
-- Pretty-printing
------------------------------------------------------------

instance Pretty ModuleName where
  pretty :: ModuleName -> Sem r Doc
pretty ModuleName
REPLModule        = Sem r Doc
"REPL"
  pretty (Named (Dir String
_) String
s) = String -> Sem r Doc
forall (m :: * -> *). Applicative m => String -> m Doc
text (ShowS
dropExtension String
s)
  pretty (Named ModuleProvenance
Stdlib String
s)  = String -> Sem r Doc
forall (m :: * -> *). Applicative m => String -> m Doc
text (ShowS
dropExtension String
s)

instance Pretty (QName a) where
  pretty :: QName a -> Sem r Doc
pretty (QName NameProvenance
LocalName Name a
x)          = Name a -> Sem r Doc
forall t (r :: EffectRow).
(Pretty t, Members '[Reader PA, LFresh] r) =>
t -> Sem r Doc
pretty Name a
x
  pretty (QName (QualifiedName ModuleName
mn) Name a
x) = ModuleName -> Sem r Doc
forall t (r :: EffectRow).
(Pretty t, Members '[Reader PA, LFresh] r) =>
t -> Sem r Doc
pretty ModuleName
mn Sem r Doc -> Sem r Doc -> Sem r Doc
forall (f :: * -> *). Applicative f => f Doc -> f Doc -> f Doc
<> Sem r Doc
"." Sem r Doc -> Sem r Doc -> Sem r Doc
forall (f :: * -> *). Applicative f => f Doc -> f Doc -> f Doc
<> Name a -> Sem r Doc
forall t (r :: EffectRow).
(Pretty t, Members '[Reader PA, LFresh] r) =>
t -> Sem r Doc
pretty Name a
x