{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE Trustworthy #-}

module Embedder.Builtins 
    (Builtin(..), builtinName, builtins,
     TyBuiltin(..), s2tb, tb2s, tybuiltins,
     builtinUserQName, builtinUserName,
     RWUserOp(..), rwu2s, s2rwu, rwu2qn, qn2rwu) where

import GHC.Generics (Generic)
import Data.Data (Typeable, Data)
import Data.Text (Text)
import Data.Tuple (swap)
import Data.Hashable (Hashable)
import Control.DeepSeq (NFData)
import Control.Arrow ((&&&))

import ReWire.Builtins (Builtin (..), builtinName, builtins)
import ReWire.Pretty (Pretty (..), TextShow, FromGeneric(..))

-- | Note: this is not injective (e.g., VecConcat has two notations)
--
--   Note: there are Builtins that don't have direct corresponding notations (e.g. Bits is used in lit, but not directly)
builtinUserQName :: [(Builtin,Text)]
builtinUserQName :: [(Builtin, Text)]
builtinUserQName = [
      -- | ReWire
      (Builtin
Error, Text
"ReWire.error"), (Builtin
Extern, Text
"ReWire.externWithSig"),
      (Builtin
NatVal, Text
"ReWire.natVal"),
      (Builtin
Put, Text
"ReWire.put"), (Builtin
Get, Text
"ReWire.get"), (Builtin
Signal, Text
"ReWire.signal"),
      (Builtin
Lift, Text
"ReWire.lift"), (Builtin
Extrude, Text
"ReWire.extrude"),
      (Builtin
VecFromList,Text
"ReWire.fromList"),
      -- | Prelude
      (Builtin
Bind, Text
"ReWire.Prelude.>>="), (Builtin
Return, Text
"ReWire.Prelude.return"), (Builtin
Return, Text
"ReWire.Prelude.pure"),
      -- | Vectors
      (Builtin
VecReplicate, Text
"ReWire.Vectors.replicate"), (Builtin
VecReverse, Text
"ReWire.Vectors.reverse"),
      (Builtin
VecSlice, Text
"ReWire.Vectors.slice"), (Builtin
VecRSlice, Text
"ReWire.Vectors.rslice"), (Builtin
VecIndex, Text
"ReWire.Vectors.index"),
      (Builtin
VecIndexProxy, Text
"ReWire.Vectors.index'"), (Builtin
VecIndexProxy, Text
"ReWire.Vectors.!"),
      (Builtin
VecConcat, Text
"ReWire.Vectors.++"), (Builtin
VecMap, Text
"ReWire.Vectors.map"), (Builtin
VecGenerate, Text
"ReWire.Vectors.generate"),
      -- Missing prims: VecUpdate, VecBulkUpdate, VecIterate, VecZip
      -- | Finites
      (Builtin
Finite, Text
"ReWire.Finite.finite"), (Builtin
FiniteMinBound, Text
"ReWire.Finite.minBound"), (Builtin
FiniteMaxBound, Text
"ReWire.Finite.maxBound"), 
      (Builtin
ToFinite, Text
"ReWire.Finite.toFinite"), (Builtin
ToFiniteMod, Text
"ReWire.Finite.toFinite'"), (Builtin
FromFinite, Text
"ReWire.Finite.fromFinite"),
      -- | Bits
      (Builtin
Bits, Text
"RWC.Primitives.rwPrimBits"),
      (Builtin
Add, Text
"ReWire.Bits.+"), (Builtin
Sub, Text
"ReWire.Bits.-"), (Builtin
Mul, Text
"ReWire.Bits.*"), (Builtin
Div, Text
"ReWire.Bits./"), (Builtin
Mod, Text
"ReWire.Bits.%"), (Builtin
Pow, Text
"ReWire.Bits.**"), 
      (Builtin
Resize, Text
"ReWire.Bits.resize"), (Builtin
BitSlice, Text
"ReWire.Bits.finBitSlice"),(Builtin
BitIndex, Text
"ReWire.Bits.finBitIndex"), 
      (Builtin
LAnd, Text
"ReWire.Bits.&&."), (Builtin
LOr, Text
"ReWire.Bits.||."), (Builtin
LNot, Text
"ReWire.Bits.lnot"),
      (Builtin
And, Text
"ReWire.Bits..&."), (Builtin
Or, Text
"ReWire.Bits..|."), (Builtin
Not, Text
"ReWire.Bits.bnot"), (Builtin
XOr, Text
"ReWire.Bits.^"), (Builtin
XNor, Text
"ReWire.Bits.~^"), 
      (Builtin
LShift, Text
"ReWire.Bits.<<."), (Builtin
RShift, Text
"ReWire.Bits.>>."), (Builtin
RShiftArith, Text
"ReWire.Bits.>>>"), 
      (Builtin
Eq, Text
"ReWire.Bits.=="), (Builtin
Gt, Text
"ReWire.Bits.>"), (Builtin
GtEq, Text
"ReWire.Bits.>="), (Builtin
Lt, Text
"ReWire.Bits.<"), (Builtin
LtEq, Text
"ReWire.Bits.<="),  
      (Builtin
RAnd, Text
"ReWire.Bits.rAnd"), (Builtin
RNAnd, Text
"ReWire.Bits.rNAnd"), (Builtin
ROr, Text
"ReWire.Bits.rOr"), (Builtin
RNor, Text
"ReWire.Bits.rNor"), (Builtin
RXOr, Text
"ReWire.Bits.rXOr"), (Builtin
RXNor, Text
"ReWire.Bits.rXNor"), 
      (Builtin
MSBit, Text
"ReWire.Bits.msbit"), (Builtin
MSBit, Text
"ReWire.Bits.bit"), (Builtin
VecConcat, Text
"ReWire.Bits.<>") ]
      -- Missing prims: ToInteger,
      -- Missing Builtins: Bits,

builtinUserName :: [(Builtin,Text)]
builtinUserName :: [(Builtin, Text)]
builtinUserName = [
      -- | ReWire
      (Builtin
Error, Text
"error"), (Builtin
Extern, Text
"externWithSig"),
      (Builtin
NatVal, Text
"natVal"),
      (Builtin
Put, Text
"put"), (Builtin
Get, Text
"get"), (Builtin
Signal, Text
"signal"),
      (Builtin
Lift, Text
"lift"), (Builtin
Extrude, Text
"extrude"),
      (Builtin
VecFromList,Text
"fromList"),
      -- | Prelude
      (Builtin
Bind, Text
">>="), (Builtin
Return, Text
"return"), (Builtin
Return, Text
"pure"),
      -- | Vectors
      (Builtin
VecReplicate, Text
"replicate"), (Builtin
VecReverse, Text
"reverse"),
      (Builtin
VecSlice, Text
"slice"), (Builtin
VecRSlice, Text
"rslice"), (Builtin
VecIndex, Text
"index"),
      (Builtin
VecIndexProxy, Text
"index'"), (Builtin
VecIndexProxy, Text
"!"),
      (Builtin
VecConcat, Text
"++"), (Builtin
VecMap, Text
"map"), (Builtin
VecGenerate, Text
"generate"),
      -- Missing prims: VecUpdate, VecBulkUpdate, VecIterate, VecZip
      -- | Finites
      (Builtin
Finite, Text
"finite"), (Builtin
FiniteMinBound, Text
"minBound"), (Builtin
FiniteMaxBound, Text
"maxBound"), 
      (Builtin
ToFinite, Text
"toFinite"), (Builtin
ToFiniteMod, Text
"toFinite'"), (Builtin
FromFinite, Text
"fromFinite"),
      -- | Bits
      (Builtin
Bits, Text
"rwPrimBits"),
      (Builtin
Add, Text
"+"), (Builtin
Sub, Text
"-"), (Builtin
Mul, Text
"*"), (Builtin
Div, Text
"/"), (Builtin
Mod, Text
"%"), (Builtin
Pow, Text
"**"), 
      (Builtin
Resize, Text
"resize"), (Builtin
BitSlice, Text
"finBitSlice"),(Builtin
BitIndex, Text
"finBitIndex"), 
      (Builtin
LAnd, Text
"&&."), (Builtin
LOr, Text
"||."), (Builtin
LNot, Text
"lnot"),
      (Builtin
And, Text
".&."), (Builtin
Or, Text
".|."), (Builtin
Not, Text
"bnot"), (Builtin
XOr, Text
"^"), (Builtin
XNor, Text
"~^"), 
      (Builtin
LShift, Text
"<<."), (Builtin
RShift, Text
">>."), (Builtin
RShiftArith, Text
">>>"), 
      (Builtin
Eq, Text
"=="), (Builtin
Gt, Text
">"), (Builtin
GtEq, Text
">="), (Builtin
Lt, Text
"<"), (Builtin
LtEq, Text
"<="),  
      (Builtin
RAnd, Text
"rAnd"), (Builtin
RNAnd, Text
"rNAnd"), (Builtin
ROr, Text
"rOr"), (Builtin
RNor, Text
"rNor"), (Builtin
RXOr, Text
"rXOr"), (Builtin
RXNor, Text
"rXNor"), 
      (Builtin
MSBit, Text
"msbit"), (Builtin
MSBit, Text
"bit")
      -- Missing prims: ToInteger,
      -- Missing Builtins: Bits, 
      ]


-- | Cases where we need to include specific handling for rewire-user definitions:
--
--   1. We need to print punctuation and infix notations carefully
--   2. We may need to differentiate based on type information in some circumstances:
--      a. We can't define a single operator over different monads (or can we?)
--      b. We need to differentiate between vector and word operations
--   3. We include Builtins because we handle them at the same junctures
--
--   We can handle other cases by writing a function or synonym in the Isabelle
--   ReWire session (rewire-embedder\/targets\/isabelle\/thys)
data RWUserOp = 
      -- No need to repeat most builtins
      RWBuiltin Builtin
      -- ops for functions
      | CompDot | CompDol 
      -- ops that match builtins: specified typing
      -- + Monads
      | BindI | BindS | BindR | BindRInf 
      | Seq | SeqI | SeqS | SeqR | SeqRInf
      | RBindI | RBindS | RBindR | RBindRInf -- reverse bind =<<
      | ReturnI | ReturnS | ReturnR
      | LiftS | LiftR
      -- + Words
      | WordIndexProxy
      | WordIndexFin
      -- + Finites
      -- + Vectors
      -- constructors from haskell prelude for builtin datatypes
      -- Data structures: ReWire.Prelude: Maybe a = Nothing | Just a, Either a b = Left a | Right b, Bool = True | False
      -- ops for builtin datatypes
      | BAnd | BOr | BXOr 
      | FinAdd | FinSub | FinMul | FinDiv | FinEq | FinLt
      | WordSlice | WordIndex | NEq | Update 
      -- (.), ($), (&&), (||), (=<<), (>>),
      -- (+), (-), (*), (div), (==), (<)
      -- `xor`, (@@)=bitSlice, (@.)=bitIndex, (/=)=not Eq, (!=)=update
      -- Additional notations:
      -- wordconcat: (VecConcat, "ReWire.Bits.<>")
      -- Prelude: id, const, flip, not, otherwise, maybe, either, fst, snd, curry, uncurry, undefined, 
      -- rewire-user notations that do not directly inline to builtins
      -- ReWire: Bit=Bool, W n=Vec n Bit, extern, modify, length, len
      -- Monad: iter, iterSt
      -- Vectors: 
      | VecLastIndexProxy -- in Isabelle, we can't overload notations that end in '
      -- | VecEmpty | VecSingleton | VecCons | VecSnoc | VecHead 
      -- | VecLastIndex | VecLastIndexProxy | VecTake | VecDrop | VecInit | VecTail 
      -- | VecZipWith | VecZipWith3 | VecPackLo | VecPackHi | VecUnpackLo | VecUnpackHi
      -- Additional notation: FiniteComp: even, odd
      -- Bits: zero, one, bit, lit, rotR, rotL, even, odd, Lit=W128
      deriving (RWUserOp -> RWUserOp -> Bool
(RWUserOp -> RWUserOp -> Bool)
-> (RWUserOp -> RWUserOp -> Bool) -> Eq RWUserOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RWUserOp -> RWUserOp -> Bool
== :: RWUserOp -> RWUserOp -> Bool
$c/= :: RWUserOp -> RWUserOp -> Bool
/= :: RWUserOp -> RWUserOp -> Bool
Eq, Eq RWUserOp
Eq RWUserOp =>
(RWUserOp -> RWUserOp -> Ordering)
-> (RWUserOp -> RWUserOp -> Bool)
-> (RWUserOp -> RWUserOp -> Bool)
-> (RWUserOp -> RWUserOp -> Bool)
-> (RWUserOp -> RWUserOp -> Bool)
-> (RWUserOp -> RWUserOp -> RWUserOp)
-> (RWUserOp -> RWUserOp -> RWUserOp)
-> Ord RWUserOp
RWUserOp -> RWUserOp -> Bool
RWUserOp -> RWUserOp -> Ordering
RWUserOp -> RWUserOp -> RWUserOp
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 :: RWUserOp -> RWUserOp -> Ordering
compare :: RWUserOp -> RWUserOp -> Ordering
$c< :: RWUserOp -> RWUserOp -> Bool
< :: RWUserOp -> RWUserOp -> Bool
$c<= :: RWUserOp -> RWUserOp -> Bool
<= :: RWUserOp -> RWUserOp -> Bool
$c> :: RWUserOp -> RWUserOp -> Bool
> :: RWUserOp -> RWUserOp -> Bool
$c>= :: RWUserOp -> RWUserOp -> Bool
>= :: RWUserOp -> RWUserOp -> Bool
$cmax :: RWUserOp -> RWUserOp -> RWUserOp
max :: RWUserOp -> RWUserOp -> RWUserOp
$cmin :: RWUserOp -> RWUserOp -> RWUserOp
min :: RWUserOp -> RWUserOp -> RWUserOp
Ord, (forall x. RWUserOp -> Rep RWUserOp x)
-> (forall x. Rep RWUserOp x -> RWUserOp) -> Generic RWUserOp
forall x. Rep RWUserOp x -> RWUserOp
forall x. RWUserOp -> Rep RWUserOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RWUserOp -> Rep RWUserOp x
from :: forall x. RWUserOp -> Rep RWUserOp x
$cto :: forall x. Rep RWUserOp x -> RWUserOp
to :: forall x. Rep RWUserOp x -> RWUserOp
Generic, Int -> RWUserOp -> ShowS
[RWUserOp] -> ShowS
RWUserOp -> String
(Int -> RWUserOp -> ShowS)
-> (RWUserOp -> String) -> ([RWUserOp] -> ShowS) -> Show RWUserOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RWUserOp -> ShowS
showsPrec :: Int -> RWUserOp -> ShowS
$cshow :: RWUserOp -> String
show :: RWUserOp -> String
$cshowList :: [RWUserOp] -> ShowS
showList :: [RWUserOp] -> ShowS
Show, Typeable, Typeable RWUserOp
Typeable RWUserOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RWUserOp -> c RWUserOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RWUserOp)
-> (RWUserOp -> Constr)
-> (RWUserOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RWUserOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RWUserOp))
-> ((forall b. Data b => b -> b) -> RWUserOp -> RWUserOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RWUserOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RWUserOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> RWUserOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RWUserOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RWUserOp -> m RWUserOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RWUserOp -> m RWUserOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RWUserOp -> m RWUserOp)
-> Data RWUserOp
RWUserOp -> Constr
RWUserOp -> DataType
(forall b. Data b => b -> b) -> RWUserOp -> RWUserOp
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) -> RWUserOp -> u
forall u. (forall d. Data d => d -> u) -> RWUserOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RWUserOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RWUserOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RWUserOp -> m RWUserOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RWUserOp -> m RWUserOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RWUserOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RWUserOp -> c RWUserOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RWUserOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RWUserOp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RWUserOp -> c RWUserOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RWUserOp -> c RWUserOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RWUserOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RWUserOp
$ctoConstr :: RWUserOp -> Constr
toConstr :: RWUserOp -> Constr
$cdataTypeOf :: RWUserOp -> DataType
dataTypeOf :: RWUserOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RWUserOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RWUserOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RWUserOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RWUserOp)
$cgmapT :: (forall b. Data b => b -> b) -> RWUserOp -> RWUserOp
gmapT :: (forall b. Data b => b -> b) -> RWUserOp -> RWUserOp
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RWUserOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RWUserOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RWUserOp -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RWUserOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RWUserOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RWUserOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RWUserOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RWUserOp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RWUserOp -> m RWUserOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RWUserOp -> m RWUserOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RWUserOp -> m RWUserOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RWUserOp -> m RWUserOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RWUserOp -> m RWUserOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RWUserOp -> m RWUserOp
Data)
      deriving Int -> RWUserOp -> Text
Int -> RWUserOp -> Text
Int -> RWUserOp -> Builder
[RWUserOp] -> Text
[RWUserOp] -> Text
[RWUserOp] -> Builder
RWUserOp -> Text
RWUserOp -> Text
RWUserOp -> Builder
(Int -> RWUserOp -> Builder)
-> (RWUserOp -> Builder)
-> ([RWUserOp] -> Builder)
-> (Int -> RWUserOp -> Text)
-> (RWUserOp -> Text)
-> ([RWUserOp] -> Text)
-> (Int -> RWUserOp -> Text)
-> (RWUserOp -> Text)
-> ([RWUserOp] -> Text)
-> TextShow RWUserOp
forall a.
(Int -> a -> Builder)
-> (a -> Builder)
-> ([a] -> Builder)
-> (Int -> a -> Text)
-> (a -> Text)
-> ([a] -> Text)
-> (Int -> a -> Text)
-> (a -> Text)
-> ([a] -> Text)
-> TextShow a
$cshowbPrec :: Int -> RWUserOp -> Builder
showbPrec :: Int -> RWUserOp -> Builder
$cshowb :: RWUserOp -> Builder
showb :: RWUserOp -> Builder
$cshowbList :: [RWUserOp] -> Builder
showbList :: [RWUserOp] -> Builder
$cshowtPrec :: Int -> RWUserOp -> Text
showtPrec :: Int -> RWUserOp -> Text
$cshowt :: RWUserOp -> Text
showt :: RWUserOp -> Text
$cshowtList :: [RWUserOp] -> Text
showtList :: [RWUserOp] -> Text
$cshowtlPrec :: Int -> RWUserOp -> Text
showtlPrec :: Int -> RWUserOp -> Text
$cshowtl :: RWUserOp -> Text
showtl :: RWUserOp -> Text
$cshowtlList :: [RWUserOp] -> Text
showtlList :: [RWUserOp] -> Text
TextShow via FromGeneric RWUserOp

instance Hashable RWUserOp
instance NFData RWUserOp

rwUserQName :: [(RWUserOp,Text)]
rwUserQName :: [(RWUserOp, Text)]
rwUserQName = [
      (RWUserOp
BindI     , Text
"ReWire.Prelude.>>=I"),  (RWUserOp
BindS     , Text
"ReWire.Prelude.>>=$"),
      (RWUserOp
BindR     , Text
"ReWire.Prelude.>>=~"),  (RWUserOp
BindRInf  , Text
"ReWire.Prelude.>>>=~"),
      (RWUserOp
RBindI    , Text
"ReWire.Prelude.=<<I"),  (RWUserOp
RBindS    , Text
"ReWire.Prelude.=<<$"),
      (RWUserOp
RBindR    , Text
"ReWire.Prelude.=<<~"),  (RWUserOp
RBindRInf , Text
"ReWire.Prelude.=<<<~"),
      (RWUserOp
Seq       , Text
"ReWire.Prelude.>>"),    (RWUserOp
SeqI      , Text
"ReWire.Prelude.>>I"),
      (RWUserOp
SeqS      , Text
"ReWire.Prelude.>>$"),   (RWUserOp
SeqR      , Text
"ReWire.Prelude.>>~"),
      (RWUserOp
SeqRInf   , Text
"ReWire.Prelude.>>>~"),  (RWUserOp
CompDot   , Text
"ReWire.Prelude.."),
      (RWUserOp
CompDol   , Text
"ReWire.Prelude.$"),     (RWUserOp
BAnd      , Text
"ReWire.Prelude.&&"),
      (RWUserOp
BOr       , Text
"ReWire.Prelude.||"),    (RWUserOp
BXOr      , Text
"ReWire.Bits.xor"),
      (RWUserOp
FinAdd    , Text
"ReWire.FiniteComp.+"),  (RWUserOp
FinSub    , Text
"ReWire.FiniteComp.-"),
      (RWUserOp
FinMul    , Text
"ReWire.FiniteComp.*"),  (RWUserOp
FinDiv    , Text
"ReWire.FiniteComp.div"),
      (RWUserOp
FinEq     , Text
"ReWire.FiniteComp.=="), (RWUserOp
FinLt     , Text
"ReWire.FiniteComp.<"),
      (RWUserOp
WordSlice , Text
"ReWire.Bits.@@"),       (RWUserOp
WordIndex , Text
"ReWire.Bits.@."),
      (RWUserOp
NEq       , Text
"ReWire.Bits./="),       (RWUserOp
Update    , Text
"ReWire.Vectors.!="),
      (RWUserOp
VecLastIndexProxy, Text
"ReWire.Vectors.lastIndex'"),
      (RWUserOp
WordIndexProxy, Text
"ReWire.Bits.!."), (RWUserOp
WordIndexFin, Text
"ReWire.Bits.!%")
      ]

rwUserName :: [(RWUserOp,Text)]
rwUserName :: [(RWUserOp, Text)]
rwUserName = [
      (RWUserOp
BindI     , Text
">>=I"),  (RWUserOp
BindS     , Text
">>=$"),  (RWUserOp
BindR     , Text
">>=~"),
      (RWUserOp
BindRInf  , Text
">>>=~"), (RWUserOp
RBindI    , Text
"=<<I"),  (RWUserOp
RBindS    , Text
"=<<$"),
      (RWUserOp
RBindR    , Text
"=<<~"),  (RWUserOp
RBindRInf , Text
"=<<<~"), (RWUserOp
Seq       , Text
">>"),
      (RWUserOp
SeqI      , Text
">>I"),   (RWUserOp
SeqS      , Text
">>$"),   (RWUserOp
SeqR      , Text
">>~"),
      (RWUserOp
SeqRInf   , Text
">>>~"),  (RWUserOp
CompDot   , Text
"."),     (RWUserOp
CompDol   , Text
"$"),
      (RWUserOp
BAnd      , Text
"&&"),    (RWUserOp
BOr       , Text
"||"),    (RWUserOp
BXOr      , Text
"xor"),
      (RWUserOp
FinAdd   , Text
"+"),      (RWUserOp
FinSub    , Text
"-"),     (RWUserOp
FinMul    , Text
"*"),
      (RWUserOp
FinDiv    , Text
"div"),   (RWUserOp
FinEq     , Text
"=="),    (RWUserOp
FinLt     , Text
"<"),
      (RWUserOp
WordSlice , Text
"@@"),    (RWUserOp
WordIndex , Text
"@."),    (RWUserOp
NEq       , Text
"/="),
      (RWUserOp
Update    , Text
"!="),    (RWUserOp
VecLastIndexProxy, Text
"lastIndex'"),
      (RWUserOp
WordIndexProxy, Text
"!."), (RWUserOp
WordIndexFin, Text
"!%")
      ]

rwu2s :: RWUserOp -> Maybe Text
rwu2s :: RWUserOp -> Maybe Text
rwu2s = \ case
      RWBuiltin Builtin
b -> Builtin -> [(Builtin, Text)] -> Maybe Text
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Builtin
b [(Builtin, Text)]
builtinUserName
      RWUserOp
b -> RWUserOp -> [(RWUserOp, Text)] -> Maybe Text
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup RWUserOp
b [(RWUserOp, Text)]
rwUserName

s2rwu :: Text -> Maybe RWUserOp
s2rwu :: Text -> Maybe RWUserOp
s2rwu = \ case
      Text
x | Just Builtin
b <- Text -> [(Text, Builtin)] -> Maybe Builtin
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Text
x (((Builtin, Text) -> (Text, Builtin))
-> [(Builtin, Text)] -> [(Text, Builtin)]
forall a b. (a -> b) -> [a] -> [b]
map (Builtin, Text) -> (Text, Builtin)
forall a b. (a, b) -> (b, a)
swap [(Builtin, Text)]
builtinUserName) -> RWUserOp -> Maybe RWUserOp
forall a. a -> Maybe a
Just (Builtin -> RWUserOp
RWBuiltin Builtin
b)
      Text
x -> Text -> [(Text, RWUserOp)] -> Maybe RWUserOp
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Text
x (((RWUserOp, Text) -> (Text, RWUserOp))
-> [(RWUserOp, Text)] -> [(Text, RWUserOp)]
forall a b. (a -> b) -> [a] -> [b]
map (RWUserOp, Text) -> (Text, RWUserOp)
forall a b. (a, b) -> (b, a)
swap [(RWUserOp, Text)]
rwUserName)

rwu2qn :: RWUserOp -> Maybe Text
rwu2qn :: RWUserOp -> Maybe Text
rwu2qn = \ case
      RWBuiltin Builtin
b -> Builtin -> [(Builtin, Text)] -> Maybe Text
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Builtin
b [(Builtin, Text)]
builtinUserQName
      RWUserOp
b -> RWUserOp -> [(RWUserOp, Text)] -> Maybe Text
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup RWUserOp
b [(RWUserOp, Text)]
rwUserQName

qn2rwu :: Text -> Maybe RWUserOp
qn2rwu :: Text -> Maybe RWUserOp
qn2rwu = \ case
      Text
x | Just Builtin
b <- Text -> [(Text, Builtin)] -> Maybe Builtin
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Text
x (((Builtin, Text) -> (Text, Builtin))
-> [(Builtin, Text)] -> [(Text, Builtin)]
forall a b. (a -> b) -> [a] -> [b]
map (Builtin, Text) -> (Text, Builtin)
forall a b. (a, b) -> (b, a)
swap [(Builtin, Text)]
builtinUserQName) -> RWUserOp -> Maybe RWUserOp
forall a. a -> Maybe a
Just (Builtin -> RWUserOp
RWBuiltin Builtin
b)
      Text
x -> Text -> [(Text, RWUserOp)] -> Maybe RWUserOp
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Text
x (((RWUserOp, Text) -> (Text, RWUserOp))
-> [(RWUserOp, Text)] -> [(Text, RWUserOp)]
forall a b. (a -> b) -> [a] -> [b]
map (RWUserOp, Text) -> (Text, RWUserOp)
forall a b. (a, b) -> (b, a)
swap [(RWUserOp, Text)]
rwUserQName)


-- | Type builtins
--   type (+), type GHC.Monad, type GHC.MonadTrans, KnownNat
--   Identity, ReacT, StateT, Vec, Finite, Ref (..), Proxy (..)
--   Maybe, Either, Bool
--   Products?
--
--   Primitives
--   Defined Types/Data structs: Monad, MonadTrans, Ref a=Ref String, Proxy (n::Nat)=Proxy
--   Imported Types/Data structs: type(+),type(Nat),Identity, ReacT, StateT, Integer, String, Bool, Vec=Vector, KnownNat, Finite
      
data TyBuiltin =
          TyInteger
        | TyString
        | TyBool
        | TyUnit
        | TyFun
        | TyReacT
        | TyStateT
        | TyIdentity
        | TyState
        | TyRe
        | TyDev
        | TyStateDev
        | TyS
        | TyProd
        | TyList
        | TyVec
        | TyProxy
        | TyFin
        | TyPlus
        | TyNeg
        | TyRef
      deriving (TyBuiltin -> TyBuiltin -> Bool
(TyBuiltin -> TyBuiltin -> Bool)
-> (TyBuiltin -> TyBuiltin -> Bool) -> Eq TyBuiltin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TyBuiltin -> TyBuiltin -> Bool
== :: TyBuiltin -> TyBuiltin -> Bool
$c/= :: TyBuiltin -> TyBuiltin -> Bool
/= :: TyBuiltin -> TyBuiltin -> Bool
Eq, Eq TyBuiltin
Eq TyBuiltin =>
(TyBuiltin -> TyBuiltin -> Ordering)
-> (TyBuiltin -> TyBuiltin -> Bool)
-> (TyBuiltin -> TyBuiltin -> Bool)
-> (TyBuiltin -> TyBuiltin -> Bool)
-> (TyBuiltin -> TyBuiltin -> Bool)
-> (TyBuiltin -> TyBuiltin -> TyBuiltin)
-> (TyBuiltin -> TyBuiltin -> TyBuiltin)
-> Ord TyBuiltin
TyBuiltin -> TyBuiltin -> Bool
TyBuiltin -> TyBuiltin -> Ordering
TyBuiltin -> TyBuiltin -> TyBuiltin
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 :: TyBuiltin -> TyBuiltin -> Ordering
compare :: TyBuiltin -> TyBuiltin -> Ordering
$c< :: TyBuiltin -> TyBuiltin -> Bool
< :: TyBuiltin -> TyBuiltin -> Bool
$c<= :: TyBuiltin -> TyBuiltin -> Bool
<= :: TyBuiltin -> TyBuiltin -> Bool
$c> :: TyBuiltin -> TyBuiltin -> Bool
> :: TyBuiltin -> TyBuiltin -> Bool
$c>= :: TyBuiltin -> TyBuiltin -> Bool
>= :: TyBuiltin -> TyBuiltin -> Bool
$cmax :: TyBuiltin -> TyBuiltin -> TyBuiltin
max :: TyBuiltin -> TyBuiltin -> TyBuiltin
$cmin :: TyBuiltin -> TyBuiltin -> TyBuiltin
min :: TyBuiltin -> TyBuiltin -> TyBuiltin
Ord, (forall x. TyBuiltin -> Rep TyBuiltin x)
-> (forall x. Rep TyBuiltin x -> TyBuiltin) -> Generic TyBuiltin
forall x. Rep TyBuiltin x -> TyBuiltin
forall x. TyBuiltin -> Rep TyBuiltin x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TyBuiltin -> Rep TyBuiltin x
from :: forall x. TyBuiltin -> Rep TyBuiltin x
$cto :: forall x. Rep TyBuiltin x -> TyBuiltin
to :: forall x. Rep TyBuiltin x -> TyBuiltin
Generic, Typeable, Typeable TyBuiltin
Typeable TyBuiltin =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TyBuiltin -> c TyBuiltin)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TyBuiltin)
-> (TyBuiltin -> Constr)
-> (TyBuiltin -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TyBuiltin))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyBuiltin))
-> ((forall b. Data b => b -> b) -> TyBuiltin -> TyBuiltin)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyBuiltin -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyBuiltin -> r)
-> (forall u. (forall d. Data d => d -> u) -> TyBuiltin -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TyBuiltin -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TyBuiltin -> m TyBuiltin)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyBuiltin -> m TyBuiltin)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyBuiltin -> m TyBuiltin)
-> Data TyBuiltin
TyBuiltin -> Constr
TyBuiltin -> DataType
(forall b. Data b => b -> b) -> TyBuiltin -> TyBuiltin
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) -> TyBuiltin -> u
forall u. (forall d. Data d => d -> u) -> TyBuiltin -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyBuiltin -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyBuiltin -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyBuiltin -> m TyBuiltin
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyBuiltin -> m TyBuiltin
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyBuiltin
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyBuiltin -> c TyBuiltin
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyBuiltin)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyBuiltin)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyBuiltin -> c TyBuiltin
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyBuiltin -> c TyBuiltin
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyBuiltin
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyBuiltin
$ctoConstr :: TyBuiltin -> Constr
toConstr :: TyBuiltin -> Constr
$cdataTypeOf :: TyBuiltin -> DataType
dataTypeOf :: TyBuiltin -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyBuiltin)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyBuiltin)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyBuiltin)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyBuiltin)
$cgmapT :: (forall b. Data b => b -> b) -> TyBuiltin -> TyBuiltin
gmapT :: (forall b. Data b => b -> b) -> TyBuiltin -> TyBuiltin
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyBuiltin -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyBuiltin -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyBuiltin -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyBuiltin -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TyBuiltin -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TyBuiltin -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyBuiltin -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyBuiltin -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyBuiltin -> m TyBuiltin
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyBuiltin -> m TyBuiltin
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyBuiltin -> m TyBuiltin
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyBuiltin -> m TyBuiltin
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyBuiltin -> m TyBuiltin
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyBuiltin -> m TyBuiltin
Data, TyBuiltin
TyBuiltin -> TyBuiltin -> Bounded TyBuiltin
forall a. a -> a -> Bounded a
$cminBound :: TyBuiltin
minBound :: TyBuiltin
$cmaxBound :: TyBuiltin
maxBound :: TyBuiltin
Bounded, Int -> TyBuiltin
TyBuiltin -> Int
TyBuiltin -> [TyBuiltin]
TyBuiltin -> TyBuiltin
TyBuiltin -> TyBuiltin -> [TyBuiltin]
TyBuiltin -> TyBuiltin -> TyBuiltin -> [TyBuiltin]
(TyBuiltin -> TyBuiltin)
-> (TyBuiltin -> TyBuiltin)
-> (Int -> TyBuiltin)
-> (TyBuiltin -> Int)
-> (TyBuiltin -> [TyBuiltin])
-> (TyBuiltin -> TyBuiltin -> [TyBuiltin])
-> (TyBuiltin -> TyBuiltin -> [TyBuiltin])
-> (TyBuiltin -> TyBuiltin -> TyBuiltin -> [TyBuiltin])
-> Enum TyBuiltin
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: TyBuiltin -> TyBuiltin
succ :: TyBuiltin -> TyBuiltin
$cpred :: TyBuiltin -> TyBuiltin
pred :: TyBuiltin -> TyBuiltin
$ctoEnum :: Int -> TyBuiltin
toEnum :: Int -> TyBuiltin
$cfromEnum :: TyBuiltin -> Int
fromEnum :: TyBuiltin -> Int
$cenumFrom :: TyBuiltin -> [TyBuiltin]
enumFrom :: TyBuiltin -> [TyBuiltin]
$cenumFromThen :: TyBuiltin -> TyBuiltin -> [TyBuiltin]
enumFromThen :: TyBuiltin -> TyBuiltin -> [TyBuiltin]
$cenumFromTo :: TyBuiltin -> TyBuiltin -> [TyBuiltin]
enumFromTo :: TyBuiltin -> TyBuiltin -> [TyBuiltin]
$cenumFromThenTo :: TyBuiltin -> TyBuiltin -> TyBuiltin -> [TyBuiltin]
enumFromThenTo :: TyBuiltin -> TyBuiltin -> TyBuiltin -> [TyBuiltin]
Enum, Int -> TyBuiltin -> ShowS
[TyBuiltin] -> ShowS
TyBuiltin -> String
(Int -> TyBuiltin -> ShowS)
-> (TyBuiltin -> String)
-> ([TyBuiltin] -> ShowS)
-> Show TyBuiltin
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TyBuiltin -> ShowS
showsPrec :: Int -> TyBuiltin -> ShowS
$cshow :: TyBuiltin -> String
show :: TyBuiltin -> String
$cshowList :: [TyBuiltin] -> ShowS
showList :: [TyBuiltin] -> ShowS
Show)
      deriving Int -> TyBuiltin -> Text
Int -> TyBuiltin -> Text
Int -> TyBuiltin -> Builder
[TyBuiltin] -> Text
[TyBuiltin] -> Text
[TyBuiltin] -> Builder
TyBuiltin -> Text
TyBuiltin -> Text
TyBuiltin -> Builder
(Int -> TyBuiltin -> Builder)
-> (TyBuiltin -> Builder)
-> ([TyBuiltin] -> Builder)
-> (Int -> TyBuiltin -> Text)
-> (TyBuiltin -> Text)
-> ([TyBuiltin] -> Text)
-> (Int -> TyBuiltin -> Text)
-> (TyBuiltin -> Text)
-> ([TyBuiltin] -> Text)
-> TextShow TyBuiltin
forall a.
(Int -> a -> Builder)
-> (a -> Builder)
-> ([a] -> Builder)
-> (Int -> a -> Text)
-> (a -> Text)
-> ([a] -> Text)
-> (Int -> a -> Text)
-> (a -> Text)
-> ([a] -> Text)
-> TextShow a
$cshowbPrec :: Int -> TyBuiltin -> Builder
showbPrec :: Int -> TyBuiltin -> Builder
$cshowb :: TyBuiltin -> Builder
showb :: TyBuiltin -> Builder
$cshowbList :: [TyBuiltin] -> Builder
showbList :: [TyBuiltin] -> Builder
$cshowtPrec :: Int -> TyBuiltin -> Text
showtPrec :: Int -> TyBuiltin -> Text
$cshowt :: TyBuiltin -> Text
showt :: TyBuiltin -> Text
$cshowtList :: [TyBuiltin] -> Text
showtList :: [TyBuiltin] -> Text
$cshowtlPrec :: Int -> TyBuiltin -> Text
showtlPrec :: Int -> TyBuiltin -> Text
$cshowtl :: TyBuiltin -> Text
showtl :: TyBuiltin -> Text
$cshowtlList :: [TyBuiltin] -> Text
showtlList :: [TyBuiltin] -> Text
TextShow via FromGeneric TyBuiltin

tb2s :: TyBuiltin -> Text
tb2s :: TyBuiltin -> Text
tb2s = \ case
      TyBuiltin
TyInteger -> Text
"Integer"
      TyBuiltin
TyString -> Text
"String"
      TyBuiltin
TyBool -> Text
"Bool"
      TyBuiltin
TyUnit -> Text
"()"
      TyBuiltin
TyFun -> Text
"->"
      TyBuiltin
TyReacT -> Text
"ReacT"
      TyBuiltin
TyStateT -> Text
"StateT"
      TyBuiltin
TyIdentity -> Text
"Identity"
      TyBuiltin
TyState -> Text
"State"
      TyBuiltin
TyS -> Text
"S"
      TyBuiltin
TyRe -> Text
"Re"
      TyBuiltin
TyDev -> Text
"Dev"
      TyBuiltin
TyStateDev -> Text
"StateDev"
      TyBuiltin
TyList -> Text
"[_]"
      TyBuiltin
TyVec -> Text
"Vec"
      TyBuiltin
TyProxy -> Text
"Proxy"
      TyBuiltin
TyFin -> Text
"Finite"
      TyBuiltin
TyProd -> Text
"(,)"
      TyBuiltin
TyPlus -> Text
"+"
      TyBuiltin
TyNeg -> Text
"-"
      TyBuiltin
TyRef -> Text
"Ref"

s2tb :: Text -> Maybe TyBuiltin
s2tb :: Text -> Maybe TyBuiltin
s2tb = \ case
      Text
"Integer"   -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyInteger
      Text
"String"    -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyString
      Text
"Bool"      -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyBool
      Text
"()"        -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyUnit
      Text
"->"        -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyFun
      Text
"ReacT"     -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyReacT
      Text
"StateT"    -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyStateT
      Text
"Identity"  -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyIdentity
      Text
"State"     -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyState
      Text
"Re"        -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyRe
      Text
"Dev"       -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyDev
      Text
"StateDev"  -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyStateDev
      Text
"S"         -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyS
      Text
"(,)"       -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyProd
      Text
"[_]"       -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyList
      Text
"Vec"       -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyVec
      Text
"Proxy"     -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyProxy
      Text
"Finite"    -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyFin
      Text
"+"         -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyPlus
      Text
"-"         -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyNeg
      Text
"Ref"       -> TyBuiltin -> Maybe TyBuiltin
forall a. a -> Maybe a
Just TyBuiltin
TyRef
      Text
_           -> Maybe TyBuiltin
forall a. Maybe a
Nothing

tybuiltins :: [(Text, TyBuiltin)]
tybuiltins :: [(Text, TyBuiltin)]
tybuiltins = (TyBuiltin -> (Text, TyBuiltin))
-> [TyBuiltin] -> [(Text, TyBuiltin)]
forall a b. (a -> b) -> [a] -> [b]
map (TyBuiltin -> Text
tb2s (TyBuiltin -> Text)
-> (TyBuiltin -> TyBuiltin) -> TyBuiltin -> (Text, TyBuiltin)
forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& TyBuiltin -> TyBuiltin
forall a. a -> a
id) [TyBuiltin
forall a. Bounded a => a
minBound .. TyBuiltin
forall a. Bounded a => a
maxBound]

instance Pretty TyBuiltin where
      pretty :: forall ann. TyBuiltin -> Doc ann
pretty = Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty (Text -> Doc ann) -> (TyBuiltin -> Text) -> TyBuiltin -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TyBuiltin -> Text
tb2s

instance NFData TyBuiltin
instance Hashable TyBuiltin