{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE Safe #-}
module Embedder.Atmo.Syntax
      ( Module (..), DataConId (..), TyConId (..)
      , Ty (..), TyBuiltin(..), Poly (..)
      , Exp (..), Pat (..)
      , Defn (..), DefnAttr (..), DataDefn (..), RecDefn (..), TypeSynonym (..)
      , DataCon (..)
      , FreeProgram, Program (..)
      , FieldId
      , DataHeader, RecHeader, Binds(..), PatBind(..)
      , FunBinding(..) -- Rhs(..), GuardedRhs(..)
      , prettyFP, getPatVars -- getFunBody
      , untype
      ) where

import Prelude hiding (replicate)

import ReWire.Annotation (Annote, Annotated (ann))
import ReWire.Orphans ()
import ReWire.Pretty (empty, text, TextShow (showt), Doc,
  nest, hsep, parens, dquotes, comma, brackets, vsep, (<+>), Pretty (pretty),
  punctuate, line, softline, align, braces, dot)
import ReWire.SYB (transform)
import Data.Containers.ListUtils (nubOrdOn)
import Data.Data (Typeable, Data (..))
import Data.Hashable (Hashable (..))
import Data.List (intersperse)
import Data.Maybe (isJust)
import Data.Text (Text)
import GHC.Generics (Generic (..))
import Numeric.Natural (Natural)
import Embedder.Builtins (TyBuiltin (..), RWUserOp, rwu2s)
import Control.Monad.Identity (Identity(..))
import ReWire.Error (MonadError, AstError)

data Module = Module ![DataDefn] ![RecDefn] ![TypeSynonym] ![Defn]
      deriving (Int -> Module -> ShowS
[Module] -> ShowS
Module -> String
(Int -> Module -> ShowS)
-> (Module -> String) -> ([Module] -> ShowS) -> Show Module
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Module -> ShowS
showsPrec :: Int -> Module -> ShowS
$cshow :: Module -> String
show :: Module -> String
$cshowList :: [Module] -> ShowS
showList :: [Module] -> ShowS
Show, (forall x. Module -> Rep Module x)
-> (forall x. Rep Module x -> Module) -> Generic Module
forall x. Rep Module x -> Module
forall x. Module -> Rep Module x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Module -> Rep Module x
from :: forall x. Module -> Rep Module x
$cto :: forall x. Rep Module x -> Module
to :: forall x. Rep Module x -> Module
Generic, Typeable Module
Typeable Module =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Module -> c Module)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Module)
-> (Module -> Constr)
-> (Module -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Module))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module))
-> ((forall b. Data b => b -> b) -> Module -> Module)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Module -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Module -> r)
-> (forall u. (forall d. Data d => d -> u) -> Module -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Module -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Module -> m Module)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module)
-> Data Module
Module -> Constr
Module -> DataType
(forall b. Data b => b -> b) -> Module -> Module
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) -> Module -> u
forall u. (forall d. Data d => d -> u) -> Module -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
$ctoConstr :: Module -> Constr
toConstr :: Module -> Constr
$cdataTypeOf :: Module -> DataType
dataTypeOf :: Module -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
$cgmapT :: (forall b. Data b => b -> b) -> Module -> Module
gmapT :: (forall b. Data b => b -> b) -> Module -> Module
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
Data)

instance Pretty Module where
      pretty :: forall ann. Module -> Doc ann
pretty (Module [DataDefn]
cs [RecDefn]
rs [TypeSynonym]
ts [Defn]
ds) = Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep (Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"module" Doc ann -> [Doc ann] -> [Doc ann]
forall a. a -> [a] -> [a]
: (DataDefn -> Doc ann) -> [DataDefn] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map DataDefn -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. DataDefn -> Doc ann
pretty [DataDefn]
cs [Doc ann] -> [Doc ann] -> [Doc ann]
forall a. Semigroup a => a -> a -> a
<> (RecDefn -> Doc ann) -> [RecDefn] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map RecDefn -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. RecDefn -> Doc ann
pretty [RecDefn]
rs [Doc ann] -> [Doc ann] -> [Doc ann]
forall a. Semigroup a => a -> a -> a
<> (TypeSynonym -> Doc ann) -> [TypeSynonym] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map TypeSynonym -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TypeSynonym -> Doc ann
pretty [TypeSynonym]
ts [Doc ann] -> [Doc ann] -> [Doc ann]
forall a. Semigroup a => a -> a -> a
<> (Defn -> Doc ann) -> [Defn] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Defn -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Defn -> Doc ann
pretty [Defn]
ds)

instance Semigroup Module where
      -- TODO(chathhorn): shouldn't be necessary
      (Module [DataDefn]
a [RecDefn]
b [TypeSynonym]
c [Defn]
d) <> :: Module -> Module -> Module
<> (Module [DataDefn]
a' [RecDefn]
b' [TypeSynonym]
c' [Defn]
d') = [DataDefn] -> [RecDefn] -> [TypeSynonym] -> [Defn] -> Module
Module ((DataDefn -> Text) -> [DataDefn] -> [DataDefn]
forall b a. Ord b => (a -> b) -> [a] -> [a]
nubOrdOn DataDefn -> Text
dataName ([DataDefn] -> [DataDefn]) -> [DataDefn] -> [DataDefn]
forall a b. (a -> b) -> a -> b
$ [DataDefn]
a [DataDefn] -> [DataDefn] -> [DataDefn]
forall a. Semigroup a => a -> a -> a
<> [DataDefn]
a') ((RecDefn -> Text) -> [RecDefn] -> [RecDefn]
forall b a. Ord b => (a -> b) -> [a] -> [a]
nubOrdOn RecDefn -> Text
recName ([RecDefn] -> [RecDefn]) -> [RecDefn] -> [RecDefn]
forall a b. (a -> b) -> a -> b
$ [RecDefn]
b [RecDefn] -> [RecDefn] -> [RecDefn]
forall a. Semigroup a => a -> a -> a
<> [RecDefn]
b') ((TypeSynonym -> Text) -> [TypeSynonym] -> [TypeSynonym]
forall b a. Ord b => (a -> b) -> [a] -> [a]
nubOrdOn TypeSynonym -> Text
typeSynName ([TypeSynonym] -> [TypeSynonym]) -> [TypeSynonym] -> [TypeSynonym]
forall a b. (a -> b) -> a -> b
$ [TypeSynonym]
c [TypeSynonym] -> [TypeSynonym] -> [TypeSynonym]
forall a. Semigroup a => a -> a -> a
<> [TypeSynonym]
c') ((Defn -> Text) -> [Defn] -> [Defn]
forall b a. Ord b => (a -> b) -> [a] -> [a]
nubOrdOn Defn -> Text
defnName ([Defn] -> [Defn]) -> [Defn] -> [Defn]
forall a b. (a -> b) -> a -> b
$ [Defn]
d [Defn] -> [Defn] -> [Defn]
forall a. Semigroup a => a -> a -> a
<> [Defn]
d')

instance Monoid Module where
      mempty :: Module
mempty = [DataDefn] -> [RecDefn] -> [TypeSynonym] -> [Defn] -> Module
Module [] [] [] []

---

-- Name Handling: 
      -- Bind bs e replaced with bs e
            -- corresponding matches are adjusted
            -- unbinds are removed (slight variable renaming)
            -- untrec removed
      -- Embed removed
      -- Name X replaced with Text
      -- instance Alpha removed
      -- instance Subst removed
      -- TRec removed
      -- runFreshM removed (replaced with runIdentity in some places)
      -- n2s removed
      -- Eq on Poly types derived instead of alpha equivalence

class Parenless a where
      -- | Parts that never need to be wrapped in parens during pretty printing.
      parenless :: a -> Bool

newtype DataConId = DataConId Text
      deriving (DataConId -> DataConId -> Bool
(DataConId -> DataConId -> Bool)
-> (DataConId -> DataConId -> Bool) -> Eq DataConId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DataConId -> DataConId -> Bool
== :: DataConId -> DataConId -> Bool
$c/= :: DataConId -> DataConId -> Bool
/= :: DataConId -> DataConId -> Bool
Eq, (forall x. DataConId -> Rep DataConId x)
-> (forall x. Rep DataConId x -> DataConId) -> Generic DataConId
forall x. Rep DataConId x -> DataConId
forall x. DataConId -> Rep DataConId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DataConId -> Rep DataConId x
from :: forall x. DataConId -> Rep DataConId x
$cto :: forall x. Rep DataConId x -> DataConId
to :: forall x. Rep DataConId x -> DataConId
Generic, Typeable, Typeable DataConId
Typeable DataConId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DataConId -> c DataConId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataConId)
-> (DataConId -> Constr)
-> (DataConId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataConId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataConId))
-> ((forall b. Data b => b -> b) -> DataConId -> DataConId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataConId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataConId -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataConId -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DataConId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataConId -> m DataConId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataConId -> m DataConId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataConId -> m DataConId)
-> Data DataConId
DataConId -> Constr
DataConId -> DataType
(forall b. Data b => b -> b) -> DataConId -> DataConId
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) -> DataConId -> u
forall u. (forall d. Data d => d -> u) -> DataConId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataConId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataConId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataConId -> m DataConId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConId -> m DataConId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataConId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataConId -> c DataConId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataConId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataConId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataConId -> c DataConId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataConId -> c DataConId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataConId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataConId
$ctoConstr :: DataConId -> Constr
toConstr :: DataConId -> Constr
$cdataTypeOf :: DataConId -> DataType
dataTypeOf :: DataConId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataConId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataConId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataConId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataConId)
$cgmapT :: (forall b. Data b => b -> b) -> DataConId -> DataConId
gmapT :: (forall b. Data b => b -> b) -> DataConId -> DataConId
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataConId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataConId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataConId -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataConId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataConId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataConId -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataConId -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataConId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataConId -> m DataConId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataConId -> m DataConId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConId -> m DataConId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConId -> m DataConId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConId -> m DataConId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConId -> m DataConId
Data)
newtype TyConId = TyConId Text
      deriving (TyConId -> TyConId -> Bool
(TyConId -> TyConId -> Bool)
-> (TyConId -> TyConId -> Bool) -> Eq TyConId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TyConId -> TyConId -> Bool
== :: TyConId -> TyConId -> Bool
$c/= :: TyConId -> TyConId -> Bool
/= :: TyConId -> TyConId -> Bool
Eq, (forall x. TyConId -> Rep TyConId x)
-> (forall x. Rep TyConId x -> TyConId) -> Generic TyConId
forall x. Rep TyConId x -> TyConId
forall x. TyConId -> Rep TyConId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TyConId -> Rep TyConId x
from :: forall x. TyConId -> Rep TyConId x
$cto :: forall x. Rep TyConId x -> TyConId
to :: forall x. Rep TyConId x -> TyConId
Generic, Typeable, Typeable TyConId
Typeable TyConId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TyConId -> c TyConId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TyConId)
-> (TyConId -> Constr)
-> (TyConId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TyConId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyConId))
-> ((forall b. Data b => b -> b) -> TyConId -> TyConId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyConId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyConId -> r)
-> (forall u. (forall d. Data d => d -> u) -> TyConId -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TyConId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TyConId -> m TyConId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyConId -> m TyConId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyConId -> m TyConId)
-> Data TyConId
TyConId -> Constr
TyConId -> DataType
(forall b. Data b => b -> b) -> TyConId -> TyConId
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) -> TyConId -> u
forall u. (forall d. Data d => d -> u) -> TyConId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyConId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyConId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyConId -> m TyConId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConId -> m TyConId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyConId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyConId -> c TyConId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyConId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyConId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyConId -> c TyConId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyConId -> c TyConId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyConId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyConId
$ctoConstr :: TyConId -> Constr
toConstr :: TyConId -> Constr
$cdataTypeOf :: TyConId -> DataType
dataTypeOf :: TyConId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyConId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyConId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyConId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyConId)
$cgmapT :: (forall b. Data b => b -> b) -> TyConId -> TyConId
gmapT :: (forall b. Data b => b -> b) -> TyConId -> TyConId
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyConId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyConId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyConId -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyConId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TyConId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TyConId -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyConId -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyConId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyConId -> m TyConId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyConId -> m TyConId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConId -> m TyConId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConId -> m TyConId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConId -> m TyConId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConId -> m TyConId
Data)
newtype FieldId  = FieldId Text
      deriving (FieldId -> FieldId -> Bool
(FieldId -> FieldId -> Bool)
-> (FieldId -> FieldId -> Bool) -> Eq FieldId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldId -> FieldId -> Bool
== :: FieldId -> FieldId -> Bool
$c/= :: FieldId -> FieldId -> Bool
/= :: FieldId -> FieldId -> Bool
Eq, (forall x. FieldId -> Rep FieldId x)
-> (forall x. Rep FieldId x -> FieldId) -> Generic FieldId
forall x. Rep FieldId x -> FieldId
forall x. FieldId -> Rep FieldId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FieldId -> Rep FieldId x
from :: forall x. FieldId -> Rep FieldId x
$cto :: forall x. Rep FieldId x -> FieldId
to :: forall x. Rep FieldId x -> FieldId
Generic, Typeable, Typeable FieldId
Typeable FieldId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FieldId -> c FieldId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FieldId)
-> (FieldId -> Constr)
-> (FieldId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FieldId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId))
-> ((forall b. Data b => b -> b) -> FieldId -> FieldId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldId -> r)
-> (forall u. (forall d. Data d => d -> u) -> FieldId -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FieldId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FieldId -> m FieldId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldId -> m FieldId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldId -> m FieldId)
-> Data FieldId
FieldId -> Constr
FieldId -> DataType
(forall b. Data b => b -> b) -> FieldId -> FieldId
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) -> FieldId -> u
forall u. (forall d. Data d => d -> u) -> FieldId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldId -> c FieldId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldId -> c FieldId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldId -> c FieldId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldId
$ctoConstr :: FieldId -> Constr
toConstr :: FieldId -> Constr
$cdataTypeOf :: FieldId -> DataType
dataTypeOf :: FieldId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId)
$cgmapT :: (forall b. Data b => b -> b) -> FieldId -> FieldId
gmapT :: (forall b. Data b => b -> b) -> FieldId -> FieldId
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FieldId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FieldId -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldId -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
Data)

instance Hashable DataConId
instance Hashable TyConId
instance Hashable FieldId

data DataCon = DataCon Annote !Text !Poly
      deriving ((forall x. DataCon -> Rep DataCon x)
-> (forall x. Rep DataCon x -> DataCon) -> Generic DataCon
forall x. Rep DataCon x -> DataCon
forall x. DataCon -> Rep DataCon x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DataCon -> Rep DataCon x
from :: forall x. DataCon -> Rep DataCon x
$cto :: forall x. Rep DataCon x -> DataCon
to :: forall x. Rep DataCon x -> DataCon
Generic, DataCon -> DataCon -> Bool
(DataCon -> DataCon -> Bool)
-> (DataCon -> DataCon -> Bool) -> Eq DataCon
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DataCon -> DataCon -> Bool
== :: DataCon -> DataCon -> Bool
$c/= :: DataCon -> DataCon -> Bool
/= :: DataCon -> DataCon -> Bool
Eq, Int -> DataCon -> ShowS
[DataCon] -> ShowS
DataCon -> String
(Int -> DataCon -> ShowS)
-> (DataCon -> String) -> ([DataCon] -> ShowS) -> Show DataCon
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DataCon -> ShowS
showsPrec :: Int -> DataCon -> ShowS
$cshow :: DataCon -> String
show :: DataCon -> String
$cshowList :: [DataCon] -> ShowS
showList :: [DataCon] -> ShowS
Show, Typeable, Typeable DataCon
Typeable DataCon =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DataCon -> c DataCon)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataCon)
-> (DataCon -> Constr)
-> (DataCon -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataCon))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataCon))
-> ((forall b. Data b => b -> b) -> DataCon -> DataCon)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataCon -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataCon -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataCon -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DataCon -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataCon -> m DataCon)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataCon -> m DataCon)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataCon -> m DataCon)
-> Data DataCon
DataCon -> Constr
DataCon -> DataType
(forall b. Data b => b -> b) -> DataCon -> DataCon
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) -> DataCon -> u
forall u. (forall d. Data d => d -> u) -> DataCon -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataCon -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataCon -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataCon -> m DataCon
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataCon -> m DataCon
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataCon
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataCon -> c DataCon
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataCon)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataCon)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataCon -> c DataCon
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataCon -> c DataCon
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataCon
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataCon
$ctoConstr :: DataCon -> Constr
toConstr :: DataCon -> Constr
$cdataTypeOf :: DataCon -> DataType
dataTypeOf :: DataCon -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataCon)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataCon)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataCon)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataCon)
$cgmapT :: (forall b. Data b => b -> b) -> DataCon -> DataCon
gmapT :: (forall b. Data b => b -> b) -> DataCon -> DataCon
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataCon -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataCon -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataCon -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataCon -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataCon -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataCon -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataCon -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataCon -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataCon -> m DataCon
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataCon -> m DataCon
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataCon -> m DataCon
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataCon -> m DataCon
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataCon -> m DataCon
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataCon -> m DataCon
Data)

instance Annotated DataCon where
      ann :: DataCon -> Annote
ann (DataCon Annote
a Text
_ Poly
_)  = Annote
a

instance Pretty DataCon where
      pretty :: forall ann. DataCon -> Doc ann
pretty (DataCon Annote
_ Text
n Poly
t)  = Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"::" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Poly -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Poly -> Doc ann
pretty Poly
t



data Poly = Poly [Text] Ty
      deriving ((forall x. Poly -> Rep Poly x)
-> (forall x. Rep Poly x -> Poly) -> Generic Poly
forall x. Rep Poly x -> Poly
forall x. Poly -> Rep Poly x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Poly -> Rep Poly x
from :: forall x. Poly -> Rep Poly x
$cto :: forall x. Rep Poly x -> Poly
to :: forall x. Rep Poly x -> Poly
Generic, Poly -> Poly -> Bool
(Poly -> Poly -> Bool) -> (Poly -> Poly -> Bool) -> Eq Poly
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Poly -> Poly -> Bool
== :: Poly -> Poly -> Bool
$c/= :: Poly -> Poly -> Bool
/= :: Poly -> Poly -> Bool
Eq, Int -> Poly -> ShowS
[Poly] -> ShowS
Poly -> String
(Int -> Poly -> ShowS)
-> (Poly -> String) -> ([Poly] -> ShowS) -> Show Poly
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Poly -> ShowS
showsPrec :: Int -> Poly -> ShowS
$cshow :: Poly -> String
show :: Poly -> String
$cshowList :: [Poly] -> ShowS
showList :: [Poly] -> ShowS
Show, Typeable, Typeable Poly
Typeable Poly =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Poly -> c Poly)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Poly)
-> (Poly -> Constr)
-> (Poly -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Poly))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Poly))
-> ((forall b. Data b => b -> b) -> Poly -> Poly)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Poly -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Poly -> r)
-> (forall u. (forall d. Data d => d -> u) -> Poly -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Poly -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Poly -> m Poly)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Poly -> m Poly)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Poly -> m Poly)
-> Data Poly
Poly -> Constr
Poly -> DataType
(forall b. Data b => b -> b) -> Poly -> Poly
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) -> Poly -> u
forall u. (forall d. Data d => d -> u) -> Poly -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Poly -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Poly -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Poly -> m Poly
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Poly -> m Poly
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Poly
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Poly -> c Poly
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Poly)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Poly)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Poly -> c Poly
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Poly -> c Poly
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Poly
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Poly
$ctoConstr :: Poly -> Constr
toConstr :: Poly -> Constr
$cdataTypeOf :: Poly -> DataType
dataTypeOf :: Poly -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Poly)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Poly)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Poly)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Poly)
$cgmapT :: (forall b. Data b => b -> b) -> Poly -> Poly
gmapT :: (forall b. Data b => b -> b) -> Poly -> Poly
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Poly -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Poly -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Poly -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Poly -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Poly -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Poly -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Poly -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Poly -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Poly -> m Poly
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Poly -> m Poly
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Poly -> m Poly
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Poly -> m Poly
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Poly -> m Poly
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Poly -> m Poly
Data)

instance Hashable Poly



instance Pretty Poly where
      pretty :: forall ann. Poly -> Doc ann
pretty (Poly [Text]
_tvs Ty
pt) = Ty -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Ty -> Doc ann
pretty Ty
pt

data Ty = TyApp Annote !Ty ![Ty]
        | TyCon Annote !Text
        | TyVar Annote !Text
        | TyNat Annote !Natural
        | TyTuple Annote ![Ty]
        | TyBuiltin Annote !TyBuiltin
      deriving (Ty -> Ty -> Bool
(Ty -> Ty -> Bool) -> (Ty -> Ty -> Bool) -> Eq Ty
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ty -> Ty -> Bool
== :: Ty -> Ty -> Bool
$c/= :: Ty -> Ty -> Bool
/= :: Ty -> Ty -> Bool
Eq, Eq Ty
Eq Ty =>
(Ty -> Ty -> Ordering)
-> (Ty -> Ty -> Bool)
-> (Ty -> Ty -> Bool)
-> (Ty -> Ty -> Bool)
-> (Ty -> Ty -> Bool)
-> (Ty -> Ty -> Ty)
-> (Ty -> Ty -> Ty)
-> Ord Ty
Ty -> Ty -> Bool
Ty -> Ty -> Ordering
Ty -> Ty -> Ty
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 :: Ty -> Ty -> Ordering
compare :: Ty -> Ty -> Ordering
$c< :: Ty -> Ty -> Bool
< :: Ty -> Ty -> Bool
$c<= :: Ty -> Ty -> Bool
<= :: Ty -> Ty -> Bool
$c> :: Ty -> Ty -> Bool
> :: Ty -> Ty -> Bool
$c>= :: Ty -> Ty -> Bool
>= :: Ty -> Ty -> Bool
$cmax :: Ty -> Ty -> Ty
max :: Ty -> Ty -> Ty
$cmin :: Ty -> Ty -> Ty
min :: Ty -> Ty -> Ty
Ord, (forall x. Ty -> Rep Ty x)
-> (forall x. Rep Ty x -> Ty) -> Generic Ty
forall x. Rep Ty x -> Ty
forall x. Ty -> Rep Ty x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Ty -> Rep Ty x
from :: forall x. Ty -> Rep Ty x
$cto :: forall x. Rep Ty x -> Ty
to :: forall x. Rep Ty x -> Ty
Generic, Typeable, Typeable Ty
Typeable Ty =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Ty -> c Ty)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Ty)
-> (Ty -> Constr)
-> (Ty -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Ty))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ty))
-> ((forall b. Data b => b -> b) -> Ty -> Ty)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r)
-> (forall u. (forall d. Data d => d -> u) -> Ty -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Ty -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Ty -> m Ty)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ty -> m Ty)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ty -> m Ty)
-> Data Ty
Ty -> Constr
Ty -> DataType
(forall b. Data b => b -> b) -> Ty -> Ty
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) -> Ty -> u
forall u. (forall d. Data d => d -> u) -> Ty -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ty
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ty -> c Ty
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ty)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ty)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ty -> c Ty
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ty -> c Ty
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ty
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ty
$ctoConstr :: Ty -> Constr
toConstr :: Ty -> Constr
$cdataTypeOf :: Ty -> DataType
dataTypeOf :: Ty -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ty)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ty)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ty)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ty)
$cgmapT :: (forall b. Data b => b -> b) -> Ty -> Ty
gmapT :: (forall b. Data b => b -> b) -> Ty -> Ty
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Ty -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Ty -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Ty -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Ty -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
Data, Int -> Ty -> ShowS
[Ty] -> ShowS
Ty -> String
(Int -> Ty -> ShowS)
-> (Ty -> String) -> ([Ty] -> ShowS) -> Show Ty
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Ty -> ShowS
showsPrec :: Int -> Ty -> ShowS
$cshow :: Ty -> String
show :: Ty -> String
$cshowList :: [Ty] -> ShowS
showList :: [Ty] -> ShowS
Show)

instance Hashable Ty

instance Annotated Ty where
      ann :: Ty -> Annote
ann = \ case
            TyApp Annote
a Ty
_ [Ty]
_   -> Annote
a
            TyCon Annote
a Text
_     -> Annote
a
            TyVar Annote
a Text
_     -> Annote
a
            TyNat Annote
a Natural
_     -> Annote
a
            TyTuple Annote
a [Ty]
_   -> Annote
a
            TyBuiltin Annote
a TyBuiltin
_ -> Annote
a

instance Parenless Ty where
      parenless :: Ty -> Bool
parenless = \ case
            TyTuple {}                     -> Bool
True
            TyCon {}                       -> Bool
True
            TyVar {}                       -> Bool
True
            TyNat {}                       -> Bool
True
            TyBuiltin Annote
_ TyBuiltin
TyInteger          -> Bool
True
            TyBuiltin Annote
_ TyBuiltin
TyString           -> Bool
True
            TyBuiltin Annote
_ TyBuiltin
TyBool             -> Bool
True
            TyBuiltin Annote
_ TyBuiltin
TyUnit             -> Bool
True
            Ty
_                              -> Bool
False

needsParens :: Ty -> Bool
needsParens :: Ty -> Bool
needsParens Ty
t = case Ty
t of
      (TyApp Annote
_ (TyBuiltin Annote
_ (TyFun {})) [Ty]
_) -> Bool
True
      Ty
_                  -> Bool
False



instance Pretty Ty where
      pretty :: forall ann. Ty -> Doc ann
pretty = \ case
            TyVar Annote
_ Text
n        -> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n
            TyCon Annote
_ Text
n        -> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n
            TyNat Annote
_ Natural
n        -> Text -> Doc ann
forall ann. Text -> Doc ann
text (Text -> Doc ann) -> Text -> Doc ann
forall a b. (a -> b) -> a -> b
$ Natural -> Text
forall a. TextShow a => a -> Text
showt Natural
n
            TyTuple Annote
_ [Ty]
ts     -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Ty -> Doc ann) -> [Ty] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Ty -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Ty -> Doc ann
pretty [Ty]
ts
            TyBuiltin Annote
_ TyBuiltin
tb   -> TyBuiltin -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TyBuiltin -> Doc ann
pretty TyBuiltin
tb
            TyApp Annote
_ (TyBuiltin Annote
_ TyBuiltin
TyList) [Ty
t] -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
brackets (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Ty -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Ty -> Doc ann
pretty Ty
t
            TyApp Annote
_ (TyBuiltin Annote
_ TyBuiltin
TyFun) [Ty
t1,Ty
t2] | Ty -> Bool
needsParens Ty
t1
                           -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Ty -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Ty -> Doc ann
pretty Ty
t1) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> TyBuiltin -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TyBuiltin -> Doc ann
pretty TyBuiltin
TyFun Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Ty -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Ty -> Doc ann
pretty Ty
t2
            TyApp Annote
_ (TyBuiltin Annote
_ TyBuiltin
TyFun) [Ty
t1,Ty
t2] -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Ty -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Ty -> Doc ann
pretty Ty
t1 Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> TyBuiltin -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TyBuiltin -> Doc ann
pretty TyBuiltin
TyFun Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Ty -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Ty -> Doc ann
pretty Ty
t2
            TyApp Annote
_ (TyBuiltin Annote
_ TyBuiltin
TyPlus) [Ty
t1,Ty
t2] -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Ty -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Ty -> Doc ann
pretty Ty
t1 Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"+" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Ty -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Ty -> Doc ann
pretty Ty
t2
            TyApp Annote
_ Ty
t [Ty]
ts -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Ty -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Ty -> Doc ann
pretty Ty
t Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ((Ty -> Doc ann) -> [Ty] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Ty -> Doc ann
forall a ann. (Pretty a, Parenless a) => a -> Doc ann
mparens [Ty]
ts)


untype :: Data d => d -> d
untype :: forall b. Data b => b -> b
untype = (Maybe Ty -> Maybe Ty) -> d -> d
forall a b. (Data a, Data b) => (a -> a) -> b -> b
transform ((Maybe Ty -> Maybe Ty) -> d -> d)
-> (Maybe Ty -> Maybe Ty) -> d -> d
forall a b. (a -> b) -> a -> b
$ \ (Maybe Ty
_ :: Maybe Ty) -> Maybe Ty
forall a. Maybe a
Nothing

---
-- Records: see the RecVal, RecSel, and RecUpd expressions, the PatRec
-- pattern, and the RecDefn declaration below.



----

-- Originally includes let bindings and where-bindings...
-- should only be let-bindings here...
-- Would be nice to simplify to, say, PatBinds or something
-- Rather, let's start with PatBinds and complicate it only if we need to
newtype Binds = BDefs [Defn]
      deriving ((forall x. Binds -> Rep Binds x)
-> (forall x. Rep Binds x -> Binds) -> Generic Binds
forall x. Rep Binds x -> Binds
forall x. Binds -> Rep Binds x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Binds -> Rep Binds x
from :: forall x. Binds -> Rep Binds x
$cto :: forall x. Rep Binds x -> Binds
to :: forall x. Rep Binds x -> Binds
Generic,Binds -> Binds -> Bool
(Binds -> Binds -> Bool) -> (Binds -> Binds -> Bool) -> Eq Binds
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Binds -> Binds -> Bool
== :: Binds -> Binds -> Bool
$c/= :: Binds -> Binds -> Bool
/= :: Binds -> Binds -> Bool
Eq,Int -> Binds -> ShowS
[Binds] -> ShowS
Binds -> String
(Int -> Binds -> ShowS)
-> (Binds -> String) -> ([Binds] -> ShowS) -> Show Binds
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Binds -> ShowS
showsPrec :: Int -> Binds -> ShowS
$cshow :: Binds -> String
show :: Binds -> String
$cshowList :: [Binds] -> ShowS
showList :: [Binds] -> ShowS
Show,Typeable,Typeable Binds
Typeable Binds =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Binds -> c Binds)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Binds)
-> (Binds -> Constr)
-> (Binds -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Binds))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Binds))
-> ((forall b. Data b => b -> b) -> Binds -> Binds)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Binds -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Binds -> r)
-> (forall u. (forall d. Data d => d -> u) -> Binds -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Binds -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Binds -> m Binds)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binds -> m Binds)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binds -> m Binds)
-> Data Binds
Binds -> Constr
Binds -> DataType
(forall b. Data b => b -> b) -> Binds -> Binds
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) -> Binds -> u
forall u. (forall d. Data d => d -> u) -> Binds -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Binds -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Binds -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binds -> m Binds
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binds -> m Binds
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Binds
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binds -> c Binds
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Binds)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Binds)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binds -> c Binds
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binds -> c Binds
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Binds
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Binds
$ctoConstr :: Binds -> Constr
toConstr :: Binds -> Constr
$cdataTypeOf :: Binds -> DataType
dataTypeOf :: Binds -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Binds)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Binds)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Binds)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Binds)
$cgmapT :: (forall b. Data b => b -> b) -> Binds -> Binds
gmapT :: (forall b. Data b => b -> b) -> Binds -> Binds
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Binds -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Binds -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Binds -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Binds -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Binds -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Binds -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Binds -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Binds -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binds -> m Binds
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binds -> m Binds
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binds -> m Binds
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binds -> m Binds
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binds -> m Binds
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binds -> m Binds
Data)

instance Hashable Binds

data PatBind = PatBind Pat Exp
      deriving ((forall x. PatBind -> Rep PatBind x)
-> (forall x. Rep PatBind x -> PatBind) -> Generic PatBind
forall x. Rep PatBind x -> PatBind
forall x. PatBind -> Rep PatBind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PatBind -> Rep PatBind x
from :: forall x. PatBind -> Rep PatBind x
$cto :: forall x. Rep PatBind x -> PatBind
to :: forall x. Rep PatBind x -> PatBind
Generic, PatBind -> PatBind -> Bool
(PatBind -> PatBind -> Bool)
-> (PatBind -> PatBind -> Bool) -> Eq PatBind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PatBind -> PatBind -> Bool
== :: PatBind -> PatBind -> Bool
$c/= :: PatBind -> PatBind -> Bool
/= :: PatBind -> PatBind -> Bool
Eq, Int -> PatBind -> ShowS
[PatBind] -> ShowS
PatBind -> String
(Int -> PatBind -> ShowS)
-> (PatBind -> String) -> ([PatBind] -> ShowS) -> Show PatBind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PatBind -> ShowS
showsPrec :: Int -> PatBind -> ShowS
$cshow :: PatBind -> String
show :: PatBind -> String
$cshowList :: [PatBind] -> ShowS
showList :: [PatBind] -> ShowS
Show, Typeable, Typeable PatBind
Typeable PatBind =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PatBind -> c PatBind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PatBind)
-> (PatBind -> Constr)
-> (PatBind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PatBind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatBind))
-> ((forall b. Data b => b -> b) -> PatBind -> PatBind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatBind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatBind -> r)
-> (forall u. (forall d. Data d => d -> u) -> PatBind -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PatBind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatBind -> m PatBind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatBind -> m PatBind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatBind -> m PatBind)
-> Data PatBind
PatBind -> Constr
PatBind -> DataType
(forall b. Data b => b -> b) -> PatBind -> PatBind
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) -> PatBind -> u
forall u. (forall d. Data d => d -> u) -> PatBind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatBind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatBind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatBind -> m PatBind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatBind -> m PatBind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatBind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatBind -> c PatBind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatBind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatBind)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatBind -> c PatBind
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatBind -> c PatBind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatBind
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatBind
$ctoConstr :: PatBind -> Constr
toConstr :: PatBind -> Constr
$cdataTypeOf :: PatBind -> DataType
dataTypeOf :: PatBind -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatBind)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatBind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatBind)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatBind)
$cgmapT :: (forall b. Data b => b -> b) -> PatBind -> PatBind
gmapT :: (forall b. Data b => b -> b) -> PatBind -> PatBind
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatBind -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatBind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatBind -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatBind -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PatBind -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PatBind -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatBind -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatBind -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatBind -> m PatBind
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatBind -> m PatBind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatBind -> m PatBind
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatBind -> m PatBind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatBind -> m PatBind
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatBind -> m PatBind
Data)

instance Hashable PatBind

instance Pretty PatBind where
      pretty :: forall ann. PatBind -> Doc ann
pretty (PatBind Pat
p Exp
e) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
brackets (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Pat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Pat -> Doc ann
pretty Pat
p Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
e

data Exp = App     Annote !(Maybe Poly) !(Maybe Ty) !Exp ![Exp]
         | Lam     Annote !(Maybe Poly) !(Maybe Ty) ![Text] !Exp
         | Var     Annote !(Maybe Poly) !(Maybe Ty) !Text
         | Con     Annote !(Maybe Poly) !(Maybe Ty) !Text
         | Case    Annote !(Maybe Poly) !(Maybe Ty) !Exp ![PatBind]
         | RWUser  Annote !(Maybe Poly) !(Maybe Ty) !RWUserOp
         | LitInt  Annote !(Maybe Poly) !Integer
         | LitStr  Annote !(Maybe Poly) !Text
         | LitVec  Annote !(Maybe Poly) !(Maybe Ty) ![Exp]
         | LitList Annote !(Maybe Poly) !(Maybe Ty) ![Exp]
         | Tuple   Annote !(Maybe Poly) !(Maybe Ty) ![Exp]
         | If      Annote !(Maybe Poly) !(Maybe Ty) !Exp !Exp !Exp
         | Let     Annote !(Maybe Poly) !(Maybe Ty) ![PatBind] !Exp
         | RecVal  Annote !(Maybe Poly) !(Maybe Ty) ![(Text, Exp)]
         | RecSel  Annote !(Maybe Poly) !(Maybe Ty) Text Exp
         | RecUpd  Annote !(Maybe Poly) !(Maybe Ty) !Exp ![(Text,Exp)]
      deriving ((forall x. Exp -> Rep Exp x)
-> (forall x. Rep Exp x -> Exp) -> Generic Exp
forall x. Rep Exp x -> Exp
forall x. Exp -> Rep Exp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Exp -> Rep Exp x
from :: forall x. Exp -> Rep Exp x
$cto :: forall x. Rep Exp x -> Exp
to :: forall x. Rep Exp x -> Exp
Generic, Int -> Exp -> ShowS
[Exp] -> ShowS
Exp -> String
(Int -> Exp -> ShowS)
-> (Exp -> String) -> ([Exp] -> ShowS) -> Show Exp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Exp -> ShowS
showsPrec :: Int -> Exp -> ShowS
$cshow :: Exp -> String
show :: Exp -> String
$cshowList :: [Exp] -> ShowS
showList :: [Exp] -> ShowS
Show, Typeable, Typeable Exp
Typeable Exp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Exp -> c Exp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Exp)
-> (Exp -> Constr)
-> (Exp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Exp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp))
-> ((forall b. Data b => b -> b) -> Exp -> Exp)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r)
-> (forall u. (forall d. Data d => d -> u) -> Exp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Exp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp)
-> Data Exp
Exp -> Constr
Exp -> DataType
(forall b. Data b => b -> b) -> Exp -> Exp
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) -> Exp -> u
forall u. (forall d. Data d => d -> u) -> Exp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
$ctoConstr :: Exp -> Constr
toConstr :: Exp -> Constr
$cdataTypeOf :: Exp -> DataType
dataTypeOf :: Exp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
$cgmapT :: (forall b. Data b => b -> b) -> Exp -> Exp
gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Exp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Exp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Exp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Exp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
Data)

instance Hashable Exp

instance Eq Exp where
      Exp
a == :: Exp -> Exp -> Bool
== Exp
b = Exp -> Int
forall a. Hashable a => a -> Int
hash Exp
a Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Exp -> Int
forall a. Hashable a => a -> Int
hash Exp
b


instance Annotated Exp where
      ann :: Exp -> Annote
ann = \ case
            App Annote
a Maybe Poly
_ Maybe Ty
_ Exp
_ [Exp]
_       -> Annote
a
            Lam Annote
a Maybe Poly
_ Maybe Ty
_ [Text]
_ Exp
_       -> Annote
a
            Var Annote
a Maybe Poly
_ Maybe Ty
_ Text
_         -> Annote
a
            Con Annote
a Maybe Poly
_ Maybe Ty
_ Text
_         -> Annote
a
            Case Annote
a Maybe Poly
_ Maybe Ty
_ Exp
_ [PatBind]
_      -> Annote
a
            RWUser Annote
a Maybe Poly
_ Maybe Ty
_ RWUserOp
_      -> Annote
a
            LitInt Annote
a Maybe Poly
_ Integer
_        -> Annote
a
            LitStr Annote
a Maybe Poly
_ Text
_        -> Annote
a
            LitList Annote
a Maybe Poly
_ Maybe Ty
_ [Exp]
_     -> Annote
a
            LitVec Annote
a Maybe Poly
_ Maybe Ty
_ [Exp]
_      -> Annote
a
            Tuple Annote
a Maybe Poly
_ Maybe Ty
_ [Exp]
_       -> Annote
a
            If Annote
a Maybe Poly
_ Maybe Ty
_ Exp
_ Exp
_ Exp
_      -> Annote
a
            Let Annote
a Maybe Poly
_ Maybe Ty
_ [PatBind]
_ Exp
_       -> Annote
a
            RecVal Annote
a Maybe Poly
_ Maybe Ty
_ [(Text, Exp)]
_      -> Annote
a
            RecSel Annote
a Maybe Poly
_ Maybe Ty
_ Text
_ Exp
_    -> Annote
a
            RecUpd Annote
a Maybe Poly
_ Maybe Ty
_ Exp
_ [(Text, Exp)]
_    -> Annote
a

-- | Does this exp have a type annotation? Avoids depending on Embedder.Atmo.Types.
typeAnnotated :: Exp -> Bool
typeAnnotated :: Exp -> Bool
typeAnnotated = Maybe Poly -> Bool
forall a. Maybe a -> Bool
isJust (Maybe Poly -> Bool) -> (Exp -> Maybe Poly) -> Exp -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. \ case
      App Annote
_ Maybe Poly
t Maybe Ty
_ Exp
_ [Exp]
_       -> Maybe Poly
t
      Lam Annote
_ Maybe Poly
t Maybe Ty
_ [Text]
_ Exp
_       -> Maybe Poly
t
      Var Annote
_ Maybe Poly
t Maybe Ty
_ Text
_         -> Maybe Poly
t
      Con Annote
_ Maybe Poly
t Maybe Ty
_ Text
_         -> Maybe Poly
t
      Case Annote
_ Maybe Poly
t Maybe Ty
_ Exp
_ [PatBind]
_      -> Maybe Poly
t
      RWUser Annote
_ Maybe Poly
t Maybe Ty
_ RWUserOp
_      -> Maybe Poly
t
      LitInt Annote
_ Maybe Poly
t Integer
_        -> Maybe Poly
t
      LitStr Annote
_ Maybe Poly
t Text
_        -> Maybe Poly
t
      LitList Annote
_ Maybe Poly
t Maybe Ty
_ [Exp]
_     -> Maybe Poly
t
      LitVec Annote
_ Maybe Poly
t Maybe Ty
_ [Exp]
_      -> Maybe Poly
t
      Tuple Annote
_ Maybe Poly
t Maybe Ty
_ [Exp]
_       -> Maybe Poly
t
      If Annote
_ Maybe Poly
t Maybe Ty
_ Exp
_ Exp
_ Exp
_      -> Maybe Poly
t
      Let Annote
_ Maybe Poly
t Maybe Ty
_ [PatBind]
_ Exp
_       -> Maybe Poly
t
      RecVal Annote
_ Maybe Poly
t Maybe Ty
_ [(Text, Exp)]
_      -> Maybe Poly
t
      RecSel Annote
_ Maybe Poly
t Maybe Ty
_ Text
_ Exp
_    -> Maybe Poly
t
      RecUpd Annote
_ Maybe Poly
t Maybe Ty
_ Exp
_ [(Text, Exp)]
_    -> Maybe Poly
t

instance Parenless Exp where
      parenless :: Exp -> Bool
parenless = \ case
            -- TODO(chathhorn): rework pretty printing to handle type annotations on applications.
            Exp
e | Exp -> Bool
typeAnnotated Exp
e -> Bool
False
            Con {}              -> Bool
True
            Var {}                                          -> Bool
True
            RWUser {}                                       -> Bool
True
            LitInt {}                                       -> Bool
True
            LitStr {}                                       -> Bool
True
            LitList {}                                      -> Bool
True
            LitVec {}                                       -> Bool
True
            Tuple {}                                        -> Bool
True
            Exp
_                                               -> Bool
False

instance Pretty Exp where
      pretty :: forall ann. Exp -> Doc ann
pretty = \ case
            Con Annote
_ Maybe Poly
pt Maybe Ty
_ Text
n                               -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n
            Var Annote
_ Maybe Poly
pt Maybe Ty
_ Text
n                               -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n
            Lam Annote
_ Maybe Poly
pt Maybe Ty
_ [Text]
vs Exp
e                           -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$
                  Identity (Doc ann) -> Doc ann
forall a. Identity a -> a
runIdentity (Identity (Doc ann) -> Doc ann) -> Identity (Doc ann) -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> Identity (Doc ann)
forall a. a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Doc ann -> Identity (Doc ann)) -> Doc ann -> Identity (Doc ann)
forall a b. (a -> b) -> a -> b
$ Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"\\" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ((Text -> Doc ann) -> [Text] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Text -> Doc ann
forall ann. Text -> Doc ann
text [Text]
vs)  Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"->" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
e
            Case Annote
_ Maybe Poly
pt Maybe Ty
_ Exp
e [PatBind]
pbs                          -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$
                  Identity (Doc ann) -> Doc ann
forall a. Identity a -> a
runIdentity (Identity (Doc ann) -> Doc ann) -> Identity (Doc ann) -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> Identity (Doc ann)
forall a. a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Doc ann -> Identity (Doc ann)) -> Doc ann -> Identity (Doc ann)
forall a b. (a -> b) -> a -> b
$ Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"case" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
e Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"of" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<>
                        Doc ann
forall ann. Doc ann
line Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep ((PatBind -> Doc ann) -> [PatBind] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map PatBind -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. PatBind -> Doc ann
pretty [PatBind]
pbs)
            RWUser Annote
_ Maybe Poly
pt Maybe Ty
_ RWUserOp
b                            -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> (Text -> Doc ann) -> Maybe Text -> Doc ann
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"RWUOp??") Text -> Doc ann
forall ann. Text -> Doc ann
text (RWUserOp -> Maybe Text
rwu2s RWUserOp
b)
            LitInt Annote
_ Maybe Poly
pt Integer
v                              -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Integer -> Doc ann
forall ann. Integer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Integer
v
            LitStr Annote
_ Maybe Poly
pt Text
v                              -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
dquotes (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
v
            LitList Annote
_ Maybe Poly
pt Maybe Ty
_ [Exp]
vs                          -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
brackets (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Exp -> Doc ann) -> [Exp] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty [Exp]
vs
            LitVec Annote
_ Maybe Poly
pt Maybe Ty
_ [Exp]
vs                           -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
brackets (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Exp -> Doc ann) -> [Exp] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty [Exp]
vs
            Tuple Annote
_ Maybe Poly
pt Maybe Ty
_ [Exp]
es                            -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Exp -> Doc ann) -> [Exp] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty [Exp]
es
            App Annote
_ Maybe Poly
_ Maybe Ty
_ Exp
e [Exp]
es                             -> Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ (Exp -> Doc ann) -> [Exp] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Exp -> Doc ann
forall a ann. (Pretty a, Parenless a) => a -> Doc ann
mparens (Exp
e Exp -> [Exp] -> [Exp]
forall a. a -> [a] -> [a]
: [Exp]
es)
            If Annote
_ Maybe Poly
_pt Maybe Ty
_mt Exp
t Exp
c Exp
a                         -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann
"if" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
t Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
"then" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
c Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
"else" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
a
            Let Annote
_ Maybe Poly
_pt Maybe Ty
_mt [PatBind]
pbs Exp
e                        -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann
"let" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
forall ann. Doc ann
softline Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
align ([Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ (PatBind -> Doc ann) -> [PatBind] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map PatBind -> Doc ann
forall ann. PatBind -> Doc ann
pLetBind [PatBind]
pbs [Doc ann] -> [Doc ann] -> [Doc ann]
forall a. [a] -> [a] -> [a]
++ [ Doc ann
"in" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
e])
            RecVal Annote
_ Maybe Poly
_pt Maybe Ty
_mt [(Text, Exp)]
fs                        -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ ((Text, Exp) -> Doc ann) -> [(Text, Exp)] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map (\(Text
f, Exp
e) -> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
f Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
"=" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
e) [(Text, Exp)]
fs
            RecSel Annote
_ Maybe Poly
_pt Maybe Ty
_mt Text
f Exp
e                       -> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
e Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
forall ann. Doc ann
dot Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
f
            RecUpd Annote
_ Maybe Poly
_pt Maybe Ty
_mt Exp
e [(Text, Exp)]
fs                      -> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
e Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces ([Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ ((Text, Exp) -> Doc ann) -> [(Text, Exp)] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map (\(Text
f, Exp
e') -> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
f Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
"=" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
e') [(Text, Exp)]
fs)
            where
            pLetBind :: PatBind -> Doc ann
            pLetBind :: forall ann. PatBind -> Doc ann
pLetBind (PatBind Pat
p Exp
e) = Pat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Pat -> Doc ann
pretty Pat
p Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
"=" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
e

---

data Pat = PatCon      Annote !(Maybe Poly) !(Maybe Ty) !Text ![Pat]
         | PatVar      Annote !(Maybe Poly) !(Maybe Ty) !Text
         | PatWildCard Annote !(Maybe Poly) !(Maybe Ty)
         | PatTuple    Annote !(Maybe Poly) !(Maybe Ty) ![Pat]
         | PatAs       Annote !(Maybe Poly) !(Maybe Ty) !Text !Pat -- ^ should only appear in FunBindings
         | PatRec      Annote !(Maybe Poly) !(Maybe Ty) ![(Text,Pat)]
      deriving (Pat -> Pat -> Bool
(Pat -> Pat -> Bool) -> (Pat -> Pat -> Bool) -> Eq Pat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat -> Pat -> Bool
== :: Pat -> Pat -> Bool
$c/= :: Pat -> Pat -> Bool
/= :: Pat -> Pat -> Bool
Eq, Int -> Pat -> ShowS
[Pat] -> ShowS
Pat -> String
(Int -> Pat -> ShowS)
-> (Pat -> String) -> ([Pat] -> ShowS) -> Show Pat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Pat -> ShowS
showsPrec :: Int -> Pat -> ShowS
$cshow :: Pat -> String
show :: Pat -> String
$cshowList :: [Pat] -> ShowS
showList :: [Pat] -> ShowS
Show, (forall x. Pat -> Rep Pat x)
-> (forall x. Rep Pat x -> Pat) -> Generic Pat
forall x. Rep Pat x -> Pat
forall x. Pat -> Rep Pat x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Pat -> Rep Pat x
from :: forall x. Pat -> Rep Pat x
$cto :: forall x. Rep Pat x -> Pat
to :: forall x. Rep Pat x -> Pat
Generic, Typeable, Typeable Pat
Typeable Pat =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Pat -> c Pat)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pat)
-> (Pat -> Constr)
-> (Pat -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pat))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat))
-> ((forall b. Data b => b -> b) -> Pat -> Pat)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pat -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Pat -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat)
-> Data Pat
Pat -> Constr
Pat -> DataType
(forall b. Data b => b -> b) -> Pat -> Pat
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) -> Pat -> u
forall u. (forall d. Data d => d -> u) -> Pat -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pat)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
$ctoConstr :: Pat -> Constr
toConstr :: Pat -> Constr
$cdataTypeOf :: Pat -> DataType
dataTypeOf :: Pat -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pat)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
$cgmapT :: (forall b. Data b => b -> b) -> Pat -> Pat
gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pat -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Pat -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pat -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pat -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
Data)

instance Hashable Pat


instance Annotated Pat where
      ann :: Pat -> Annote
ann = \ case
            PatCon Annote
a Maybe Poly
_ Maybe Ty
_ Text
_ [Pat]
_  -> Annote
a
            PatVar Annote
a Maybe Poly
_ Maybe Ty
_ Text
_    -> Annote
a
            PatWildCard Annote
a Maybe Poly
_ Maybe Ty
_ -> Annote
a
            PatTuple Annote
a Maybe Poly
_ Maybe Ty
_ [Pat]
_  -> Annote
a
            PatAs Annote
a Maybe Poly
_ Maybe Ty
_ Text
_ Pat
_   -> Annote
a
            PatRec Annote
a Maybe Poly
_ Maybe Ty
_ [(Text, Pat)]
_    -> Annote
a

instance Parenless Pat where
      parenless :: Pat -> Bool
parenless = \ case
            PatCon Annote
_ Maybe Poly
_ Maybe Ty
_ Text
_ []  -> Bool
True
            PatVar {}          -> Bool
True
            PatWildCard {}     -> Bool
True
            PatTuple {}        -> Bool
True
            PatAs {}           -> Bool
True
            Pat
_                  -> Bool
False

instance Pretty Pat where
      pretty :: forall ann. Pat -> Doc ann
pretty = \ case
            PatCon Annote
_ Maybe Poly
pt Maybe Ty
_ Text
n [Pat]
ps   -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ((Pat -> Doc ann) -> [Pat] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Pat -> Doc ann
forall a ann. (Pretty a, Parenless a) => a -> Doc ann
mparens [Pat]
ps)
            PatVar Annote
_ Maybe Poly
pt Maybe Ty
_ Text
n      -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n
            PatWildCard Annote
_ Maybe Poly
pt Maybe Ty
_   -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"_"
            PatTuple Annote
_ Maybe Poly
pt Maybe Ty
_ [Pat]
ps   -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Pat -> Doc ann) -> [Pat] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Pat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Pat -> Doc ann
pretty [Pat]
ps
            PatAs Annote
_ Maybe Poly
pt Maybe Ty
_ Text
n Pat
p     -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
"@" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Pat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Pat -> Doc ann
pretty Pat
p)
            PatRec Annote
_ Maybe Poly
pt Maybe Ty
_ [(Text, Pat)]
fs     -> Maybe Poly -> Doc ann -> Doc ann
forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
pt (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ ((Text, Pat) -> Doc ann) -> [(Text, Pat)] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map (Text, Pat) -> Doc ann
forall ann. (Text, Pat) -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [(Text, Pat)]
fs

---

data FunBinding = FunBinding Annote ![Pat] !Exp
      deriving (FunBinding -> FunBinding -> Bool
(FunBinding -> FunBinding -> Bool)
-> (FunBinding -> FunBinding -> Bool) -> Eq FunBinding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FunBinding -> FunBinding -> Bool
== :: FunBinding -> FunBinding -> Bool
$c/= :: FunBinding -> FunBinding -> Bool
/= :: FunBinding -> FunBinding -> Bool
Eq, (forall x. FunBinding -> Rep FunBinding x)
-> (forall x. Rep FunBinding x -> FunBinding) -> Generic FunBinding
forall x. Rep FunBinding x -> FunBinding
forall x. FunBinding -> Rep FunBinding x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FunBinding -> Rep FunBinding x
from :: forall x. FunBinding -> Rep FunBinding x
$cto :: forall x. Rep FunBinding x -> FunBinding
to :: forall x. Rep FunBinding x -> FunBinding
Generic, Int -> FunBinding -> ShowS
[FunBinding] -> ShowS
FunBinding -> String
(Int -> FunBinding -> ShowS)
-> (FunBinding -> String)
-> ([FunBinding] -> ShowS)
-> Show FunBinding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FunBinding -> ShowS
showsPrec :: Int -> FunBinding -> ShowS
$cshow :: FunBinding -> String
show :: FunBinding -> String
$cshowList :: [FunBinding] -> ShowS
showList :: [FunBinding] -> ShowS
Show, Typeable, Typeable FunBinding
Typeable FunBinding =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FunBinding -> c FunBinding)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FunBinding)
-> (FunBinding -> Constr)
-> (FunBinding -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FunBinding))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FunBinding))
-> ((forall b. Data b => b -> b) -> FunBinding -> FunBinding)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FunBinding -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FunBinding -> r)
-> (forall u. (forall d. Data d => d -> u) -> FunBinding -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FunBinding -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FunBinding -> m FunBinding)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunBinding -> m FunBinding)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunBinding -> m FunBinding)
-> Data FunBinding
FunBinding -> Constr
FunBinding -> DataType
(forall b. Data b => b -> b) -> FunBinding -> FunBinding
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) -> FunBinding -> u
forall u. (forall d. Data d => d -> u) -> FunBinding -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunBinding -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunBinding -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FunBinding -> m FunBinding
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunBinding -> m FunBinding
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunBinding
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunBinding -> c FunBinding
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FunBinding)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunBinding)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunBinding -> c FunBinding
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunBinding -> c FunBinding
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunBinding
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunBinding
$ctoConstr :: FunBinding -> Constr
toConstr :: FunBinding -> Constr
$cdataTypeOf :: FunBinding -> DataType
dataTypeOf :: FunBinding -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FunBinding)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FunBinding)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunBinding)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunBinding)
$cgmapT :: (forall b. Data b => b -> b) -> FunBinding -> FunBinding
gmapT :: (forall b. Data b => b -> b) -> FunBinding -> FunBinding
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunBinding -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunBinding -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunBinding -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunBinding -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FunBinding -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FunBinding -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FunBinding -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FunBinding -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FunBinding -> m FunBinding
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FunBinding -> m FunBinding
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunBinding -> m FunBinding
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunBinding -> m FunBinding
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunBinding -> m FunBinding
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunBinding -> m FunBinding
Data)

instance Hashable FunBinding

instance Pretty FunBinding where
      pretty :: forall ann. FunBinding -> Doc ann
pretty (FunBinding Annote
_ [Pat]
ps Exp
rhs) = [Pat] -> Exp -> Doc ann
forall ann. [Pat] -> Exp -> Doc ann
pFunCase [Pat]
ps Exp
rhs

pFunCase :: [Pat] -> Exp -> Doc ann
pFunCase :: forall ann. [Pat] -> Exp -> Doc ann
pFunCase [Pat]
ps Exp
e = [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ((Pat -> Doc ann) -> [Pat] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Pat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Pat -> Doc ann
pretty [Pat]
ps) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
"|->" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Exp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Exp -> Doc ann
pretty Exp
e

getPatVars :: (MonadError AstError m) => [Pat] -> m [Text]
getPatVars :: forall (m :: * -> *). MonadError AstError m => [Pat] -> m [Text]
getPatVars [] = [Text] -> m [Text]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return []
getPatVars (PatVar Annote
_ Maybe Poly
_ Maybe Ty
_ Text
v : [Pat]
ps) = [Pat] -> m [Text]
forall (m :: * -> *). MonadError AstError m => [Pat] -> m [Text]
getPatVars [Pat]
ps m [Text] -> ([Text] -> m [Text]) -> m [Text]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ [Text]
vs -> [Text] -> m [Text]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Text] -> m [Text]) -> [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ Text
v Text -> [Text] -> [Text]
forall a. a -> [a] -> [a]
: [Text]
vs
getPatVars (PatCon Annote
_ Maybe Poly
_ Maybe Ty
_ Text
_n [Pat]
ps : [Pat]
ps') = [Pat] -> m [Text]
forall (m :: * -> *). MonadError AstError m => [Pat] -> m [Text]
getPatVars [Pat]
ps' m [Text] -> ([Text] -> m [Text]) -> m [Text]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ [Text]
vs' -> [Pat] -> m [Text]
forall (m :: * -> *). MonadError AstError m => [Pat] -> m [Text]
getPatVars [Pat]
ps m [Text] -> ([Text] -> m [Text]) -> m [Text]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ [Text]
vs -> [Text] -> m [Text]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Text] -> m [Text]) -> [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ [Text]
vs [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text]
vs'
getPatVars (PatTuple Annote
_ Maybe Poly
_ Maybe Ty
_ [Pat]
ps : [Pat]
ps') = [Pat] -> m [Text]
forall (m :: * -> *). MonadError AstError m => [Pat] -> m [Text]
getPatVars [Pat]
ps' m [Text] -> ([Text] -> m [Text]) -> m [Text]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ [Text]
vs' -> [Pat] -> m [Text]
forall (m :: * -> *). MonadError AstError m => [Pat] -> m [Text]
getPatVars [Pat]
ps m [Text] -> ([Text] -> m [Text]) -> m [Text]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ [Text]
vs -> [Text] -> m [Text]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Text] -> m [Text]) -> [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ [Text]
vs [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text]
vs'
getPatVars (PatWildCard {} : [Pat]
ps) = [Pat] -> m [Text]
forall (m :: * -> *). MonadError AstError m => [Pat] -> m [Text]
getPatVars [Pat]
ps
getPatVars (PatAs Annote
_ Maybe Poly
_ Maybe Ty
_ Text
n Pat
p : [Pat]
ps) = [Pat] -> m [Text]
forall (m :: * -> *). MonadError AstError m => [Pat] -> m [Text]
getPatVars [Pat
p] m [Text] -> ([Text] -> m [Text]) -> m [Text]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ [Text]
vs' -> [Pat] -> m [Text]
forall (m :: * -> *). MonadError AstError m => [Pat] -> m [Text]
getPatVars [Pat]
ps m [Text] -> ([Text] -> m [Text]) -> m [Text]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ [Text]
vs -> [Text] -> m [Text]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Text] -> m [Text]) -> [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ Text
n Text -> [Text] -> [Text]
forall a. a -> [a] -> [a]
: [Text]
vs [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text]
vs'
getPatVars (PatRec Annote
_ Maybe Poly
_ Maybe Ty
_ [(Text, Pat)]
fs : [Pat]
ps) = [Pat] -> m [Text]
forall (m :: * -> *). MonadError AstError m => [Pat] -> m [Text]
getPatVars (((Text, Pat) -> Pat) -> [(Text, Pat)] -> [Pat]
forall a b. (a -> b) -> [a] -> [b]
map (Text, Pat) -> Pat
forall a b. (a, b) -> b
snd [(Text, Pat)]
fs) m [Text] -> ([Text] -> m [Text]) -> m [Text]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ [Text]
vs' -> [Pat] -> m [Text]
forall (m :: * -> *). MonadError AstError m => [Pat] -> m [Text]
getPatVars [Pat]
ps m [Text] -> ([Text] -> m [Text]) -> m [Text]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ [Text]
vs -> [Text] -> m [Text]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Text] -> m [Text]) -> [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ [Text]
vs [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text]
vs'

data Defn = Defn
            { Defn -> Annote
defnAnnote :: Annote
            , Defn -> Text
defnName   :: !Text
            , Defn -> Poly
defnPolyTy :: !Poly
            , Defn -> Maybe DefnAttr
defnAttr   :: !(Maybe DefnAttr)
            , Defn -> [FunBinding]
defnBinds  :: ![FunBinding]
            }
      deriving (Defn -> Defn -> Bool
(Defn -> Defn -> Bool) -> (Defn -> Defn -> Bool) -> Eq Defn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn -> Defn -> Bool
== :: Defn -> Defn -> Bool
$c/= :: Defn -> Defn -> Bool
/= :: Defn -> Defn -> Bool
Eq, (forall x. Defn -> Rep Defn x)
-> (forall x. Rep Defn x -> Defn) -> Generic Defn
forall x. Rep Defn x -> Defn
forall x. Defn -> Rep Defn x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Defn -> Rep Defn x
from :: forall x. Defn -> Rep Defn x
$cto :: forall x. Rep Defn x -> Defn
to :: forall x. Rep Defn x -> Defn
Generic, Int -> Defn -> ShowS
[Defn] -> ShowS
Defn -> String
(Int -> Defn -> ShowS)
-> (Defn -> String) -> ([Defn] -> ShowS) -> Show Defn
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Defn -> ShowS
showsPrec :: Int -> Defn -> ShowS
$cshow :: Defn -> String
show :: Defn -> String
$cshowList :: [Defn] -> ShowS
showList :: [Defn] -> ShowS
Show, Typeable, Typeable Defn
Typeable Defn =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Defn -> c Defn)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Defn)
-> (Defn -> Constr)
-> (Defn -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Defn))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Defn))
-> ((forall b. Data b => b -> b) -> Defn -> Defn)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r)
-> (forall u. (forall d. Data d => d -> u) -> Defn -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Defn -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Defn -> m Defn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Defn -> m Defn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Defn -> m Defn)
-> Data Defn
Defn -> Constr
Defn -> DataType
(forall b. Data b => b -> b) -> Defn -> Defn
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) -> Defn -> u
forall u. (forall d. Data d => d -> u) -> Defn -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Defn -> m Defn
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Defn -> m Defn
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Defn
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Defn -> c Defn
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Defn)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Defn)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Defn -> c Defn
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Defn -> c Defn
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Defn
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Defn
$ctoConstr :: Defn -> Constr
toConstr :: Defn -> Constr
$cdataTypeOf :: Defn -> DataType
dataTypeOf :: Defn -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Defn)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Defn)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Defn)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Defn)
$cgmapT :: (forall b. Data b => b -> b) -> Defn -> Defn
gmapT :: (forall b. Data b => b -> b) -> Defn -> Defn
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Defn -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Defn -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Defn -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Defn -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Defn -> m Defn
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Defn -> m Defn
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Defn -> m Defn
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Defn -> m Defn
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Defn -> m Defn
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Defn -> m Defn
Data)

instance Hashable Defn

instance Annotated Defn where
      ann :: Defn -> Annote
ann (Defn Annote
a Text
_ Poly
_ Maybe DefnAttr
_ [FunBinding]
_) = Annote
a

instance Pretty Defn where
      pretty :: forall ann. Defn -> Doc ann
pretty (Defn Annote
_ Text
n Poly
t Maybe DefnAttr
attr [FunBinding]
bs) =
            Identity (Doc ann) -> Doc ann
forall a. Identity a -> a
runIdentity (Identity (Doc ann) -> Doc ann) -> Identity (Doc ann) -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> Identity (Doc ann)
forall a. a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Doc ann -> Identity (Doc ann)) -> Doc ann -> Identity (Doc ann)
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ (Doc ann -> Doc ann) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2)
                 ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$  [ Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"{-# INLINE" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"#-}"   | Maybe DefnAttr
attr Maybe DefnAttr -> Maybe DefnAttr -> Bool
forall a. Eq a => a -> a -> Bool
== DefnAttr -> Maybe DefnAttr
forall a. a -> Maybe a
Just DefnAttr
Inline   ]
                 [Doc ann] -> [Doc ann] -> [Doc ann]
forall a. Semigroup a => a -> a -> a
<> [ Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"{-# NOINLINE" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"#-}" | Maybe DefnAttr
attr Maybe DefnAttr -> Maybe DefnAttr -> Bool
forall a. Eq a => a -> a -> Bool
== DefnAttr -> Maybe DefnAttr
forall a. a -> Maybe a
Just DefnAttr
NoInline ]
                 [Doc ann] -> [Doc ann] -> [Doc ann]
forall a. Semigroup a => a -> a -> a
<> [ Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"::" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Poly -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Poly -> Doc ann
pretty Poly
t ]
                 [Doc ann] -> [Doc ann] -> [Doc ann]
forall a. Semigroup a => a -> a -> a
<> (FunBinding -> Doc ann) -> [FunBinding] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map FunBinding -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. FunBinding -> Doc ann
pretty [FunBinding]
bs

---

data DefnAttr = Inline | NoInline
      deriving (DefnAttr -> DefnAttr -> Bool
(DefnAttr -> DefnAttr -> Bool)
-> (DefnAttr -> DefnAttr -> Bool) -> Eq DefnAttr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DefnAttr -> DefnAttr -> Bool
== :: DefnAttr -> DefnAttr -> Bool
$c/= :: DefnAttr -> DefnAttr -> Bool
/= :: DefnAttr -> DefnAttr -> Bool
Eq, (forall x. DefnAttr -> Rep DefnAttr x)
-> (forall x. Rep DefnAttr x -> DefnAttr) -> Generic DefnAttr
forall x. Rep DefnAttr x -> DefnAttr
forall x. DefnAttr -> Rep DefnAttr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DefnAttr -> Rep DefnAttr x
from :: forall x. DefnAttr -> Rep DefnAttr x
$cto :: forall x. Rep DefnAttr x -> DefnAttr
to :: forall x. Rep DefnAttr x -> DefnAttr
Generic, Int -> DefnAttr -> ShowS
[DefnAttr] -> ShowS
DefnAttr -> String
(Int -> DefnAttr -> ShowS)
-> (DefnAttr -> String) -> ([DefnAttr] -> ShowS) -> Show DefnAttr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DefnAttr -> ShowS
showsPrec :: Int -> DefnAttr -> ShowS
$cshow :: DefnAttr -> String
show :: DefnAttr -> String
$cshowList :: [DefnAttr] -> ShowS
showList :: [DefnAttr] -> ShowS
Show, Typeable, Typeable DefnAttr
Typeable DefnAttr =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DefnAttr -> c DefnAttr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DefnAttr)
-> (DefnAttr -> Constr)
-> (DefnAttr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DefnAttr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DefnAttr))
-> ((forall b. Data b => b -> b) -> DefnAttr -> DefnAttr)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DefnAttr -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DefnAttr -> r)
-> (forall u. (forall d. Data d => d -> u) -> DefnAttr -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DefnAttr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DefnAttr -> m DefnAttr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DefnAttr -> m DefnAttr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DefnAttr -> m DefnAttr)
-> Data DefnAttr
DefnAttr -> Constr
DefnAttr -> DataType
(forall b. Data b => b -> b) -> DefnAttr -> DefnAttr
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) -> DefnAttr -> u
forall u. (forall d. Data d => d -> u) -> DefnAttr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefnAttr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefnAttr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DefnAttr -> m DefnAttr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefnAttr -> m DefnAttr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefnAttr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefnAttr -> c DefnAttr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DefnAttr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DefnAttr)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefnAttr -> c DefnAttr
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefnAttr -> c DefnAttr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefnAttr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefnAttr
$ctoConstr :: DefnAttr -> Constr
toConstr :: DefnAttr -> Constr
$cdataTypeOf :: DefnAttr -> DataType
dataTypeOf :: DefnAttr -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DefnAttr)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DefnAttr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DefnAttr)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DefnAttr)
$cgmapT :: (forall b. Data b => b -> b) -> DefnAttr -> DefnAttr
gmapT :: (forall b. Data b => b -> b) -> DefnAttr -> DefnAttr
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefnAttr -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefnAttr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefnAttr -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefnAttr -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DefnAttr -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DefnAttr -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DefnAttr -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DefnAttr -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DefnAttr -> m DefnAttr
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DefnAttr -> m DefnAttr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefnAttr -> m DefnAttr
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefnAttr -> m DefnAttr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefnAttr -> m DefnAttr
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefnAttr -> m DefnAttr
Data)

instance Hashable DefnAttr


---

-- | this is just a synonym for the dataName and dataVars of a DataDefn
type DataHeader = (Text,[Text])

data DataDefn = DataDefn
      { DataDefn -> Annote
dataAnnote :: Annote
      , DataDefn -> Text
dataName   :: !Text
      , DataDefn -> [Text]
dataVars   :: ![Text]
      , DataDefn -> [DataCon]
dataCons   :: ![DataCon]
      }
      deriving (DataDefn -> DataDefn -> Bool
(DataDefn -> DataDefn -> Bool)
-> (DataDefn -> DataDefn -> Bool) -> Eq DataDefn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DataDefn -> DataDefn -> Bool
== :: DataDefn -> DataDefn -> Bool
$c/= :: DataDefn -> DataDefn -> Bool
/= :: DataDefn -> DataDefn -> Bool
Eq, (forall x. DataDefn -> Rep DataDefn x)
-> (forall x. Rep DataDefn x -> DataDefn) -> Generic DataDefn
forall x. Rep DataDefn x -> DataDefn
forall x. DataDefn -> Rep DataDefn x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DataDefn -> Rep DataDefn x
from :: forall x. DataDefn -> Rep DataDefn x
$cto :: forall x. Rep DataDefn x -> DataDefn
to :: forall x. Rep DataDefn x -> DataDefn
Generic, Int -> DataDefn -> ShowS
[DataDefn] -> ShowS
DataDefn -> String
(Int -> DataDefn -> ShowS)
-> (DataDefn -> String) -> ([DataDefn] -> ShowS) -> Show DataDefn
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DataDefn -> ShowS
showsPrec :: Int -> DataDefn -> ShowS
$cshow :: DataDefn -> String
show :: DataDefn -> String
$cshowList :: [DataDefn] -> ShowS
showList :: [DataDefn] -> ShowS
Show, Typeable, Typeable DataDefn
Typeable DataDefn =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DataDefn -> c DataDefn)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataDefn)
-> (DataDefn -> Constr)
-> (DataDefn -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataDefn))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDefn))
-> ((forall b. Data b => b -> b) -> DataDefn -> DataDefn)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDefn -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDefn -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataDefn -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DataDefn -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataDefn -> m DataDefn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataDefn -> m DataDefn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataDefn -> m DataDefn)
-> Data DataDefn
DataDefn -> Constr
DataDefn -> DataType
(forall b. Data b => b -> b) -> DataDefn -> DataDefn
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) -> DataDefn -> u
forall u. (forall d. Data d => d -> u) -> DataDefn -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDefn -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDefn -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataDefn -> m DataDefn
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDefn -> m DataDefn
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataDefn
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDefn -> c DataDefn
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataDefn)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDefn)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDefn -> c DataDefn
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDefn -> c DataDefn
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataDefn
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataDefn
$ctoConstr :: DataDefn -> Constr
toConstr :: DataDefn -> Constr
$cdataTypeOf :: DataDefn -> DataType
dataTypeOf :: DataDefn -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataDefn)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataDefn)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDefn)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDefn)
$cgmapT :: (forall b. Data b => b -> b) -> DataDefn -> DataDefn
gmapT :: (forall b. Data b => b -> b) -> DataDefn -> DataDefn
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDefn -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDefn -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDefn -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDefn -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataDefn -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataDefn -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataDefn -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataDefn -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataDefn -> m DataDefn
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataDefn -> m DataDefn
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDefn -> m DataDefn
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDefn -> m DataDefn
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDefn -> m DataDefn
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDefn -> m DataDefn
Data)


instance Annotated DataDefn where
      ann :: DataDefn -> Annote
ann (DataDefn Annote
a Text
_ [Text]
_ [DataCon]
_) = Annote
a

instance Pretty DataDefn where
      pretty :: forall ann. DataDefn -> Doc ann
pretty (DataDefn Annote
_ Text
n [Text]
tvs [DataCon]
cs) = Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep
            ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ (Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"data" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ((Text -> Doc ann) -> [Text] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Text -> Doc ann
forall ann. Text -> Doc ann
text [Text]
tvs) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"where")
            Doc ann -> [Doc ann] -> [Doc ann]
forall a. a -> [a] -> [a]
: (DataCon -> Doc ann) -> [DataCon] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 (Doc ann -> Doc ann) -> (DataCon -> Doc ann) -> DataCon -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataCon -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. DataCon -> Doc ann
pretty) [DataCon]
cs

---

-- RecDefn, a specialized version of DataDefn

-- | this is just a synonym for the dataName and dataVars of a DataDefn
type RecHeader = (Text,[Text])

data RecDefn = RecDefn
      { RecDefn -> Annote
recAnnote :: Annote
      , RecDefn -> Text
recName   :: !Text
      , RecDefn -> [Text]
recVars   :: ![Text]
      , RecDefn -> Poly
recPoly   :: !Poly
      , RecDefn -> [(Text, Ty)]
recFields :: ![(Text, Ty)]
      }
      deriving (RecDefn -> RecDefn -> Bool
(RecDefn -> RecDefn -> Bool)
-> (RecDefn -> RecDefn -> Bool) -> Eq RecDefn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecDefn -> RecDefn -> Bool
== :: RecDefn -> RecDefn -> Bool
$c/= :: RecDefn -> RecDefn -> Bool
/= :: RecDefn -> RecDefn -> Bool
Eq, (forall x. RecDefn -> Rep RecDefn x)
-> (forall x. Rep RecDefn x -> RecDefn) -> Generic RecDefn
forall x. Rep RecDefn x -> RecDefn
forall x. RecDefn -> Rep RecDefn x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RecDefn -> Rep RecDefn x
from :: forall x. RecDefn -> Rep RecDefn x
$cto :: forall x. Rep RecDefn x -> RecDefn
to :: forall x. Rep RecDefn x -> RecDefn
Generic, Int -> RecDefn -> ShowS
[RecDefn] -> ShowS
RecDefn -> String
(Int -> RecDefn -> ShowS)
-> (RecDefn -> String) -> ([RecDefn] -> ShowS) -> Show RecDefn
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RecDefn -> ShowS
showsPrec :: Int -> RecDefn -> ShowS
$cshow :: RecDefn -> String
show :: RecDefn -> String
$cshowList :: [RecDefn] -> ShowS
showList :: [RecDefn] -> ShowS
Show, Typeable, Typeable RecDefn
Typeable RecDefn =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RecDefn -> c RecDefn)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RecDefn)
-> (RecDefn -> Constr)
-> (RecDefn -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RecDefn))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RecDefn))
-> ((forall b. Data b => b -> b) -> RecDefn -> RecDefn)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RecDefn -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RecDefn -> r)
-> (forall u. (forall d. Data d => d -> u) -> RecDefn -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RecDefn -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RecDefn -> m RecDefn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RecDefn -> m RecDefn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RecDefn -> m RecDefn)
-> Data RecDefn
RecDefn -> Constr
RecDefn -> DataType
(forall b. Data b => b -> b) -> RecDefn -> RecDefn
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) -> RecDefn -> u
forall u. (forall d. Data d => d -> u) -> RecDefn -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RecDefn -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RecDefn -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RecDefn -> m RecDefn
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecDefn -> m RecDefn
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RecDefn
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RecDefn -> c RecDefn
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RecDefn)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RecDefn)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RecDefn -> c RecDefn
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RecDefn -> c RecDefn
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RecDefn
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RecDefn
$ctoConstr :: RecDefn -> Constr
toConstr :: RecDefn -> Constr
$cdataTypeOf :: RecDefn -> DataType
dataTypeOf :: RecDefn -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RecDefn)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RecDefn)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RecDefn)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RecDefn)
$cgmapT :: (forall b. Data b => b -> b) -> RecDefn -> RecDefn
gmapT :: (forall b. Data b => b -> b) -> RecDefn -> RecDefn
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RecDefn -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RecDefn -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RecDefn -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RecDefn -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RecDefn -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RecDefn -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RecDefn -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RecDefn -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RecDefn -> m RecDefn
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RecDefn -> m RecDefn
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecDefn -> m RecDefn
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecDefn -> m RecDefn
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecDefn -> m RecDefn
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecDefn -> m RecDefn
Data)


instance Annotated RecDefn where
      ann :: RecDefn -> Annote
ann (RecDefn Annote
a Text
_ [Text]
_ Poly
_ [(Text, Ty)]
_) = Annote
a

instance Pretty RecDefn where
      pretty :: forall ann. RecDefn -> Doc ann
pretty (RecDefn Annote
_ Text
n [Text]
tvs Poly
_ [(Text, Ty)]
fs) = Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep
            ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ (Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"record" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ((Text -> Doc ann) -> [Text] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Text -> Doc ann
forall ann. Text -> Doc ann
text [Text]
tvs) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"where")
            Doc ann -> [Doc ann] -> [Doc ann]
forall a. a -> [a] -> [a]
: ((Text, Ty) -> Doc ann) -> [(Text, Ty)] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map (\ (Text
f,Ty
t) -> Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
f Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
"::" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Ty -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Ty -> Doc ann
pretty Ty
t) [(Text, Ty)]
fs

---

data TypeSynonym = TypeSynonym
      { TypeSynonym -> Annote
typeSynAnnote :: Annote
      , TypeSynonym -> Text
typeSynName   :: !Text
      , TypeSynonym -> Poly
typeSynType   :: !Poly
      }
      deriving (TypeSynonym -> TypeSynonym -> Bool
(TypeSynonym -> TypeSynonym -> Bool)
-> (TypeSynonym -> TypeSynonym -> Bool) -> Eq TypeSynonym
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeSynonym -> TypeSynonym -> Bool
== :: TypeSynonym -> TypeSynonym -> Bool
$c/= :: TypeSynonym -> TypeSynonym -> Bool
/= :: TypeSynonym -> TypeSynonym -> Bool
Eq, (forall x. TypeSynonym -> Rep TypeSynonym x)
-> (forall x. Rep TypeSynonym x -> TypeSynonym)
-> Generic TypeSynonym
forall x. Rep TypeSynonym x -> TypeSynonym
forall x. TypeSynonym -> Rep TypeSynonym x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TypeSynonym -> Rep TypeSynonym x
from :: forall x. TypeSynonym -> Rep TypeSynonym x
$cto :: forall x. Rep TypeSynonym x -> TypeSynonym
to :: forall x. Rep TypeSynonym x -> TypeSynonym
Generic, Int -> TypeSynonym -> ShowS
[TypeSynonym] -> ShowS
TypeSynonym -> String
(Int -> TypeSynonym -> ShowS)
-> (TypeSynonym -> String)
-> ([TypeSynonym] -> ShowS)
-> Show TypeSynonym
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TypeSynonym -> ShowS
showsPrec :: Int -> TypeSynonym -> ShowS
$cshow :: TypeSynonym -> String
show :: TypeSynonym -> String
$cshowList :: [TypeSynonym] -> ShowS
showList :: [TypeSynonym] -> ShowS
Show, Typeable, Typeable TypeSynonym
Typeable TypeSynonym =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TypeSynonym -> c TypeSynonym)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeSynonym)
-> (TypeSynonym -> Constr)
-> (TypeSynonym -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeSynonym))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TypeSynonym))
-> ((forall b. Data b => b -> b) -> TypeSynonym -> TypeSynonym)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeSynonym -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeSynonym -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeSynonym -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TypeSynonym -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeSynonym -> m TypeSynonym)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeSynonym -> m TypeSynonym)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeSynonym -> m TypeSynonym)
-> Data TypeSynonym
TypeSynonym -> Constr
TypeSynonym -> DataType
(forall b. Data b => b -> b) -> TypeSynonym -> TypeSynonym
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) -> TypeSynonym -> u
forall u. (forall d. Data d => d -> u) -> TypeSynonym -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSynonym -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSynonym -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeSynonym -> m TypeSynonym
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSynonym -> m TypeSynonym
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeSynonym
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSynonym -> c TypeSynonym
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeSynonym)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeSynonym)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSynonym -> c TypeSynonym
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSynonym -> c TypeSynonym
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeSynonym
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeSynonym
$ctoConstr :: TypeSynonym -> Constr
toConstr :: TypeSynonym -> Constr
$cdataTypeOf :: TypeSynonym -> DataType
dataTypeOf :: TypeSynonym -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeSynonym)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeSynonym)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeSynonym)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeSynonym)
$cgmapT :: (forall b. Data b => b -> b) -> TypeSynonym -> TypeSynonym
gmapT :: (forall b. Data b => b -> b) -> TypeSynonym -> TypeSynonym
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSynonym -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSynonym -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSynonym -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSynonym -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeSynonym -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TypeSynonym -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeSynonym -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeSynonym -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeSynonym -> m TypeSynonym
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeSynonym -> m TypeSynonym
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSynonym -> m TypeSynonym
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSynonym -> m TypeSynonym
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSynonym -> m TypeSynonym
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSynonym -> m TypeSynonym
Data)

instance Hashable TypeSynonym


instance Annotated TypeSynonym where
      ann :: TypeSynonym -> Annote
ann (TypeSynonym Annote
a Text
_ Poly
_) = Annote
a

instance Pretty TypeSynonym where
      pretty :: forall ann. TypeSynonym -> Doc ann
pretty (TypeSynonym Annote
_ Text
n (Poly [Text]
tvs Ty
t)) = Identity (Doc ann) -> Doc ann
forall a. Identity a -> a
runIdentity (Identity (Doc ann) -> Doc ann) -> Identity (Doc ann) -> Doc ann
forall a b. (a -> b) -> a -> b
$
            Doc ann -> Identity (Doc ann)
forall a. a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
n Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ((Text -> Doc ann) -> [Text] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Text -> Doc ann
forall ann. Text -> Doc ann
text [Text]
tvs) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
"=" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Ty -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Ty -> Doc ann
pretty Ty
t)
---

type FreeProgram = ([DataDefn], [RecDefn], [TypeSynonym], [Defn])

newtype Program = Program ([DataDefn], [RecDefn], [TypeSynonym], [Defn])
      deriving ((forall x. Program -> Rep Program x)
-> (forall x. Rep Program x -> Program) -> Generic Program
forall x. Rep Program x -> Program
forall x. Program -> Rep Program x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Program -> Rep Program x
from :: forall x. Program -> Rep Program x
$cto :: forall x. Rep Program x -> Program
to :: forall x. Rep Program x -> Program
Generic, Int -> Program -> ShowS
[Program] -> ShowS
Program -> String
(Int -> Program -> ShowS)
-> (Program -> String) -> ([Program] -> ShowS) -> Show Program
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Program -> ShowS
showsPrec :: Int -> Program -> ShowS
$cshow :: Program -> String
show :: Program -> String
$cshowList :: [Program] -> ShowS
showList :: [Program] -> ShowS
Show, Typeable)

instance Pretty Program where
      pretty :: forall ann. Program -> Doc ann
pretty (Program ([DataDefn], [RecDefn], [TypeSynonym], [Defn])
p) = ([DataDefn], [RecDefn], [TypeSynonym], [Defn]) -> Doc ann
forall ann.
([DataDefn], [RecDefn], [TypeSynonym], [Defn]) -> Doc ann
prettyFP ([DataDefn], [RecDefn], [TypeSynonym], [Defn])
p

---

mparens :: (Pretty a, Parenless a) => a -> Doc ann
mparens :: forall a ann. (Pretty a, Parenless a) => a -> Doc ann
mparens a
a = if a -> Bool
forall a. Parenless a => a -> Bool
parenless a
a then a -> Doc ann
forall ann. a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty a
a else Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ a -> Doc ann
forall ann. a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty a
a

ppTyAnn :: Maybe Poly -> Doc ann -> Doc ann
ppTyAnn :: forall ann. Maybe Poly -> Doc ann -> Doc ann
ppTyAnn Maybe Poly
Nothing Doc ann
d = Doc ann
d
ppTyAnn (Just Poly
pt) Doc ann
d = Doc ann
d Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
text Text
"::" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Poly -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Poly -> Doc ann
pretty Poly
pt

-- TODO(chathhorn): make FreeProgram newtype.
prettyFP :: FreeProgram -> Doc ann
prettyFP :: forall ann.
([DataDefn], [RecDefn], [TypeSynonym], [Defn]) -> Doc ann
prettyFP ([DataDefn]
ts, [RecDefn]
rs, [TypeSynonym]
syns, [Defn]
vs) = [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall a. a -> [a] -> [a]
intersperse Doc ann
forall ann. Doc ann
empty ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (DataDefn -> Doc ann) -> [DataDefn] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map DataDefn -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. DataDefn -> Doc ann
pretty [DataDefn]
ts [Doc ann] -> [Doc ann] -> [Doc ann]
forall a. Semigroup a => a -> a -> a
<> (RecDefn -> Doc ann) -> [RecDefn] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map RecDefn -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. RecDefn -> Doc ann
pretty [RecDefn]
rs [Doc ann] -> [Doc ann] -> [Doc ann]
forall a. Semigroup a => a -> a -> a
<> (TypeSynonym -> Doc ann) -> [TypeSynonym] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map TypeSynonym -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TypeSynonym -> Doc ann
pretty [TypeSynonym]
syns [Doc ann] -> [Doc ann] -> [Doc ann]
forall a. Semigroup a => a -> a -> a
<> (Defn -> Doc ann) -> [Defn] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Defn -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Defn -> Doc ann
pretty [Defn]
vs