{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE OverloadedStrings #-}

{- | The types of identifiers used across the compiler.

The types 'VarId', 'TVarId', 'DConId', and 'TConId' are used in the IR for data
variables, type variables, data constructors, and type constructors, which each
inhabit a separate namespace. The underlying 'Identifier' type is used in the
AST, before these different kinds of identifiers are differentiated by the
lowering phase.

These are defined as newtypes (rather than as type aliases) that ultimately
abstract over the underlying 'String' Identifier. We do this for a few reasons:

    * The particular newtype carries semantic meaning in the IR, e.g., 'VarId'
      is an identifier for data variables and nothing else. This prevents
      semantically distinct items from being used in place of one another
      (without explicit coercion). For example, this will prevent accidentally
      using a type variable identifier as a data constructor.

    * In the future, this may be extended to carry other (non-semantic)
      metadata, such as source code location.

    * It allows us to freely attach typeclass instances to this type without
      FlexibleInstances (since 'String' is a type synonym for @[Char]@).

Users should never need to specifically use the data constructor for each
newtype, e.g., @VarId (Identifier "foo")@. Instead, each identifier belongs to
the 'IsString' typeclass, that can be written as @fromString "foo"@, so that the
appropriate type can be inferred from the context where the identifier is used.
Furthermore, the 'fromString' call can be automatically inserted by the
OverloadedStrings GHC extension, meaning we can just write @"foo"@.

All identifier types are instances of the 'Identifiable' typeclass, which allows
us to write generic functions that operate over any kind of identifier. One can
explicitly convert from an identifier to another using the handy 'fromId'
helper; which /specific/ type of identifier may be inferred from the outer
context, or explicitly annotated (e.g., @fromId i :: VarId@ to construct
a 'VarId' out of identifier @i@).
-}
module Common.Identifiers (
  Identifiable (..),
  IsString (..),
  fromId,
  showId,
  TConId (..),
  TVarId (..),
  DConId (..),
  VarId (..),
  TVarIdx (..),
  CSym (..),
  HasFreeVars (..),
  Identifier (..),
  isCons,
  isVar,
  mangle,
  mangleVars,
  isReserved,
  reserved,
  isGenerated,
  genId,
  ungenId,
  cons,
  nil,
) where

import Common.Pretty (Pretty (..))

import Control.Monad.State (
  MonadState (..),
  State,
  evalState,
 )
import Data.Char (isUpper)
import Data.Generics (
  Data,
  Proxy (Proxy),
  Typeable,
  everywhereM,
  mkM,
 )
import qualified Data.Map as M
import qualified Data.Set as S
import Data.String (IsString (..))

import Language.C (Id (..))
import Language.C.Quote (ToIdent (..))
import Data.List (isPrefixOf)


-- | A type that may be used as a Sslang identifier.
class (IsString i, Ord i, Show i) => Identifiable i where
  ident :: i
    -> String
    -- ^ Obtain its underlying 'String' representation.


-- | Explicitly convert between two types of identifiers.
fromId :: (Identifiable a, Identifiable b) => a -> b
fromId :: a -> b
fromId = String -> b
forall a. IsString a => String -> a
fromString (String -> b) -> (a -> String) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall i. Identifiable i => i -> String
ident


-- | Convert a showable instance to some kind of identifier.
showId :: (Show a, Identifiable b) => a -> b
showId :: a -> b
showId = String -> b
forall a. IsString a => String -> a
fromString (String -> b) -> (a -> String) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show


{- | A generic Sslang identifier.

Used as the type for identifiers in the AST.

Also used as the base type for other identifiers (e.g., 'TConId', 'VarId'),
which derive their typeclass instances from this.
-}
newtype Identifier = Identifier String
  deriving (Identifier -> Identifier -> Bool
(Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool) -> Eq Identifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Identifier -> Identifier -> Bool
$c/= :: Identifier -> Identifier -> Bool
== :: Identifier -> Identifier -> Bool
$c== :: Identifier -> Identifier -> Bool
Eq, Eq Identifier
Eq Identifier
-> (Identifier -> Identifier -> Ordering)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Identifier)
-> (Identifier -> Identifier -> Identifier)
-> Ord Identifier
Identifier -> Identifier -> Bool
Identifier -> Identifier -> Ordering
Identifier -> Identifier -> Identifier
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 :: Identifier -> Identifier -> Identifier
$cmin :: Identifier -> Identifier -> Identifier
max :: Identifier -> Identifier -> Identifier
$cmax :: Identifier -> Identifier -> Identifier
>= :: Identifier -> Identifier -> Bool
$c>= :: Identifier -> Identifier -> Bool
> :: Identifier -> Identifier -> Bool
$c> :: Identifier -> Identifier -> Bool
<= :: Identifier -> Identifier -> Bool
$c<= :: Identifier -> Identifier -> Bool
< :: Identifier -> Identifier -> Bool
$c< :: Identifier -> Identifier -> Bool
compare :: Identifier -> Identifier -> Ordering
$ccompare :: Identifier -> Identifier -> Ordering
$cp1Ord :: Eq Identifier
Ord, Typeable, Typeable Identifier
DataType
Constr
Typeable Identifier
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Identifier -> c Identifier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Identifier)
-> (Identifier -> Constr)
-> (Identifier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Identifier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Identifier))
-> ((forall b. Data b => b -> b) -> Identifier -> Identifier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r)
-> (forall u. (forall d. Data d => d -> u) -> Identifier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Identifier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
-> Data Identifier
Identifier -> DataType
Identifier -> Constr
(forall b. Data b => b -> b) -> Identifier -> Identifier
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
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) -> Identifier -> u
forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Identifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
$cIdentifier :: Constr
$tIdentifier :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Identifier -> m Identifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
gmapMp :: (forall d. Data d => d -> m d) -> Identifier -> m Identifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
gmapM :: (forall d. Data d => d -> m d) -> Identifier -> m Identifier
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
gmapQi :: Int -> (forall d. Data d => d -> u) -> Identifier -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Identifier -> u
gmapQ :: (forall d. Data d => d -> u) -> Identifier -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
gmapT :: (forall b. Data b => b -> b) -> Identifier -> Identifier
$cgmapT :: (forall b. Data b => b -> b) -> Identifier -> Identifier
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Identifier)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Identifier)
dataTypeOf :: Identifier -> DataType
$cdataTypeOf :: Identifier -> DataType
toConstr :: Identifier -> Constr
$ctoConstr :: Identifier -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
$cp1Data :: Typeable Identifier
Data)


instance IsString Identifier where
  fromString :: String -> Identifier
fromString = String -> Identifier
Identifier


instance Identifiable Identifier where
  ident :: Identifier -> String
ident (Identifier String
i) = String
i


instance Show Identifier where
  show :: Identifier -> String
show (Identifier String
i) = String
i


instance ToIdent Identifier where
  toIdent :: Identifier -> SrcLoc -> Id
toIdent (Identifier String
i) = String -> SrcLoc -> Id
Id String
i


instance Semigroup Identifier where
  Identifier String
a <> :: Identifier -> Identifier -> Identifier
<> Identifier String
b = String -> Identifier
Identifier (String -> Identifier) -> String -> Identifier
forall a b. (a -> b) -> a -> b
$ String
a String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
b


instance Monoid Identifier where
  mempty :: Identifier
mempty = String -> Identifier
Identifier String
forall a. Monoid a => a
mempty -- ""


instance Pretty Identifier where
  pretty :: Identifier -> Doc ann
pretty = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann)
-> (Identifier -> String) -> Identifier -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> String
forall i. Identifiable i => i -> String
ident


-- | Identifier for type constructors, e.g., @Option@.
newtype TConId = TConId Identifier
  deriving (TConId -> TConId -> Bool
(TConId -> TConId -> Bool)
-> (TConId -> TConId -> Bool) -> Eq TConId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TConId -> TConId -> Bool
$c/= :: TConId -> TConId -> Bool
== :: TConId -> TConId -> Bool
$c== :: TConId -> TConId -> Bool
Eq)
  deriving (Eq TConId
Eq TConId
-> (TConId -> TConId -> Ordering)
-> (TConId -> TConId -> Bool)
-> (TConId -> TConId -> Bool)
-> (TConId -> TConId -> Bool)
-> (TConId -> TConId -> Bool)
-> (TConId -> TConId -> TConId)
-> (TConId -> TConId -> TConId)
-> Ord TConId
TConId -> TConId -> Bool
TConId -> TConId -> Ordering
TConId -> TConId -> TConId
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 :: TConId -> TConId -> TConId
$cmin :: TConId -> TConId -> TConId
max :: TConId -> TConId -> TConId
$cmax :: TConId -> TConId -> TConId
>= :: TConId -> TConId -> Bool
$c>= :: TConId -> TConId -> Bool
> :: TConId -> TConId -> Bool
$c> :: TConId -> TConId -> Bool
<= :: TConId -> TConId -> Bool
$c<= :: TConId -> TConId -> Bool
< :: TConId -> TConId -> Bool
$c< :: TConId -> TConId -> Bool
compare :: TConId -> TConId -> Ordering
$ccompare :: TConId -> TConId -> Ordering
$cp1Ord :: Eq TConId
Ord)
  deriving (Typeable)
  deriving (Typeable TConId
DataType
Constr
Typeable TConId
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TConId -> c TConId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TConId)
-> (TConId -> Constr)
-> (TConId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TConId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TConId))
-> ((forall b. Data b => b -> b) -> TConId -> TConId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TConId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TConId -> r)
-> (forall u. (forall d. Data d => d -> u) -> TConId -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TConId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TConId -> m TConId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TConId -> m TConId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TConId -> m TConId)
-> Data TConId
TConId -> DataType
TConId -> Constr
(forall b. Data b => b -> b) -> TConId -> TConId
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TConId -> c TConId
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TConId
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) -> TConId -> u
forall u. (forall d. Data d => d -> u) -> TConId -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TConId -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TConId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TConId -> m TConId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TConId -> m TConId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TConId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TConId -> c TConId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TConId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TConId)
$cTConId :: Constr
$tTConId :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TConId -> m TConId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TConId -> m TConId
gmapMp :: (forall d. Data d => d -> m d) -> TConId -> m TConId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TConId -> m TConId
gmapM :: (forall d. Data d => d -> m d) -> TConId -> m TConId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TConId -> m TConId
gmapQi :: Int -> (forall d. Data d => d -> u) -> TConId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TConId -> u
gmapQ :: (forall d. Data d => d -> u) -> TConId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TConId -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TConId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TConId -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TConId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TConId -> r
gmapT :: (forall b. Data b => b -> b) -> TConId -> TConId
$cgmapT :: (forall b. Data b => b -> b) -> TConId -> TConId
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TConId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TConId)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TConId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TConId)
dataTypeOf :: TConId -> DataType
$cdataTypeOf :: TConId -> DataType
toConstr :: TConId -> Constr
$ctoConstr :: TConId -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TConId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TConId
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TConId -> c TConId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TConId -> c TConId
$cp1Data :: Typeable TConId
Data)
  deriving (TConId -> SrcLoc -> Id
(TConId -> SrcLoc -> Id) -> ToIdent TConId
forall a. (a -> SrcLoc -> Id) -> ToIdent a
toIdent :: TConId -> SrcLoc -> Id
$ctoIdent :: TConId -> SrcLoc -> Id
ToIdent) via Identifier
  deriving (String -> TConId
(String -> TConId) -> IsString TConId
forall a. (String -> a) -> IsString a
fromString :: String -> TConId
$cfromString :: String -> TConId
IsString) via Identifier
  deriving (Ord TConId
Show TConId
IsString TConId
IsString TConId
-> Ord TConId
-> Show TConId
-> (TConId -> String)
-> Identifiable TConId
TConId -> String
forall i.
IsString i -> Ord i -> Show i -> (i -> String) -> Identifiable i
ident :: TConId -> String
$cident :: TConId -> String
$cp3Identifiable :: Show TConId
$cp2Identifiable :: Ord TConId
$cp1Identifiable :: IsString TConId
Identifiable) via Identifier
  deriving (b -> TConId -> TConId
NonEmpty TConId -> TConId
TConId -> TConId -> TConId
(TConId -> TConId -> TConId)
-> (NonEmpty TConId -> TConId)
-> (forall b. Integral b => b -> TConId -> TConId)
-> Semigroup TConId
forall b. Integral b => b -> TConId -> TConId
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> TConId -> TConId
$cstimes :: forall b. Integral b => b -> TConId -> TConId
sconcat :: NonEmpty TConId -> TConId
$csconcat :: NonEmpty TConId -> TConId
<> :: TConId -> TConId -> TConId
$c<> :: TConId -> TConId -> TConId
Semigroup) via Identifier
  deriving (Semigroup TConId
TConId
Semigroup TConId
-> TConId
-> (TConId -> TConId -> TConId)
-> ([TConId] -> TConId)
-> Monoid TConId
[TConId] -> TConId
TConId -> TConId -> TConId
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [TConId] -> TConId
$cmconcat :: [TConId] -> TConId
mappend :: TConId -> TConId -> TConId
$cmappend :: TConId -> TConId -> TConId
mempty :: TConId
$cmempty :: TConId
$cp1Monoid :: Semigroup TConId
Monoid) via Identifier
  deriving ([TConId] -> Doc ann
TConId -> Doc ann
(forall ann. TConId -> Doc ann)
-> (forall ann. [TConId] -> Doc ann) -> Pretty TConId
forall ann. [TConId] -> Doc ann
forall ann. TConId -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
prettyList :: [TConId] -> Doc ann
$cprettyList :: forall ann. [TConId] -> Doc ann
pretty :: TConId -> Doc ann
$cpretty :: forall ann. TConId -> Doc ann
Pretty) via Identifier


instance Show TConId where
  show :: TConId -> String
show (TConId Identifier
i) = Identifier -> String
forall a. Show a => a -> String
show Identifier
i


-- | ToIdentifier for type variable, e.g., @a@.
newtype TVarId = TVarId Identifier
  deriving (TVarId -> TVarId -> Bool
(TVarId -> TVarId -> Bool)
-> (TVarId -> TVarId -> Bool) -> Eq TVarId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TVarId -> TVarId -> Bool
$c/= :: TVarId -> TVarId -> Bool
== :: TVarId -> TVarId -> Bool
$c== :: TVarId -> TVarId -> Bool
Eq)
  deriving (Eq TVarId
Eq TVarId
-> (TVarId -> TVarId -> Ordering)
-> (TVarId -> TVarId -> Bool)
-> (TVarId -> TVarId -> Bool)
-> (TVarId -> TVarId -> Bool)
-> (TVarId -> TVarId -> Bool)
-> (TVarId -> TVarId -> TVarId)
-> (TVarId -> TVarId -> TVarId)
-> Ord TVarId
TVarId -> TVarId -> Bool
TVarId -> TVarId -> Ordering
TVarId -> TVarId -> TVarId
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 :: TVarId -> TVarId -> TVarId
$cmin :: TVarId -> TVarId -> TVarId
max :: TVarId -> TVarId -> TVarId
$cmax :: TVarId -> TVarId -> TVarId
>= :: TVarId -> TVarId -> Bool
$c>= :: TVarId -> TVarId -> Bool
> :: TVarId -> TVarId -> Bool
$c> :: TVarId -> TVarId -> Bool
<= :: TVarId -> TVarId -> Bool
$c<= :: TVarId -> TVarId -> Bool
< :: TVarId -> TVarId -> Bool
$c< :: TVarId -> TVarId -> Bool
compare :: TVarId -> TVarId -> Ordering
$ccompare :: TVarId -> TVarId -> Ordering
$cp1Ord :: Eq TVarId
Ord)
  deriving (Typeable)
  deriving (Typeable TVarId
DataType
Constr
Typeable TVarId
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TVarId -> c TVarId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TVarId)
-> (TVarId -> Constr)
-> (TVarId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TVarId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TVarId))
-> ((forall b. Data b => b -> b) -> TVarId -> TVarId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TVarId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TVarId -> r)
-> (forall u. (forall d. Data d => d -> u) -> TVarId -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TVarId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TVarId -> m TVarId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TVarId -> m TVarId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TVarId -> m TVarId)
-> Data TVarId
TVarId -> DataType
TVarId -> Constr
(forall b. Data b => b -> b) -> TVarId -> TVarId
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TVarId -> c TVarId
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TVarId
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) -> TVarId -> u
forall u. (forall d. Data d => d -> u) -> TVarId -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TVarId -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TVarId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TVarId -> m TVarId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TVarId -> m TVarId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TVarId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TVarId -> c TVarId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TVarId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TVarId)
$cTVarId :: Constr
$tTVarId :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TVarId -> m TVarId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TVarId -> m TVarId
gmapMp :: (forall d. Data d => d -> m d) -> TVarId -> m TVarId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TVarId -> m TVarId
gmapM :: (forall d. Data d => d -> m d) -> TVarId -> m TVarId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TVarId -> m TVarId
gmapQi :: Int -> (forall d. Data d => d -> u) -> TVarId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TVarId -> u
gmapQ :: (forall d. Data d => d -> u) -> TVarId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TVarId -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TVarId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TVarId -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TVarId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TVarId -> r
gmapT :: (forall b. Data b => b -> b) -> TVarId -> TVarId
$cgmapT :: (forall b. Data b => b -> b) -> TVarId -> TVarId
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TVarId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TVarId)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TVarId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TVarId)
dataTypeOf :: TVarId -> DataType
$cdataTypeOf :: TVarId -> DataType
toConstr :: TVarId -> Constr
$ctoConstr :: TVarId -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TVarId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TVarId
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TVarId -> c TVarId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TVarId -> c TVarId
$cp1Data :: Typeable TVarId
Data)
  deriving (TVarId -> SrcLoc -> Id
(TVarId -> SrcLoc -> Id) -> ToIdent TVarId
forall a. (a -> SrcLoc -> Id) -> ToIdent a
toIdent :: TVarId -> SrcLoc -> Id
$ctoIdent :: TVarId -> SrcLoc -> Id
ToIdent) via Identifier
  deriving (String -> TVarId
(String -> TVarId) -> IsString TVarId
forall a. (String -> a) -> IsString a
fromString :: String -> TVarId
$cfromString :: String -> TVarId
IsString) via Identifier
  deriving (Ord TVarId
Show TVarId
IsString TVarId
IsString TVarId
-> Ord TVarId
-> Show TVarId
-> (TVarId -> String)
-> Identifiable TVarId
TVarId -> String
forall i.
IsString i -> Ord i -> Show i -> (i -> String) -> Identifiable i
ident :: TVarId -> String
$cident :: TVarId -> String
$cp3Identifiable :: Show TVarId
$cp2Identifiable :: Ord TVarId
$cp1Identifiable :: IsString TVarId
Identifiable) via Identifier
  deriving (b -> TVarId -> TVarId
NonEmpty TVarId -> TVarId
TVarId -> TVarId -> TVarId
(TVarId -> TVarId -> TVarId)
-> (NonEmpty TVarId -> TVarId)
-> (forall b. Integral b => b -> TVarId -> TVarId)
-> Semigroup TVarId
forall b. Integral b => b -> TVarId -> TVarId
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> TVarId -> TVarId
$cstimes :: forall b. Integral b => b -> TVarId -> TVarId
sconcat :: NonEmpty TVarId -> TVarId
$csconcat :: NonEmpty TVarId -> TVarId
<> :: TVarId -> TVarId -> TVarId
$c<> :: TVarId -> TVarId -> TVarId
Semigroup) via Identifier
  deriving (Semigroup TVarId
TVarId
Semigroup TVarId
-> TVarId
-> (TVarId -> TVarId -> TVarId)
-> ([TVarId] -> TVarId)
-> Monoid TVarId
[TVarId] -> TVarId
TVarId -> TVarId -> TVarId
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [TVarId] -> TVarId
$cmconcat :: [TVarId] -> TVarId
mappend :: TVarId -> TVarId -> TVarId
$cmappend :: TVarId -> TVarId -> TVarId
mempty :: TVarId
$cmempty :: TVarId
$cp1Monoid :: Semigroup TVarId
Monoid) via Identifier
  deriving ([TVarId] -> Doc ann
TVarId -> Doc ann
(forall ann. TVarId -> Doc ann)
-> (forall ann. [TVarId] -> Doc ann) -> Pretty TVarId
forall ann. [TVarId] -> Doc ann
forall ann. TVarId -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
prettyList :: [TVarId] -> Doc ann
$cprettyList :: forall ann. [TVarId] -> Doc ann
pretty :: TVarId -> Doc ann
$cpretty :: forall ann. TVarId -> Doc ann
Pretty) via Identifier


instance Show TVarId where
  show :: TVarId -> String
show (TVarId Identifier
i) = Identifier -> String
forall a. Show a => a -> String
show Identifier
i


-- | Identifier for data constructors, e.g., @None@.
newtype DConId = DConId Identifier
  deriving (DConId -> DConId -> Bool
(DConId -> DConId -> Bool)
-> (DConId -> DConId -> Bool) -> Eq DConId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DConId -> DConId -> Bool
$c/= :: DConId -> DConId -> Bool
== :: DConId -> DConId -> Bool
$c== :: DConId -> DConId -> Bool
Eq)
  deriving (Int -> DConId -> ShowS
[DConId] -> ShowS
DConId -> String
(Int -> DConId -> ShowS)
-> (DConId -> String) -> ([DConId] -> ShowS) -> Show DConId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DConId] -> ShowS
$cshowList :: [DConId] -> ShowS
show :: DConId -> String
$cshow :: DConId -> String
showsPrec :: Int -> DConId -> ShowS
$cshowsPrec :: Int -> DConId -> ShowS
Show)
  deriving (Eq DConId
Eq DConId
-> (DConId -> DConId -> Ordering)
-> (DConId -> DConId -> Bool)
-> (DConId -> DConId -> Bool)
-> (DConId -> DConId -> Bool)
-> (DConId -> DConId -> Bool)
-> (DConId -> DConId -> DConId)
-> (DConId -> DConId -> DConId)
-> Ord DConId
DConId -> DConId -> Bool
DConId -> DConId -> Ordering
DConId -> DConId -> DConId
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 :: DConId -> DConId -> DConId
$cmin :: DConId -> DConId -> DConId
max :: DConId -> DConId -> DConId
$cmax :: DConId -> DConId -> DConId
>= :: DConId -> DConId -> Bool
$c>= :: DConId -> DConId -> Bool
> :: DConId -> DConId -> Bool
$c> :: DConId -> DConId -> Bool
<= :: DConId -> DConId -> Bool
$c<= :: DConId -> DConId -> Bool
< :: DConId -> DConId -> Bool
$c< :: DConId -> DConId -> Bool
compare :: DConId -> DConId -> Ordering
$ccompare :: DConId -> DConId -> Ordering
$cp1Ord :: Eq DConId
Ord)
  deriving (Typeable)
  deriving (Typeable DConId
DataType
Constr
Typeable DConId
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DConId -> c DConId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DConId)
-> (DConId -> Constr)
-> (DConId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DConId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DConId))
-> ((forall b. Data b => b -> b) -> DConId -> DConId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DConId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DConId -> r)
-> (forall u. (forall d. Data d => d -> u) -> DConId -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DConId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DConId -> m DConId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DConId -> m DConId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DConId -> m DConId)
-> Data DConId
DConId -> DataType
DConId -> Constr
(forall b. Data b => b -> b) -> DConId -> DConId
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DConId -> c DConId
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DConId
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) -> DConId -> u
forall u. (forall d. Data d => d -> u) -> DConId -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DConId -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DConId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DConId -> m DConId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DConId -> m DConId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DConId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DConId -> c DConId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DConId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DConId)
$cDConId :: Constr
$tDConId :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DConId -> m DConId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DConId -> m DConId
gmapMp :: (forall d. Data d => d -> m d) -> DConId -> m DConId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DConId -> m DConId
gmapM :: (forall d. Data d => d -> m d) -> DConId -> m DConId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DConId -> m DConId
gmapQi :: Int -> (forall d. Data d => d -> u) -> DConId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DConId -> u
gmapQ :: (forall d. Data d => d -> u) -> DConId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DConId -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DConId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DConId -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DConId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DConId -> r
gmapT :: (forall b. Data b => b -> b) -> DConId -> DConId
$cgmapT :: (forall b. Data b => b -> b) -> DConId -> DConId
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DConId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DConId)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DConId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DConId)
dataTypeOf :: DConId -> DataType
$cdataTypeOf :: DConId -> DataType
toConstr :: DConId -> Constr
$ctoConstr :: DConId -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DConId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DConId
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DConId -> c DConId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DConId -> c DConId
$cp1Data :: Typeable DConId
Data)
  deriving (DConId -> SrcLoc -> Id
(DConId -> SrcLoc -> Id) -> ToIdent DConId
forall a. (a -> SrcLoc -> Id) -> ToIdent a
toIdent :: DConId -> SrcLoc -> Id
$ctoIdent :: DConId -> SrcLoc -> Id
ToIdent) via Identifier
  deriving (String -> DConId
(String -> DConId) -> IsString DConId
forall a. (String -> a) -> IsString a
fromString :: String -> DConId
$cfromString :: String -> DConId
IsString) via Identifier
  deriving (Ord DConId
Show DConId
IsString DConId
IsString DConId
-> Ord DConId
-> Show DConId
-> (DConId -> String)
-> Identifiable DConId
DConId -> String
forall i.
IsString i -> Ord i -> Show i -> (i -> String) -> Identifiable i
ident :: DConId -> String
$cident :: DConId -> String
$cp3Identifiable :: Show DConId
$cp2Identifiable :: Ord DConId
$cp1Identifiable :: IsString DConId
Identifiable) via Identifier
  deriving (b -> DConId -> DConId
NonEmpty DConId -> DConId
DConId -> DConId -> DConId
(DConId -> DConId -> DConId)
-> (NonEmpty DConId -> DConId)
-> (forall b. Integral b => b -> DConId -> DConId)
-> Semigroup DConId
forall b. Integral b => b -> DConId -> DConId
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> DConId -> DConId
$cstimes :: forall b. Integral b => b -> DConId -> DConId
sconcat :: NonEmpty DConId -> DConId
$csconcat :: NonEmpty DConId -> DConId
<> :: DConId -> DConId -> DConId
$c<> :: DConId -> DConId -> DConId
Semigroup) via Identifier
  deriving (Semigroup DConId
DConId
Semigroup DConId
-> DConId
-> (DConId -> DConId -> DConId)
-> ([DConId] -> DConId)
-> Monoid DConId
[DConId] -> DConId
DConId -> DConId -> DConId
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [DConId] -> DConId
$cmconcat :: [DConId] -> DConId
mappend :: DConId -> DConId -> DConId
$cmappend :: DConId -> DConId -> DConId
mempty :: DConId
$cmempty :: DConId
$cp1Monoid :: Semigroup DConId
Monoid) via Identifier
  deriving ([DConId] -> Doc ann
DConId -> Doc ann
(forall ann. DConId -> Doc ann)
-> (forall ann. [DConId] -> Doc ann) -> Pretty DConId
forall ann. [DConId] -> Doc ann
forall ann. DConId -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
prettyList :: [DConId] -> Doc ann
$cprettyList :: forall ann. [DConId] -> Doc ann
pretty :: DConId -> Doc ann
$cpretty :: forall ann. DConId -> Doc ann
Pretty) via Identifier


-- | Identifier for data variables, e.g., @x@.
newtype VarId = VarId Identifier
  deriving (VarId -> VarId -> Bool
(VarId -> VarId -> Bool) -> (VarId -> VarId -> Bool) -> Eq VarId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VarId -> VarId -> Bool
$c/= :: VarId -> VarId -> Bool
== :: VarId -> VarId -> Bool
$c== :: VarId -> VarId -> Bool
Eq)
  deriving (Int -> VarId -> ShowS
[VarId] -> ShowS
VarId -> String
(Int -> VarId -> ShowS)
-> (VarId -> String) -> ([VarId] -> ShowS) -> Show VarId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VarId] -> ShowS
$cshowList :: [VarId] -> ShowS
show :: VarId -> String
$cshow :: VarId -> String
showsPrec :: Int -> VarId -> ShowS
$cshowsPrec :: Int -> VarId -> ShowS
Show)
  deriving (Eq VarId
Eq VarId
-> (VarId -> VarId -> Ordering)
-> (VarId -> VarId -> Bool)
-> (VarId -> VarId -> Bool)
-> (VarId -> VarId -> Bool)
-> (VarId -> VarId -> Bool)
-> (VarId -> VarId -> VarId)
-> (VarId -> VarId -> VarId)
-> Ord VarId
VarId -> VarId -> Bool
VarId -> VarId -> Ordering
VarId -> VarId -> VarId
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 :: VarId -> VarId -> VarId
$cmin :: VarId -> VarId -> VarId
max :: VarId -> VarId -> VarId
$cmax :: VarId -> VarId -> VarId
>= :: VarId -> VarId -> Bool
$c>= :: VarId -> VarId -> Bool
> :: VarId -> VarId -> Bool
$c> :: VarId -> VarId -> Bool
<= :: VarId -> VarId -> Bool
$c<= :: VarId -> VarId -> Bool
< :: VarId -> VarId -> Bool
$c< :: VarId -> VarId -> Bool
compare :: VarId -> VarId -> Ordering
$ccompare :: VarId -> VarId -> Ordering
$cp1Ord :: Eq VarId
Ord)
  deriving (Typeable)
  deriving (Typeable VarId
DataType
Constr
Typeable VarId
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VarId -> c VarId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VarId)
-> (VarId -> Constr)
-> (VarId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c VarId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarId))
-> ((forall b. Data b => b -> b) -> VarId -> VarId)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarId -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarId -> r)
-> (forall u. (forall d. Data d => d -> u) -> VarId -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> VarId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> VarId -> m VarId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VarId -> m VarId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VarId -> m VarId)
-> Data VarId
VarId -> DataType
VarId -> Constr
(forall b. Data b => b -> b) -> VarId -> VarId
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarId -> c VarId
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarId
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) -> VarId -> u
forall u. (forall d. Data d => d -> u) -> VarId -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarId -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarId -> m VarId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarId -> m VarId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarId -> c VarId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarId)
$cVarId :: Constr
$tVarId :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> VarId -> m VarId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarId -> m VarId
gmapMp :: (forall d. Data d => d -> m d) -> VarId -> m VarId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarId -> m VarId
gmapM :: (forall d. Data d => d -> m d) -> VarId -> m VarId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarId -> m VarId
gmapQi :: Int -> (forall d. Data d => d -> u) -> VarId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarId -> u
gmapQ :: (forall d. Data d => d -> u) -> VarId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VarId -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarId -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarId -> r
gmapT :: (forall b. Data b => b -> b) -> VarId -> VarId
$cgmapT :: (forall b. Data b => b -> b) -> VarId -> VarId
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarId)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c VarId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarId)
dataTypeOf :: VarId -> DataType
$cdataTypeOf :: VarId -> DataType
toConstr :: VarId -> Constr
$ctoConstr :: VarId -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarId
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarId -> c VarId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarId -> c VarId
$cp1Data :: Typeable VarId
Data)
  deriving (VarId -> SrcLoc -> Id
(VarId -> SrcLoc -> Id) -> ToIdent VarId
forall a. (a -> SrcLoc -> Id) -> ToIdent a
toIdent :: VarId -> SrcLoc -> Id
$ctoIdent :: VarId -> SrcLoc -> Id
ToIdent) via Identifier
  deriving (String -> VarId
(String -> VarId) -> IsString VarId
forall a. (String -> a) -> IsString a
fromString :: String -> VarId
$cfromString :: String -> VarId
IsString) via Identifier
  deriving (Ord VarId
Show VarId
IsString VarId
IsString VarId
-> Ord VarId
-> Show VarId
-> (VarId -> String)
-> Identifiable VarId
VarId -> String
forall i.
IsString i -> Ord i -> Show i -> (i -> String) -> Identifiable i
ident :: VarId -> String
$cident :: VarId -> String
$cp3Identifiable :: Show VarId
$cp2Identifiable :: Ord VarId
$cp1Identifiable :: IsString VarId
Identifiable) via Identifier
  deriving (b -> VarId -> VarId
NonEmpty VarId -> VarId
VarId -> VarId -> VarId
(VarId -> VarId -> VarId)
-> (NonEmpty VarId -> VarId)
-> (forall b. Integral b => b -> VarId -> VarId)
-> Semigroup VarId
forall b. Integral b => b -> VarId -> VarId
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> VarId -> VarId
$cstimes :: forall b. Integral b => b -> VarId -> VarId
sconcat :: NonEmpty VarId -> VarId
$csconcat :: NonEmpty VarId -> VarId
<> :: VarId -> VarId -> VarId
$c<> :: VarId -> VarId -> VarId
Semigroup) via Identifier
  deriving (Semigroup VarId
VarId
Semigroup VarId
-> VarId
-> (VarId -> VarId -> VarId)
-> ([VarId] -> VarId)
-> Monoid VarId
[VarId] -> VarId
VarId -> VarId -> VarId
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [VarId] -> VarId
$cmconcat :: [VarId] -> VarId
mappend :: VarId -> VarId -> VarId
$cmappend :: VarId -> VarId -> VarId
mempty :: VarId
$cmempty :: VarId
$cp1Monoid :: Semigroup VarId
Monoid) via Identifier
  deriving ([VarId] -> Doc ann
VarId -> Doc ann
(forall ann. VarId -> Doc ann)
-> (forall ann. [VarId] -> Doc ann) -> Pretty VarId
forall ann. [VarId] -> Doc ann
forall ann. VarId -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
prettyList :: [VarId] -> Doc ann
$cprettyList :: forall ann. [VarId] -> Doc ann
pretty :: VarId -> Doc ann
$cpretty :: forall ann. VarId -> Doc ann
Pretty) via Identifier


-- | Identifier for C symbols, e.g., @printf@.
newtype CSym = CSym Identifier
  deriving (CSym -> CSym -> Bool
(CSym -> CSym -> Bool) -> (CSym -> CSym -> Bool) -> Eq CSym
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CSym -> CSym -> Bool
$c/= :: CSym -> CSym -> Bool
== :: CSym -> CSym -> Bool
$c== :: CSym -> CSym -> Bool
Eq)
  deriving (Int -> CSym -> ShowS
[CSym] -> ShowS
CSym -> String
(Int -> CSym -> ShowS)
-> (CSym -> String) -> ([CSym] -> ShowS) -> Show CSym
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CSym] -> ShowS
$cshowList :: [CSym] -> ShowS
show :: CSym -> String
$cshow :: CSym -> String
showsPrec :: Int -> CSym -> ShowS
$cshowsPrec :: Int -> CSym -> ShowS
Show)
  deriving (Eq CSym
Eq CSym
-> (CSym -> CSym -> Ordering)
-> (CSym -> CSym -> Bool)
-> (CSym -> CSym -> Bool)
-> (CSym -> CSym -> Bool)
-> (CSym -> CSym -> Bool)
-> (CSym -> CSym -> CSym)
-> (CSym -> CSym -> CSym)
-> Ord CSym
CSym -> CSym -> Bool
CSym -> CSym -> Ordering
CSym -> CSym -> CSym
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 :: CSym -> CSym -> CSym
$cmin :: CSym -> CSym -> CSym
max :: CSym -> CSym -> CSym
$cmax :: CSym -> CSym -> CSym
>= :: CSym -> CSym -> Bool
$c>= :: CSym -> CSym -> Bool
> :: CSym -> CSym -> Bool
$c> :: CSym -> CSym -> Bool
<= :: CSym -> CSym -> Bool
$c<= :: CSym -> CSym -> Bool
< :: CSym -> CSym -> Bool
$c< :: CSym -> CSym -> Bool
compare :: CSym -> CSym -> Ordering
$ccompare :: CSym -> CSym -> Ordering
$cp1Ord :: Eq CSym
Ord)
  deriving (Typeable)
  deriving (Typeable CSym
DataType
Constr
Typeable CSym
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CSym -> c CSym)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CSym)
-> (CSym -> Constr)
-> (CSym -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CSym))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CSym))
-> ((forall b. Data b => b -> b) -> CSym -> CSym)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CSym -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CSym -> r)
-> (forall u. (forall d. Data d => d -> u) -> CSym -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CSym -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CSym -> m CSym)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CSym -> m CSym)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CSym -> m CSym)
-> Data CSym
CSym -> DataType
CSym -> Constr
(forall b. Data b => b -> b) -> CSym -> CSym
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CSym -> c CSym
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CSym
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) -> CSym -> u
forall u. (forall d. Data d => d -> u) -> CSym -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CSym -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CSym -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CSym -> m CSym
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CSym -> m CSym
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CSym
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CSym -> c CSym
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CSym)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CSym)
$cCSym :: Constr
$tCSym :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CSym -> m CSym
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CSym -> m CSym
gmapMp :: (forall d. Data d => d -> m d) -> CSym -> m CSym
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CSym -> m CSym
gmapM :: (forall d. Data d => d -> m d) -> CSym -> m CSym
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CSym -> m CSym
gmapQi :: Int -> (forall d. Data d => d -> u) -> CSym -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CSym -> u
gmapQ :: (forall d. Data d => d -> u) -> CSym -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CSym -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CSym -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CSym -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CSym -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CSym -> r
gmapT :: (forall b. Data b => b -> b) -> CSym -> CSym
$cgmapT :: (forall b. Data b => b -> b) -> CSym -> CSym
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CSym)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CSym)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CSym)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CSym)
dataTypeOf :: CSym -> DataType
$cdataTypeOf :: CSym -> DataType
toConstr :: CSym -> Constr
$ctoConstr :: CSym -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CSym
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CSym
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CSym -> c CSym
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CSym -> c CSym
$cp1Data :: Typeable CSym
Data)
  deriving (CSym -> SrcLoc -> Id
(CSym -> SrcLoc -> Id) -> ToIdent CSym
forall a. (a -> SrcLoc -> Id) -> ToIdent a
toIdent :: CSym -> SrcLoc -> Id
$ctoIdent :: CSym -> SrcLoc -> Id
ToIdent) via Identifier
  deriving (String -> CSym
(String -> CSym) -> IsString CSym
forall a. (String -> a) -> IsString a
fromString :: String -> CSym
$cfromString :: String -> CSym
IsString) via Identifier
  deriving (Ord CSym
Show CSym
IsString CSym
IsString CSym
-> Ord CSym -> Show CSym -> (CSym -> String) -> Identifiable CSym
CSym -> String
forall i.
IsString i -> Ord i -> Show i -> (i -> String) -> Identifiable i
ident :: CSym -> String
$cident :: CSym -> String
$cp3Identifiable :: Show CSym
$cp2Identifiable :: Ord CSym
$cp1Identifiable :: IsString CSym
Identifiable) via Identifier
  deriving (b -> CSym -> CSym
NonEmpty CSym -> CSym
CSym -> CSym -> CSym
(CSym -> CSym -> CSym)
-> (NonEmpty CSym -> CSym)
-> (forall b. Integral b => b -> CSym -> CSym)
-> Semigroup CSym
forall b. Integral b => b -> CSym -> CSym
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> CSym -> CSym
$cstimes :: forall b. Integral b => b -> CSym -> CSym
sconcat :: NonEmpty CSym -> CSym
$csconcat :: NonEmpty CSym -> CSym
<> :: CSym -> CSym -> CSym
$c<> :: CSym -> CSym -> CSym
Semigroup) via Identifier
  deriving (Semigroup CSym
CSym
Semigroup CSym
-> CSym
-> (CSym -> CSym -> CSym)
-> ([CSym] -> CSym)
-> Monoid CSym
[CSym] -> CSym
CSym -> CSym -> CSym
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [CSym] -> CSym
$cmconcat :: [CSym] -> CSym
mappend :: CSym -> CSym -> CSym
$cmappend :: CSym -> CSym -> CSym
mempty :: CSym
$cmempty :: CSym
$cp1Monoid :: Semigroup CSym
Monoid) via Identifier
  deriving ([CSym] -> Doc ann
CSym -> Doc ann
(forall ann. CSym -> Doc ann)
-> (forall ann. [CSym] -> Doc ann) -> Pretty CSym
forall ann. [CSym] -> Doc ann
forall ann. CSym -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
prettyList :: [CSym] -> Doc ann
$cprettyList :: forall ann. [CSym] -> Doc ann
pretty :: CSym -> Doc ann
$cpretty :: forall ann. CSym -> Doc ann
Pretty) via Identifier


-- | de Bruijn index for type variables, e.g., @'0@
newtype TVarIdx = TVarIdx Int
  deriving (TVarIdx -> TVarIdx -> Bool
(TVarIdx -> TVarIdx -> Bool)
-> (TVarIdx -> TVarIdx -> Bool) -> Eq TVarIdx
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TVarIdx -> TVarIdx -> Bool
$c/= :: TVarIdx -> TVarIdx -> Bool
== :: TVarIdx -> TVarIdx -> Bool
$c== :: TVarIdx -> TVarIdx -> Bool
Eq)
  deriving (Eq TVarIdx
Eq TVarIdx
-> (TVarIdx -> TVarIdx -> Ordering)
-> (TVarIdx -> TVarIdx -> Bool)
-> (TVarIdx -> TVarIdx -> Bool)
-> (TVarIdx -> TVarIdx -> Bool)
-> (TVarIdx -> TVarIdx -> Bool)
-> (TVarIdx -> TVarIdx -> TVarIdx)
-> (TVarIdx -> TVarIdx -> TVarIdx)
-> Ord TVarIdx
TVarIdx -> TVarIdx -> Bool
TVarIdx -> TVarIdx -> Ordering
TVarIdx -> TVarIdx -> TVarIdx
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 :: TVarIdx -> TVarIdx -> TVarIdx
$cmin :: TVarIdx -> TVarIdx -> TVarIdx
max :: TVarIdx -> TVarIdx -> TVarIdx
$cmax :: TVarIdx -> TVarIdx -> TVarIdx
>= :: TVarIdx -> TVarIdx -> Bool
$c>= :: TVarIdx -> TVarIdx -> Bool
> :: TVarIdx -> TVarIdx -> Bool
$c> :: TVarIdx -> TVarIdx -> Bool
<= :: TVarIdx -> TVarIdx -> Bool
$c<= :: TVarIdx -> TVarIdx -> Bool
< :: TVarIdx -> TVarIdx -> Bool
$c< :: TVarIdx -> TVarIdx -> Bool
compare :: TVarIdx -> TVarIdx -> Ordering
$ccompare :: TVarIdx -> TVarIdx -> Ordering
$cp1Ord :: Eq TVarIdx
Ord)
  deriving (Typeable)
  deriving (Typeable TVarIdx
DataType
Constr
Typeable TVarIdx
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TVarIdx -> c TVarIdx)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TVarIdx)
-> (TVarIdx -> Constr)
-> (TVarIdx -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TVarIdx))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TVarIdx))
-> ((forall b. Data b => b -> b) -> TVarIdx -> TVarIdx)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TVarIdx -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TVarIdx -> r)
-> (forall u. (forall d. Data d => d -> u) -> TVarIdx -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TVarIdx -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TVarIdx -> m TVarIdx)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TVarIdx -> m TVarIdx)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TVarIdx -> m TVarIdx)
-> Data TVarIdx
TVarIdx -> DataType
TVarIdx -> Constr
(forall b. Data b => b -> b) -> TVarIdx -> TVarIdx
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TVarIdx -> c TVarIdx
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TVarIdx
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) -> TVarIdx -> u
forall u. (forall d. Data d => d -> u) -> TVarIdx -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TVarIdx -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TVarIdx -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TVarIdx -> m TVarIdx
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TVarIdx -> m TVarIdx
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TVarIdx
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TVarIdx -> c TVarIdx
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TVarIdx)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TVarIdx)
$cTVarIdx :: Constr
$tTVarIdx :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TVarIdx -> m TVarIdx
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TVarIdx -> m TVarIdx
gmapMp :: (forall d. Data d => d -> m d) -> TVarIdx -> m TVarIdx
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TVarIdx -> m TVarIdx
gmapM :: (forall d. Data d => d -> m d) -> TVarIdx -> m TVarIdx
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TVarIdx -> m TVarIdx
gmapQi :: Int -> (forall d. Data d => d -> u) -> TVarIdx -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TVarIdx -> u
gmapQ :: (forall d. Data d => d -> u) -> TVarIdx -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TVarIdx -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TVarIdx -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TVarIdx -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TVarIdx -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TVarIdx -> r
gmapT :: (forall b. Data b => b -> b) -> TVarIdx -> TVarIdx
$cgmapT :: (forall b. Data b => b -> b) -> TVarIdx -> TVarIdx
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TVarIdx)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TVarIdx)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TVarIdx)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TVarIdx)
dataTypeOf :: TVarIdx -> DataType
$cdataTypeOf :: TVarIdx -> DataType
toConstr :: TVarIdx -> Constr
$ctoConstr :: TVarIdx -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TVarIdx
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TVarIdx
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TVarIdx -> c TVarIdx
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TVarIdx -> c TVarIdx
$cp1Data :: Typeable TVarIdx
Data)


instance Show TVarIdx where
  show :: TVarIdx -> String
show (TVarIdx Int
i) = String
"'" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
i


instance Pretty TVarIdx where
  pretty :: TVarIdx -> Doc ann
pretty = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann) -> (TVarIdx -> String) -> TVarIdx -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVarIdx -> String
forall a. Show a => a -> String
show


-- | Terms @t@ that have free variables @i@
class Identifiable i => HasFreeVars t i | t -> i where
  freeVars :: t -> S.Set i


-- | Whether an identifier refers to a type or data constructor.
isCons :: Identifiable a => a -> Bool
isCons :: a -> Bool
isCons a
i
  | String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
s = Bool
False
  | Bool
otherwise = Char -> Bool
isUpper (String -> Char
forall a. [a] -> a
head String
s) Bool -> Bool -> Bool
|| String -> Char
forall a. [a] -> a
head String
s Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
':' Bool -> Bool -> Bool
&& String -> Char
forall a. [a] -> a
last String
s Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
':'
 where
  s :: String
s = a -> String
forall i. Identifiable i => i -> String
ident a
i


{- | Whether an identifier refers to a type or data variable.

 Note that internal variables (i.e., 'isIVar') are also considered variables.
-}
isVar :: Identifiable a => a -> Bool
isVar :: a -> Bool
isVar = Bool -> Bool
not (Bool -> Bool) -> (a -> Bool) -> a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
forall a. Identifiable a => a -> Bool
isCons


-- | Create a reserved identifier (that can be code-generated as long as a can)
reserved :: Identifiable a => a -> a
reserved :: a -> a
reserved a
a = String -> a
forall a. IsString a => String -> a
fromString (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ String
"__sslang_builtin__" String -> ShowS
forall a. Semigroup a => a -> a -> a
<> a -> String
forall i. Identifiable i => i -> String
ident a
a


-- | Whether an identifier is reserved.
isReserved :: Identifiable a => a -> Bool
isReserved :: a -> Bool
isReserved a
i = String
"__sslang_builtin__" String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` String
s
  where s :: String
s = a -> String
forall i. Identifiable i => i -> String
ident a
i

-- | Whether an identifier is an compiler-generated variable name.
isGenerated :: Identifiable a => a -> Bool
isGenerated :: a -> Bool
isGenerated a
i
  | String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
s = Bool
False
  | Bool
otherwise = String -> Char
forall a. [a] -> a
head String
s Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'(' Bool -> Bool -> Bool
&& String -> Char
forall a. [a] -> a
last String
s Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
')'
 where
  s :: String
s = a -> String
forall i. Identifiable i => i -> String
ident a
i


-- | Generate an internal variable name (parenthesized) from some hint.
genId :: Identifiable a => a -> a
genId :: a -> a
genId a
i
  | String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
s = String -> a
forall a. IsString a => String -> a
fromString String
"(_)"
  | Bool
otherwise = String -> a
forall a. IsString a => String -> a
fromString (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ String
"(" String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
s String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
")"
 where
  s :: String
s = a -> String
forall i. Identifiable i => i -> String
ident a
i


-- | Filter out generated identifiers.
ungenId :: Identifiable a => a -> Maybe a
ungenId :: a -> Maybe a
ungenId a
i
  | a -> Bool
forall a. Identifiable a => a -> Bool
isGenerated a
i = Maybe a
forall a. Maybe a
Nothing
  | Bool
otherwise = a -> Maybe a
forall a. a -> Maybe a
Just a
i


{- | Mangle all identifiers in some data structure.

This function is useful for preserving the general syntactic structure of
a datum without inspecting the /specific/ identifiers used within. This is
useful for comparing ASTs modulo alpha renaming.

The @Proxy i@ parameter is used to specify exactly which kind of identifier to
mangle. For instance, to mangle all 'VarId' nodes:

> mangleVarId :: Data a => a -> a
> mangleVarId = mangle (Proxy :: VarId)
-}
mangle :: (Identifiable i, Data i, Data a) => Proxy i -> a -> a
mangle :: Proxy i -> a -> a
mangle Proxy i
p a
d = GenericM (StateT (Int, Map i i) Identity)
-> a -> StateT (Int, Map i i) Identity a
forall (m :: * -> *). Monad m => GenericM m -> GenericM m
everywhereM ((i -> StateT (Int, Map i i) Identity i)
-> a -> StateT (Int, Map i i) Identity a
forall (m :: * -> *) a b.
(Monad m, Typeable a, Typeable b) =>
(b -> m b) -> a -> m a
mkM ((i -> StateT (Int, Map i i) Identity i)
 -> a -> StateT (Int, Map i i) Identity a)
-> (i -> StateT (Int, Map i i) Identity i)
-> a
-> StateT (Int, Map i i) Identity a
forall a b. (a -> b) -> a -> b
$ Proxy i -> i -> StateT (Int, Map i i) Identity i
forall i.
(Identifiable i, Data i) =>
Proxy i -> i -> State (Int, Map i i) i
mang Proxy i
p) a
d StateT (Int, Map i i) Identity a -> (Int, Map i i) -> a
forall s a. State s a -> s -> a
`evalState` (Int
0, Map i i
forall k a. Map k a
M.empty)
 where
  mang :: (Identifiable i, Data i) => Proxy i -> i -> State (Int, M.Map i i) i
  mang :: Proxy i -> i -> State (Int, Map i i) i
mang Proxy i
_ i
i = do
    (Int
ctr, Map i i
idMap) <- StateT (Int, Map i i) Identity (Int, Map i i)
forall s (m :: * -> *). MonadState s m => m s
get
    case i -> Map i i -> Maybe i
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup i
i Map i i
idMap of
      Just i
i' -> i -> State (Int, Map i i) i
forall (m :: * -> *) a. Monad m => a -> m a
return i
i'
      Maybe i
Nothing -> do
        let ctr' :: Int
ctr' = Int
ctr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
            i' :: i
i' = i -> i
forall a. Identifiable a => a -> a
genId (i -> i) -> i -> i
forall a b. (a -> b) -> a -> b
$ String -> i
forall a. IsString a => String -> a
fromString (String -> i) -> String -> i
forall a b. (a -> b) -> a -> b
$ Int -> String
forall a. Show a => a -> String
show Int
ctr'
        (Int, Map i i) -> StateT (Int, Map i i) Identity ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Int
ctr', i -> i -> Map i i -> Map i i
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert i
i i
i' Map i i
idMap)
        i -> State (Int, Map i i) i
forall (m :: * -> *) a. Monad m => a -> m a
return i
i'


-- | Mangle all type and data variable identifiers.
mangleVars :: (Data a) => a -> a
mangleVars :: a -> a
mangleVars = Proxy VarId -> a -> a
forall i a. (Identifiable i, Data i, Data a) => Proxy i -> a -> a
mangle (Proxy VarId
forall k (t :: k). Proxy t
Proxy :: Proxy VarId) (a -> a) -> (a -> a) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy TVarId -> a -> a
forall i a. (Identifiable i, Data i, Data a) => Proxy i -> a -> a
mangle (Proxy TVarId
forall k (t :: k). Proxy t
Proxy :: Proxy TVarId)


-- | Cons identifier for Lists
cons :: Identifier
cons :: Identifier
cons = String -> Identifier
Identifier String
"Cons"


-- | Nil identifier for Lists
nil :: Identifier
nil :: Identifier
nil = String -> Identifier
Identifier String
"Nil"