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

-----------------------------------------------------------------------------

-----------------------------------------------------------------------------

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

-- |
-- Module      :  Disco.Names
-- Copyright   :  disco team and contributors
-- Maintainer  :  [email protected]
--
-- Names for modules and identifiers.
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 System.FilePath (dropExtension)
import Unbound.Generics.LocallyNameless
import Prelude hiding ((<>))

import Disco.Pretty
import Disco.Types

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

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

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

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

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

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

-- | Does this name correspond to a free variable?
isFree :: QName a -> Bool
isFree :: forall a. 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 :: forall a. 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 .- :: forall a. 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 :: forall t e. (Data t, Typeable e) => Traversal' t (QName e)
fvQ = (QName e -> f (QName e)) -> t -> f t
forall s a. (Data s, Typeable a) => Traversal' s a
Traversal' t (QName e)
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 :: forall b a. Subst b a => 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 :: forall b a. Subst b a => [(QName b, b)] -> a -> a
substsQ = [(QName b, b)] -> a -> a
forall a. HasCallStack => a
undefined

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

instance Pretty ModuleName where
  pretty :: forall (r :: EffectRow) ann.
Members '[Reader PA, LFresh] r =>
ModuleName -> Sem r (Doc ann)
pretty ModuleName
REPLModule = Sem r (Doc ann)
"REPL"
  pretty (Named (Dir FilePath
_) FilePath
s) = FilePath -> Sem r (Doc ann)
forall (m :: * -> *) ann. Applicative m => FilePath -> m (Doc ann)
text (ShowS
dropExtension FilePath
s)
  pretty (Named ModuleProvenance
Stdlib FilePath
s) = FilePath -> Sem r (Doc ann)
forall (m :: * -> *) ann. Applicative m => FilePath -> m (Doc ann)
text (ShowS
dropExtension FilePath
s)

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