{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE FlexibleInstances         #-}
{-# LANGUAGE FlexibleContexts          #-}
{-# LANGUAGE UndecidableInstances      #-}
{-# LANGUAGE TupleSections             #-}
{-# LANGUAGE OverloadedStrings         #-}
{-# LANGUAGE DeriveDataTypeable        #-}
{-# LANGUAGE ScopedTypeVariables       #-}
{-# OPTIONS_GHC -Wno-orphans           #-}

module Language.Haskell.Liquid.Parse
  ( hsSpecificationP
  , parseSpecComments
  , singleSpecP
  , BPspec (..)
  , parseTest'
  )
  where

import           Control.Arrow                          (second)
import           Control.Monad
import           Control.Monad.Identity
import           Data.Bifunctor                         (first)
import qualified Data.Char                              as Char
import qualified Data.Foldable                          as F
import           Data.String
import           Data.Void
import           Prelude                                hiding (error)
import           Text.Megaparsec                        hiding (ParseError)
import           Text.Megaparsec.Char
import qualified Data.HashMap.Strict                    as M
import qualified Data.HashSet                           as S
import           Data.Data
import qualified Data.Maybe                             as Mb -- (isNothing, fromMaybe)
import           Data.Char                              (isSpace, isAlphaNum)
import           Data.List                              (partition)
import qualified Text.PrettyPrint.HughesPJ              as PJ
import           Text.PrettyPrint.HughesPJ.Compat       ((<+>))
import           Language.Fixpoint.Types                hiding (panic, SVar, DDecl, DataDecl, DataCtor (..), Error, R, Predicate)
import           Language.Haskell.Liquid.GHC.Misc       hiding (getSourcePos)
import           Language.Haskell.Liquid.Types.Bounds
import           Language.Haskell.Liquid.Types.DataDecl
import           Language.Haskell.Liquid.Types.Errors
import           Language.Haskell.Liquid.Types.Names
import           Language.Haskell.Liquid.Types.PredType
import           Language.Haskell.Liquid.Types.RType
import           Language.Haskell.Liquid.Types.RefType
import           Language.Haskell.Liquid.Types.RTypeOp
import           Language.Haskell.Liquid.Types.Specs
import           Language.Haskell.Liquid.Types.Types
import           Language.Haskell.Liquid.Types.Variance
import qualified Language.Haskell.Liquid.Misc           as Misc
import qualified Language.Haskell.Liquid.Measure        as Measure
import           Language.Fixpoint.Parse                hiding (Parser, dataDeclP, refBindP, refP, refDefP, parseTest')
import qualified Liquid.GHC.API                         as GHC

import Control.Monad.State

-- * Top-level parsing API

hsSpecificationP :: GHC.ModuleName -> [BPspec] -> (ModName, BareSpecParsed)
hsSpecificationP :: ModuleName -> [BPspec] -> (ModName, BareSpecParsed)
hsSpecificationP ModuleName
modName [BPspec]
specs = (ModType -> ModuleName -> ModName
ModName ModType
SrcImport ModuleName
modName, [BPspec] -> BareSpecParsed
mkSpec [BPspec]
specs)

-- | Parse comments in .hs and .lhs files
parseSpecComments :: [(SourcePos, String)] -> Either [Error] [BPspec]
parseSpecComments :: [(SourcePos, [Char])] -> Either [Error] [BPspec]
parseSpecComments [(SourcePos, [Char])]
specComments =
  case ([Error], [BPspec])
-> PStateV LocSymbol
-> [(SourcePos, [Char])]
-> ([Error], [BPspec])
go ([], []) PStateV LocSymbol
initPStateWithList [(SourcePos, [Char])]
specComments of
    ([], [BPspec]
specs) ->
      [BPspec] -> Either [Error] [BPspec]
forall a b. b -> Either a b
Right [BPspec]
specs
    ([Error]
errors, [BPspec]
_) ->
      [Error] -> Either [Error] [BPspec]
forall a b. a -> Either a b
Left [Error]
errors
  where
    go :: ([Error], [BPspec])   -- accumulated errors and parsed specs (in reverse order)
       -> LHPState              -- parser state (primarily infix operator priorities)
       -> [(SourcePos, String)] -- remaining unparsed spec comments
       -> ([Error], [BPspec])   -- final errors and parsed specs
    go :: ([Error], [BPspec])
-> PStateV LocSymbol
-> [(SourcePos, [Char])]
-> ([Error], [BPspec])
go ([Error]
errors, [BPspec]
specs) PStateV LocSymbol
_ []
      = ([Error] -> [Error]
forall a. [a] -> [a]
reverse [Error]
errors, [BPspec] -> [BPspec]
forall a. [a] -> [a]
reverse [BPspec]
specs)
    go ([Error]
errors, [BPspec]
specs) PStateV LocSymbol
pstate ((SourcePos
pos, [Char]
specComment):[(SourcePos, [Char])]
xs)
      = -- 'specP' parses a single spec comment, i.e., a single LH directive
        -- we allow a "block" of specs now
        case PStateV LocSymbol
-> Parser [BPspec]
-> SourcePos
-> [Char]
-> Either
     (ParseErrorBundle [Char] Void) (PStateV LocSymbol, [BPspec])
forall a.
PStateV LocSymbol
-> Parser a
-> SourcePos
-> [Char]
-> Either (ParseErrorBundle [Char] Void) (PStateV LocSymbol, a)
parseWithError PStateV LocSymbol
pstate (ParserV LocSymbol BPspec -> Parser [BPspec]
forall v a. ParserV v a -> ParserV v [a]
block ParserV LocSymbol BPspec
specP) SourcePos
pos [Char]
specComment of
          Left ParseErrorBundle [Char] Void
err'       -> ([Error], [BPspec])
-> PStateV LocSymbol
-> [(SourcePos, [Char])]
-> ([Error], [BPspec])
go (ParseErrorBundle [Char] Void -> [Error]
parseErrorBundleToErrors ParseErrorBundle [Char] Void
err' [Error] -> [Error] -> [Error]
forall a. [a] -> [a] -> [a]
++ [Error]
errors, [BPspec]
specs) PStateV LocSymbol
pstate [(SourcePos, [Char])]
xs
          Right (PStateV LocSymbol
st,[BPspec]
spec) -> ([Error], [BPspec])
-> PStateV LocSymbol
-> [(SourcePos, [Char])]
-> ([Error], [BPspec])
go ([Error]
errors,[BPspec]
spec [BPspec] -> [BPspec] -> [BPspec]
forall a. [a] -> [a] -> [a]
++ [BPspec]
specs) PStateV LocSymbol
st [(SourcePos, [Char])]
xs

type LHPState = PStateV LocSymbol
type Parser = ParserV LocSymbol

instance ParseableV LocSymbol where
  parseV :: ParserV LocSymbol LocSymbol
parseV = ParserV LocSymbol LocSymbol
forall v. ParserV v LocSymbol
locSymbolP
  mkSu :: [(Symbol, ExprV LocSymbol)] -> SubstV LocSymbol
mkSu = HashMap Symbol (ExprV LocSymbol) -> SubstV LocSymbol
forall v. HashMap Symbol (ExprV v) -> SubstV v
Su (HashMap Symbol (ExprV LocSymbol) -> SubstV LocSymbol)
-> ([(Symbol, ExprV LocSymbol)]
    -> HashMap Symbol (ExprV LocSymbol))
-> [(Symbol, ExprV LocSymbol)]
-> SubstV LocSymbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Symbol, ExprV LocSymbol)] -> HashMap Symbol (ExprV LocSymbol)
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList ([(Symbol, ExprV LocSymbol)] -> HashMap Symbol (ExprV LocSymbol))
-> ([(Symbol, ExprV LocSymbol)] -> [(Symbol, ExprV LocSymbol)])
-> [(Symbol, ExprV LocSymbol)]
-> HashMap Symbol (ExprV LocSymbol)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Symbol, ExprV LocSymbol)] -> [(Symbol, ExprV LocSymbol)]
forall a. [a] -> [a]
reverse ([(Symbol, ExprV LocSymbol)] -> [(Symbol, ExprV LocSymbol)])
-> ([(Symbol, ExprV LocSymbol)] -> [(Symbol, ExprV LocSymbol)])
-> [(Symbol, ExprV LocSymbol)]
-> [(Symbol, ExprV LocSymbol)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Symbol, ExprV LocSymbol) -> Bool)
-> [(Symbol, ExprV LocSymbol)] -> [(Symbol, ExprV LocSymbol)]
forall a. (a -> Bool) -> [a] -> [a]
filter (Symbol, ExprV LocSymbol) -> Bool
forall {a}. Eq a => (a, ExprV (Located a)) -> Bool
notTrivial
    where
      notTrivial :: (a, ExprV (Located a)) -> Bool
notTrivial (a
x, EVar Located a
y) = a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
/= Located a -> a
forall a. Located a -> a
val Located a
y
      notTrivial (a, ExprV (Located a))
_           = Bool
True
  vFromString :: Located [Char] -> LocSymbol
vFromString = ([Char] -> Symbol) -> Located [Char] -> LocSymbol
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Char] -> Symbol
forall a. Symbolic a => a -> Symbol
symbol

initPStateWithList :: LHPState
initPStateWithList :: PStateV LocSymbol
initPStateWithList
  = (Maybe (Located [Char] -> ExprV LocSymbol) -> PStateV LocSymbol
forall v.
ParseableV v =>
Maybe (Located [Char] -> ExprV v) -> PStateV v
initPState Maybe (Located [Char] -> ExprV LocSymbol)
forall {a}. Maybe a
composeFun)
               { empList    = Just $ \Located ()
lx -> LocSymbol -> ExprV LocSymbol
forall v. v -> ExprV v
EVar (Symbol
"GHC.Types.[]" Symbol -> Located () -> LocSymbol
forall a b. a -> Located b -> Located a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Located ()
lx)
               , singList   = Just (\Located ()
lx ExprV LocSymbol
e -> ExprV LocSymbol -> ExprV LocSymbol -> ExprV LocSymbol
forall v. ExprV v -> ExprV v -> ExprV v
EApp (ExprV LocSymbol -> ExprV LocSymbol -> ExprV LocSymbol
forall v. ExprV v -> ExprV v -> ExprV v
EApp (LocSymbol -> ExprV LocSymbol
forall v. v -> ExprV v
EVar (Symbol
"GHC.Types.:" Symbol -> Located () -> LocSymbol
forall a b. a -> Located b -> Located a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Located ()
lx)) ExprV LocSymbol
e) (LocSymbol -> ExprV LocSymbol
forall v. v -> ExprV v
EVar (Symbol
"GHC.Types.[]" Symbol -> Located () -> LocSymbol
forall a b. a -> Located b -> Located a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Located ()
lx)))
               }
  where composeFun :: Maybe a
composeFun = Maybe a
forall {a}. Maybe a
Nothing

-------------------------------------------------------------------------------
singleSpecP :: SourcePos -> String -> Either (ParseErrorBundle String Void) BPspec
-------------------------------------------------------------------------------
singleSpecP :: SourcePos -> [Char] -> Either (ParseErrorBundle [Char] Void) BPspec
singleSpecP SourcePos
pos = ((PStateV LocSymbol, BPspec) -> BPspec)
-> Either
     (ParseErrorBundle [Char] Void) (PStateV LocSymbol, BPspec)
-> Either (ParseErrorBundle [Char] Void) BPspec
forall a b l. (a -> b) -> Either l a -> Either l b
mapRight (PStateV LocSymbol, BPspec) -> BPspec
forall a b. (a, b) -> b
snd (Either (ParseErrorBundle [Char] Void) (PStateV LocSymbol, BPspec)
 -> Either (ParseErrorBundle [Char] Void) BPspec)
-> ([Char]
    -> Either
         (ParseErrorBundle [Char] Void) (PStateV LocSymbol, BPspec))
-> [Char]
-> Either (ParseErrorBundle [Char] Void) BPspec
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PStateV LocSymbol
-> ParserV LocSymbol BPspec
-> SourcePos
-> [Char]
-> Either
     (ParseErrorBundle [Char] Void) (PStateV LocSymbol, BPspec)
forall a.
PStateV LocSymbol
-> Parser a
-> SourcePos
-> [Char]
-> Either (ParseErrorBundle [Char] Void) (PStateV LocSymbol, a)
parseWithError PStateV LocSymbol
initPStateWithList ParserV LocSymbol BPspec
specP SourcePos
pos

mapRight :: (a -> b) -> Either l a -> Either l b
mapRight :: forall a b l. (a -> b) -> Either l a -> Either l b
mapRight a -> b
f (Right a
x) = b -> Either l b
forall a b. b -> Either a b
Right (b -> Either l b) -> b -> Either l b
forall a b. (a -> b) -> a -> b
$ a -> b
f a
x
mapRight a -> b
_ (Left l
x)  = l -> Either l b
forall a b. a -> Either a b
Left l
x

-- Note [PState in parser]
--
-- In the original parsec parser, 'PState' did not contain the supply counter.
-- The supply counter was separately initialised to 0 on every parser call, e.g.
-- in 'parseWithError'.
--
-- Now, the supply counter is a part of 'PState' and would normally be threaded
-- between subsequent parsing calls within s single file, as for example issued
-- by 'hsSpecificationP'. This threading seems correct to me (Andres). It sounds
-- like we would want to have the same behaviour of the counter whether we are
-- parsing several separate specs or a single combined spec.
--
-- However, I am getting one test failure due to the threading change, namely
-- Tests.Micro.class-laws-pos.FreeVar.hs, because in a unification call two
-- variables occurring in a binding position do not match. This seems like a bug
-- in the unifier. I'm nevertheless reproucing the "old" supply behaviour for
-- now. This should be revisited later. TODO.

-- | Entry point for parsers.
--
-- Resets the supply in the given state to 0, see Note [PState in parser].
-- Also resets the layout stack, as different spec comments in a file can
-- start at different columns, and we do not want layout info to carry
-- across different such comments.
--
parseWithError :: forall a. LHPState -> Parser a -> SourcePos -> String -> Either (ParseErrorBundle String Void) (LHPState, a)
parseWithError :: forall a.
PStateV LocSymbol
-> Parser a
-> SourcePos
-> [Char]
-> Either (ParseErrorBundle [Char] Void) (PStateV LocSymbol, a)
parseWithError PStateV LocSymbol
pstate Parser a
parser SourcePos
p [Char]
s =
  case (State [Char] Void,
 Either (ParseErrorBundle [Char] Void) (a, PStateV LocSymbol))
-> Either (ParseErrorBundle [Char] Void) (a, PStateV LocSymbol)
forall a b. (a, b) -> b
snd (Identity
  (State [Char] Void,
   Either (ParseErrorBundle [Char] Void) (a, PStateV LocSymbol))
-> (State [Char] Void,
    Either (ParseErrorBundle [Char] Void) (a, PStateV LocSymbol))
forall a. Identity a -> a
runIdentity (ParsecT Void [Char] Identity (a, PStateV LocSymbol)
-> State [Char] Void
-> Identity
     (State [Char] Void,
      Either (ParseErrorBundle [Char] Void) (a, PStateV LocSymbol))
forall (m :: * -> *) e s a.
Monad m =>
ParsecT e s m a
-> State s e -> m (State s e, Either (ParseErrorBundle s e) a)
runParserT' (Parser a
-> PStateV LocSymbol
-> ParsecT Void [Char] Identity (a, PStateV LocSymbol)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT Parser a
doParse PStateV LocSymbol
pstate{supply = 0, layoutStack = Empty}) State [Char] Void
forall {e}. State [Char] e
internalParserState)) of
    Left ParseErrorBundle [Char] Void
peb -> ParseErrorBundle [Char] Void
-> Either (ParseErrorBundle [Char] Void) (PStateV LocSymbol, a)
forall a b. a -> Either a b
Left ParseErrorBundle [Char] Void
peb
    Right (a
r, PStateV LocSymbol
st) -> (PStateV LocSymbol, a)
-> Either (ParseErrorBundle [Char] Void) (PStateV LocSymbol, a)
forall a b. b -> Either a b
Right (PStateV LocSymbol
st, a
r)
  where
    doParse :: Parser a
    doParse :: Parser a
doParse = ParserV LocSymbol ()
forall v. ParserV v ()
spaces ParserV LocSymbol () -> Parser a -> Parser a
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser a
parser Parser a -> ParserV LocSymbol () -> Parser a
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserV LocSymbol ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
eof
    internalParserState :: State [Char] e
internalParserState =
      State
        { stateInput :: [Char]
stateInput = [Char]
s
        , stateOffset :: Int
stateOffset = Int
0
        , statePosState :: PosState [Char]
statePosState =
          PosState
            { pstateInput :: [Char]
pstateInput = [Char]
s
            , pstateOffset :: Int
pstateOffset = Int
0
            , pstateSourcePos :: SourcePos
pstateSourcePos = SourcePos
p
            , pstateTabWidth :: Pos
pstateTabWidth = Pos
defaultTabWidth
            , pstateLinePrefix :: [Char]
pstateLinePrefix = [Char]
""
            }
        , stateParseErrors :: [ParseError [Char] e]
stateParseErrors = []
        }

-- | Function to test parsers interactively.
parseTest' :: Show a => Parser a -> String -> IO ()
parseTest' :: forall a. Show a => Parser a -> [Char] -> IO ()
parseTest' Parser a
parser [Char]
input =
  Parsec Void [Char] a -> [Char] -> IO ()
forall e a s.
(ShowErrorComponent e, Show a, VisualStream s,
 TraversableStream s) =>
Parsec e s a -> s -> IO ()
parseTest (Parser a -> PStateV LocSymbol -> Parsec Void [Char] a
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT Parser a
parser PStateV LocSymbol
initPStateWithList) [Char]
input

parseErrorBundleToErrors :: ParseErrorBundle String Void -> [Error]
parseErrorBundleToErrors :: ParseErrorBundle [Char] Void -> [Error]
parseErrorBundleToErrors (ParseErrorBundle NonEmpty (ParseError [Char] Void)
errors PosState [Char]
posState) =
  let
    (NonEmpty (ParseError [Char] Void, SourcePos)
es, PosState [Char]
_) = (ParseError [Char] Void -> Int)
-> NonEmpty (ParseError [Char] Void)
-> PosState [Char]
-> (NonEmpty (ParseError [Char] Void, SourcePos), PosState [Char])
forall (t :: * -> *) s a.
(Traversable t, TraversableStream s) =>
(a -> Int) -> t a -> PosState s -> (t (a, SourcePos), PosState s)
attachSourcePos ParseError [Char] Void -> Int
forall s e. ParseError s e -> Int
errorOffset NonEmpty (ParseError [Char] Void)
errors PosState [Char]
posState
  in
    (ParseError [Char] Void, SourcePos) -> Error
parseErrorError ((ParseError [Char] Void, SourcePos) -> Error)
-> [(ParseError [Char] Void, SourcePos)] -> [Error]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (ParseError [Char] Void, SourcePos)
-> [(ParseError [Char] Void, SourcePos)]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList NonEmpty (ParseError [Char] Void, SourcePos)
es

---------------------------------------------------------------------------
parseErrorError     :: (ParseError, SourcePos) -> Error
---------------------------------------------------------------------------
parseErrorError :: (ParseError [Char] Void, SourcePos) -> Error
parseErrorError (ParseError [Char] Void
e, SourcePos
pos) = SrcSpan -> Doc -> ParseError [Char] Void -> Error
forall t. SrcSpan -> Doc -> ParseError [Char] Void -> TError t
ErrParse SrcSpan
sp Doc
msg ParseError [Char] Void
e
  where
    sp :: SrcSpan
sp              = SourcePos -> SrcSpan
sourcePosSrcSpan SourcePos
pos
    msg :: Doc
msg             = Doc
"Error Parsing Specification from:" Doc -> Doc -> Doc
<+> [Char] -> Doc
PJ.text (SourcePos -> [Char]
sourceName SourcePos
pos)

--------------------------------------------------------------------------------
-- | BareTypes -----------------------------------------------------------------
--------------------------------------------------------------------------------

{- | [NOTE:BARETYPE-PARSE] Fundamentally, a type is of the form

      comp -> comp -> ... -> comp

So

  bt = comp
     | comp '->' bt

  comp = circle
       | '(' bt ')'

  circle = the ground component of a baretype, sans parens or "->" at the top level

Each 'comp' should have a variable to refer to it,
either a parser-assigned one or given explicitly. e.g.

  xs : [Int]

-}

data ParamComp = PC { ParamComp -> PcScope
_pci :: PcScope
                    , ParamComp -> BareTypeParsed
_pct :: BareTypeParsed }

data PcScope = PcImplicit Symbol
             | PcExplicit Symbol
             | PcNoSymbol
             deriving (PcScope -> PcScope -> Bool
(PcScope -> PcScope -> Bool)
-> (PcScope -> PcScope -> Bool) -> Eq PcScope
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PcScope -> PcScope -> Bool
== :: PcScope -> PcScope -> Bool
$c/= :: PcScope -> PcScope -> Bool
/= :: PcScope -> PcScope -> Bool
Eq,Int -> PcScope -> ShowS
[PcScope] -> ShowS
PcScope -> [Char]
(Int -> PcScope -> ShowS)
-> (PcScope -> [Char]) -> ([PcScope] -> ShowS) -> Show PcScope
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PcScope -> ShowS
showsPrec :: Int -> PcScope -> ShowS
$cshow :: PcScope -> [Char]
show :: PcScope -> [Char]
$cshowList :: [PcScope] -> ShowS
showList :: [PcScope] -> ShowS
Show)

nullPC :: BareTypeParsed -> ParamComp
nullPC :: BareTypeParsed -> ParamComp
nullPC BareTypeParsed
bt = PcScope -> BareTypeParsed -> ParamComp
PC PcScope
PcNoSymbol BareTypeParsed
bt

btP :: Parser ParamComp
btP :: Parser ParamComp
btP = do
  c@(PC sb _) <- Parser ParamComp
compP
  case sb of
    PcScope
PcNoSymbol   -> ParamComp -> Parser ParamComp
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ParamComp
c
    PcImplicit Symbol
b -> ParamComp -> Symbol -> Parser ParamComp
parseFun ParamComp
c Symbol
b
    PcExplicit Symbol
b -> ParamComp -> Symbol -> Parser ParamComp
parseFun ParamComp
c Symbol
b
  Parser ParamComp -> [Char] -> Parser ParamComp
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"btP"
  where
    parseFun :: ParamComp -> Symbol -> Parser ParamComp
parseFun c :: ParamComp
c@(PC PcScope
sb BareTypeParsed
t1) Symbol
sy  =
      (do
            [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"->"
            PC _ t2 <- Parser ParamComp
btP
            return (PC sb (mkRFun sy t1 t2)))
        Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
         (do
            [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"=>"
            PC _ t2 <- Parser ParamComp
btP
            -- TODO:AZ return an error if s == PcExplicit
            return $ PC sb $ foldr (mkRFun dummySymbol) t2 (getClasses t1))
         Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          (do
             b <- ParserV LocSymbol LocSymbol
forall v. ParserV v LocSymbol
locInfixSymbolP
             PC _ t2 <- btP
             return $ PC sb $ RApp
               (mkBTyCon $ fmap (makeUnresolvedLHName LHTcName) b)
               [t1,t2]
               []
               trueURef
          )
         Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParamComp -> Parser ParamComp
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ParamComp
c

    mkRFun :: Symbol
-> RTypeV v c tv (UReftV v (ReftV v))
-> RTypeV v c tv (UReftV v (ReftV v))
-> RTypeV v c tv (UReftV v (ReftV v))
mkRFun Symbol
b RTypeV v c tv (UReftV v (ReftV v))
t RTypeV v c tv (UReftV v (ReftV v))
t' = Symbol
-> RFInfo
-> RTypeV v c tv (UReftV v (ReftV v))
-> RTypeV v c tv (UReftV v (ReftV v))
-> UReftV v (ReftV v)
-> RTypeV v c tv (UReftV v (ReftV v))
forall v c tv r.
Symbol
-> RFInfo
-> RTypeV v c tv r
-> RTypeV v c tv r
-> r
-> RTypeV v c tv r
RFun Symbol
b RFInfo
defRFInfo RTypeV v c tv (UReftV v (ReftV v))
t RTypeV v c tv (UReftV v (ReftV v))
t' UReftV v (ReftV v)
forall v. UReftV v (ReftV v)
trueURef

compP :: Parser ParamComp
compP :: Parser ParamComp
compP = Parser ParamComp
circleP Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParamComp -> Parser ParamComp
forall v a. ParserV v a -> ParserV v a
parens Parser ParamComp
btP Parser ParamComp -> [Char] -> Parser ParamComp
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"compP"

circleP :: Parser ParamComp
circleP :: Parser ParamComp
circleP
  =  BareTypeParsed -> ParamComp
nullPC (BareTypeParsed -> ParamComp)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> Parser ParamComp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"forall" ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareAllP)
 Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParamComp
holePC                                 -- starts with '_'
 Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParamComp
namedCircleP                           -- starts with lower
 Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParamComp
bareTypeBracesP                        -- starts with '{'
 Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParamComp
unnamedCircleP
 Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParamComp
anglesCircleP                          -- starts with '<'
 Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> BareTypeParsed -> ParamComp
nullPC (BareTypeParsed -> ParamComp)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> Parser ParamComp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall (m :: * -> *) b. Monad m => m (ReftV LocSymbol -> b) -> m b
dummyP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
bbaseP               -- starts with '_' or '[' or '(' or lower or "'" or upper
 Parser ParamComp -> [Char] -> Parser ParamComp
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"circleP"

anglesCircleP :: Parser ParamComp
anglesCircleP :: Parser ParamComp
anglesCircleP
  = Parser ParamComp -> Parser ParamComp
forall v a. ParserV v a -> ParserV v a
angles (Parser ParamComp -> Parser ParamComp)
-> Parser ParamComp -> Parser ParamComp
forall a b. (a -> b) -> a -> b
$ do
      PC sb t <- Parser ParamComp -> Parser ParamComp
forall v a. ParserV v a -> ParserV v a
parens Parser ParamComp
btP
      p       <- monoPredicateP
      return   $ PC sb (t `strengthenUReft` MkUReft trueReft p)

holePC :: Parser ParamComp
holePC :: Parser ParamComp
holePC = do
  h <- StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
holeP
  b <- dummyBindP
  return (PC (PcImplicit b) h)

namedCircleP :: Parser ParamComp
namedCircleP :: Parser ParamComp
namedCircleP = do
  lb <- ParserV LocSymbol LocSymbol
forall v. ParserV v LocSymbol
locLowerIdP
  do _ <- reservedOp ":"
     let b = LocSymbol -> Symbol
forall a. Located a -> a
val LocSymbol
lb
     PC (PcExplicit b) <$> bareArgP b
    <|> do
      b <- dummyBindP
      PC (PcImplicit b) <$> dummyP (lowerIdTail lb)

unnamedCircleP :: Parser ParamComp
unnamedCircleP :: Parser ParamComp
unnamedCircleP = do
  lb <- Parser Symbol -> ParserV LocSymbol LocSymbol
forall v a. ParserV v a -> ParserV v (Located a)
located Parser Symbol
dummyBindP
  let b = LocSymbol -> Symbol
forall a. Located a -> a
val LocSymbol
lb
  t1 <- bareArgP b
  return $ PC (PcImplicit b) t1

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

-- | The top-level parser for "bare" refinement types. If refinements are
-- not supplied, then the default "top" refinement is used.

bareTypeP :: Parser BareTypeParsed
bareTypeP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP = do
  PC _ v <- Parser ParamComp
btP
  return v

bareTypeBracesP :: Parser ParamComp
bareTypeBracesP :: Parser ParamComp
bareTypeBracesP = do
  t <-  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Either ParamComp BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Either ParamComp BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
forall v a. ParserV v a -> ParserV v a
braces (
            StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Either ParamComp BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (BareTypeParsed -> Either ParamComp BareTypeParsed
forall a b. b -> Either a b
Right (BareTypeParsed -> Either ParamComp BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
constraintP)
           StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Either ParamComp BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
            (do
                    x  <- Parser Symbol
forall v. ParserV v Symbol
symbolP
                    _ <- reservedOp ":"
                    -- NOSUBST i  <- freshIntP
                    t  <- bbaseP
                    reservedOp "|"
                    ra <- refasHoleP
                    -- xi is a unique var based on the name in x.
                    -- su replaces any use of x in the balance of the expression with the unique val
                    -- NOSUBST let xi = intSymbol x i
                    -- NOSUBST let su v = if v == x then xi else v
                    return $ Left $ PC (PcExplicit x) $ t (Reft (x, ra)) )
            )) StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Either ParamComp BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Either ParamComp BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
forall {v} {b}.
StateT (PStateV v) (Parsec Void [Char]) (ExprV LocSymbol)
-> ParserV v (Either ParamComp b)
helper Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
holeOrPredsP) StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Either ParamComp BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Either ParamComp BareTypeParsed)
forall {v} {b}.
StateT (PStateV v) (Parsec Void [Char]) (ExprV LocSymbol)
-> ParserV v (Either ParamComp b)
helper Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
predP
  case t of
    Left ParamComp
l -> ParamComp -> Parser ParamComp
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ParamComp
l
    Right BareTypeParsed
ct -> do
      PC _sb tt <- Parser ParamComp
btP
      return $ nullPC $ rrTy ct tt
  where
    holeOrPredsP :: StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
holeOrPredsP
      = ([Char] -> ParserV v ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"_" ParserV v ()
-> StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
-> StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
forall a b.
StateT (PStateV v) (Parsec Void [Char]) a
-> StateT (PStateV v) (Parsec Void [Char]) b
-> StateT (PStateV v) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ExprV v -> StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
forall a. a -> StateT (PStateV v) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ExprV v
forall v. ExprV v
hole)
     StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
-> StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
-> StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
forall a.
StateT (PStateV v) (Parsec Void [Char]) a
-> StateT (PStateV v) (Parsec Void [Char]) a
-> StateT (PStateV v) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
-> StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
forall a.
StateT (PStateV v) (Parsec Void [Char]) a
-> StateT (PStateV v) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (ListNE (ExprV v) -> ExprV v
forall v. (Fixpoint v, Ord v) => ListNE (ExprV v) -> ExprV v
pAnd (ListNE (ExprV v) -> ExprV v)
-> StateT (PStateV v) (Parsec Void [Char]) (ListNE (ExprV v))
-> StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV v) (Parsec Void [Char]) (ListNE (ExprV v))
-> StateT (PStateV v) (Parsec Void [Char]) (ListNE (ExprV v))
forall v a. ParserV v a -> ParserV v a
brackets (StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
-> StateT (PStateV v) (Parsec Void [Char]) [Char]
-> StateT (PStateV v) (Parsec Void [Char]) (ListNE (ExprV v))
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
predP StateT (PStateV v) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
semi))
    helper :: StateT (PStateV v) (Parsec Void [Char]) (ExprV LocSymbol)
-> ParserV v (Either ParamComp b)
helper StateT (PStateV v) (Parsec Void [Char]) (ExprV LocSymbol)
p = ParserV v (Either ParamComp b) -> ParserV v (Either ParamComp b)
forall v a. ParserV v a -> ParserV v a
braces (ParserV v (Either ParamComp b) -> ParserV v (Either ParamComp b))
-> ParserV v (Either ParamComp b) -> ParserV v (Either ParamComp b)
forall a b. (a -> b) -> a -> b
$ do
      t <- RReftV LocSymbol -> BareTypeParsed
forall v c tv r. r -> RTypeV v c tv r
RHole (RReftV LocSymbol -> BareTypeParsed)
-> (ExprV LocSymbol -> RReftV LocSymbol)
-> ExprV LocSymbol
-> BareTypeParsed
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReftV LocSymbol -> RReftV LocSymbol
forall r v. r -> UReftV v r
uTop (ReftV LocSymbol -> RReftV LocSymbol)
-> (ExprV LocSymbol -> ReftV LocSymbol)
-> ExprV LocSymbol
-> RReftV LocSymbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Symbol, ExprV LocSymbol) -> ReftV LocSymbol
forall v. (Symbol, ExprV v) -> ReftV v
Reft ((Symbol, ExprV LocSymbol) -> ReftV LocSymbol)
-> (ExprV LocSymbol -> (Symbol, ExprV LocSymbol))
-> ExprV LocSymbol
-> ReftV LocSymbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Symbol
"VV",) (ExprV LocSymbol -> BareTypeParsed)
-> StateT (PStateV v) (Parsec Void [Char]) (ExprV LocSymbol)
-> StateT (PStateV v) (Parsec Void [Char]) BareTypeParsed
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV v) (Parsec Void [Char]) (ExprV LocSymbol)
p
      return (Left $ nullPC t)


bareArgP :: Symbol -> Parser BareTypeParsed
bareArgP :: Symbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareArgP Symbol
vvv
  =  Symbol
-> Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
refDefP Symbol
vvv Parser (ExprV LocSymbol)
refasHoleP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
bbaseP    -- starts with '{'
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
holeP                            -- starts with '_'
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall (m :: * -> *) b. Monad m => m (ReftV LocSymbol -> b) -> m b
dummyP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
bbaseP
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall v a. ParserV v a -> ParserV v a
parens StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP                 -- starts with '('
                                      -- starts with '_', '[', '(', lower, upper
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bareArgP"

bareAtomP
  :: (Parser (ExprV LocSymbol) -> Parser (ReftV LocSymbol -> BareTypeParsed) -> Parser BareTypeParsed)
  -> Parser BareTypeParsed
bareAtomP :: (Parser (ExprV LocSymbol)
 -> StateT
      (PStateV LocSymbol)
      (Parsec Void [Char])
      (ReftV LocSymbol -> BareTypeParsed)
 -> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareAtomP Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
ref
  =  Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
ref Parser (ExprV LocSymbol)
refasHoleP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
bbaseP
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
holeP
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall (m :: * -> *) b. Monad m => m (ReftV LocSymbol -> b) -> m b
dummyP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
bbaseP
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bareAtomP"

bareAtomBindP :: Parser BareTypeParsed
bareAtomBindP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareAtomBindP = (Parser (ExprV LocSymbol)
 -> StateT
      (PStateV LocSymbol)
      (Parsec Void [Char])
      (ReftV LocSymbol -> BareTypeParsed)
 -> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareAtomP Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
refBindBindP


-- Either
--  { x : t | ra }
-- or
--  { ra }
refBindBindP :: Parser (ExprV LocSymbol)
             -> Parser (ReftV LocSymbol -> BareTypeParsed)
             -> Parser BareTypeParsed
refBindBindP :: Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
refBindBindP Parser (ExprV LocSymbol)
rp StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
kindP'
  = StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall v a. ParserV v a -> ParserV v a
braces (
      (do
              x  <- Parser Symbol
forall v. ParserV v Symbol
symbolP
              _ <- reservedOp ":"
              -- NOSUBST i  <- freshIntP
              t  <- kindP'
              reservedOp "|"
              ra <- rp
              -- xi is a unique var based on the name in x.
              -- su replaces any use of x in the balance of the expression with the unique val
              -- NOSUBST let xi = intSymbol x i
              -- NOSUBST let su v = if v == x then xi else v
              return $ {- substa su $ NOSUBST -} t (Reft (x, ra)) )
     StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (RReftV LocSymbol -> BareTypeParsed
forall v c tv r. r -> RTypeV v c tv r
RHole (RReftV LocSymbol -> BareTypeParsed)
-> (ExprV LocSymbol -> RReftV LocSymbol)
-> ExprV LocSymbol
-> BareTypeParsed
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReftV LocSymbol -> RReftV LocSymbol
forall r v. r -> UReftV v r
uTop (ReftV LocSymbol -> RReftV LocSymbol)
-> (ExprV LocSymbol -> ReftV LocSymbol)
-> ExprV LocSymbol
-> RReftV LocSymbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Symbol, ExprV LocSymbol) -> ReftV LocSymbol
forall v. (Symbol, ExprV v) -> ReftV v
Reft ((Symbol, ExprV LocSymbol) -> ReftV LocSymbol)
-> (ExprV LocSymbol -> (Symbol, ExprV LocSymbol))
-> ExprV LocSymbol
-> ReftV LocSymbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Symbol
"VV",) (ExprV LocSymbol -> BareTypeParsed)
-> Parser (ExprV LocSymbol)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (ExprV LocSymbol)
rp)
     StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"refBindBindP"
   )


refDefP :: Symbol
        -> Parser (ExprV LocSymbol)
        -> Parser (ReftV LocSymbol -> BareTypeParsed)
        -> Parser BareTypeParsed
refDefP :: Symbol
-> Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
refDefP Symbol
sy Parser (ExprV LocSymbol)
rp StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
kindP' = StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall v a. ParserV v a -> ParserV v a
braces (StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
 -> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a b. (a -> b) -> a -> b
$ do
  x       <- Symbol -> Parser Symbol
optBindP Symbol
sy
  -- NOSUBST i       <- freshIntP
  t       <- try (kindP' <* reservedOp "|") <|> return (RHole . uTop) <?> "refDefP"
  ra      <- rp
  -- xi is a unique var based on the name in x.
  -- su replaces any use of x in the balance of the expression with the unique val
  -- NOSUBST let xi   = intSymbol x i
  -- NOSUBST let su v = if v == x then xi else v
  return   $ {- substa su $ NOSUBST -} t (Reft (x, ra))
       -- substa su . t . Reft . (x,) <$> (rp <* spaces))
      --  <|> ((RHole . uTop . Reft . ("VV",)) <$> (rp <* spaces))

refP :: Parser (ReftV LocSymbol -> BareTypeParsed) -> Parser BareTypeParsed
refP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
refP = Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
refBindBindP Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
refaP

relrefaP :: Parser (RelExprV LocSymbol)
relrefaP :: Parser (RelExprV LocSymbol)
relrefaP =
  Parser (RelExprV LocSymbol) -> Parser (RelExprV LocSymbol)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (ExprV LocSymbol -> RelExprV LocSymbol -> RelExprV LocSymbol
forall v. ExprV v -> RelExprV v -> RelExprV v
ERUnChecked (ExprV LocSymbol -> RelExprV LocSymbol -> RelExprV LocSymbol)
-> Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (RelExprV LocSymbol -> RelExprV LocSymbol)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
refaP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (RelExprV LocSymbol -> RelExprV LocSymbol)
-> ParserV LocSymbol ()
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (RelExprV LocSymbol -> RelExprV LocSymbol)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
":=>" StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (RelExprV LocSymbol -> RelExprV LocSymbol)
-> Parser (RelExprV LocSymbol) -> Parser (RelExprV LocSymbol)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (RelExprV LocSymbol)
relrefaP)
    Parser (RelExprV LocSymbol)
-> Parser (RelExprV LocSymbol) -> Parser (RelExprV LocSymbol)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (RelExprV LocSymbol) -> Parser (RelExprV LocSymbol)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (ExprV LocSymbol -> RelExprV LocSymbol -> RelExprV LocSymbol
forall v. ExprV v -> RelExprV v -> RelExprV v
ERChecked (ExprV LocSymbol -> RelExprV LocSymbol -> RelExprV LocSymbol)
-> Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (RelExprV LocSymbol -> RelExprV LocSymbol)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
refaP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (RelExprV LocSymbol -> RelExprV LocSymbol)
-> ParserV LocSymbol ()
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (RelExprV LocSymbol -> RelExprV LocSymbol)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"!=>" StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (RelExprV LocSymbol -> RelExprV LocSymbol)
-> Parser (RelExprV LocSymbol) -> Parser (RelExprV LocSymbol)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (RelExprV LocSymbol)
relrefaP)
    Parser (RelExprV LocSymbol)
-> Parser (RelExprV LocSymbol) -> Parser (RelExprV LocSymbol)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ExprV LocSymbol -> RelExprV LocSymbol
forall v. ExprV v -> RelExprV v
ERBasic (ExprV LocSymbol -> RelExprV LocSymbol)
-> Parser (ExprV LocSymbol) -> Parser (RelExprV LocSymbol)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
refaP

-- "sym :" or return the devault sym
optBindP :: Symbol -> Parser Symbol
optBindP :: Symbol -> Parser Symbol
optBindP Symbol
x = Parser Symbol -> Parser Symbol
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser Symbol
forall v. ParserV v Symbol
bindP Parser Symbol -> Parser Symbol -> Parser Symbol
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Symbol -> Parser Symbol
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Symbol
x

holeP :: Parser BareTypeParsed
holeP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
holeP    = [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"_" ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (RReftV LocSymbol -> BareTypeParsed
forall v c tv r. r -> RTypeV v c tv r
RHole (RReftV LocSymbol -> BareTypeParsed)
-> RReftV LocSymbol -> BareTypeParsed
forall a b. (a -> b) -> a -> b
$ ReftV LocSymbol -> RReftV LocSymbol
forall r v. r -> UReftV v r
uTop (ReftV LocSymbol -> RReftV LocSymbol)
-> ReftV LocSymbol -> RReftV LocSymbol
forall a b. (a -> b) -> a -> b
$ (Symbol, ExprV LocSymbol) -> ReftV LocSymbol
forall v. (Symbol, ExprV v) -> ReftV v
Reft (Symbol
"VV", ExprV LocSymbol
forall v. ExprV v
hole))

holeRefP :: Parser (ReftV v -> BareTypeV v)
holeRefP :: forall v. Parser (ReftV v -> BareTypeV v)
holeRefP = [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"_" ParserV LocSymbol ()
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (ReftV v -> BareTypeV v)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (ReftV v -> BareTypeV v)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (ReftV v -> BareTypeV v)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (ReftV v -> BareTypeV v)
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (RReftV v -> BareTypeV v
forall v c tv r. r -> RTypeV v c tv r
RHole (RReftV v -> BareTypeV v)
-> (ReftV v -> RReftV v) -> ReftV v -> BareTypeV v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReftV v -> RReftV v
forall r v. r -> UReftV v r
uTop)

-- NOPROP refasHoleP :: Parser Expr
-- NOPROP refasHoleP  = try refaP
-- NOPROP          <|> (reserved "_" >> return hole)

refasHoleP :: Parser (ExprV LocSymbol)
refasHoleP :: Parser (ExprV LocSymbol)
refasHoleP
  =  ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"_" ParserV LocSymbol ()
-> Parser (ExprV LocSymbol) -> Parser (ExprV LocSymbol)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ExprV LocSymbol -> Parser (ExprV LocSymbol)
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ExprV LocSymbol
forall v. ExprV v
hole)
 Parser (ExprV LocSymbol)
-> Parser (ExprV LocSymbol) -> Parser (ExprV LocSymbol)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
refaP
 Parser (ExprV LocSymbol) -> [Char] -> Parser (ExprV LocSymbol)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"refasHoleP"

bbaseP :: Parser (ReftV LocSymbol -> BareTypeParsed)
bbaseP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
bbaseP
  =  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
forall v. Parser (ReftV v -> BareTypeV v)
holeRefP  -- Starts with '_'
 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Maybe BareTypeParsed
 -> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
 -> ReftV LocSymbol
 -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Maybe BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Maybe BareTypeParsed
-> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> ReftV LocSymbol
-> BareTypeParsed
forall v tv r.
Maybe (RTypeV v BTyCon tv (UReftV v r))
-> [RTPropV v BTyCon tv (UReftV v r)]
-> r
-> RTypeV v BTyCon tv (UReftV v r)
bLst (StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Maybe BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Maybe BareTypeParsed)
forall v a. ParserV v a -> ParserV v a
brackets (StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Maybe BareTypeParsed)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP)) StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
forall r c.
Monoid r =>
Parser [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
predicatesP
 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([(Maybe Symbol, BareTypeParsed)]
 -> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
 -> ReftV LocSymbol
 -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Maybe Symbol, BareTypeParsed)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 [(Maybe Symbol, BareTypeParsed)]
-> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> ReftV LocSymbol
-> BareTypeParsed
bTup (StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [(Maybe Symbol, BareTypeParsed)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Maybe Symbol, BareTypeParsed)]
forall v a. ParserV v a -> ParserV v a
parens (StateT
   (PStateV LocSymbol)
   (Parsec Void [Char])
   [(Maybe Symbol, BareTypeParsed)]
 -> StateT
      (PStateV LocSymbol)
      (Parsec Void [Char])
      [(Maybe Symbol, BareTypeParsed)])
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Maybe Symbol, BareTypeParsed)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Maybe Symbol, BareTypeParsed)]
forall a b. (a -> b) -> a -> b
$ StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Maybe Symbol, BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Maybe Symbol, BareTypeParsed)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy (StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Maybe Symbol, BareTypeParsed)
forall a. Parser a -> Parser (Maybe Symbol, a)
maybeBind StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP) StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma) StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
forall r c.
Monoid r =>
Parser [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
predicatesP
 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
parseHelper  -- starts with lower
 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (BTyCon
 -> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
 -> [BareTypeParsed]
 -> PredicateV LocSymbol
 -> ReftV LocSymbol
 -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [BareTypeParsed]
-> Parser (PredicateV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall (m :: * -> *) a1 a2 a3 a4 r.
Monad m =>
(a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM4 BTyCon
-> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> [BareTypeParsed]
-> PredicateV LocSymbol
-> ReftV LocSymbol
-> BareTypeParsed
forall c v tv r.
c
-> [RTPropV v c tv (UReftV v r)]
-> [RTypeV v c tv (UReftV v r)]
-> PredicateV v
-> r
-> RTypeV v c tv (UReftV v r)
bCon StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
bTyConP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
forall r c.
Monoid r =>
Parser [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
predicatesP (StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [BareTypeParsed]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTyArgP) Parser (PredicateV LocSymbol)
mmonoPredicateP
           -- starts with "'" or upper case char
 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> [Char]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bbaseP"
 where
   parseHelper :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
parseHelper = do
     l <- Parser Symbol -> ParserV LocSymbol LocSymbol
forall v a. ParserV v a -> ParserV v (Located a)
located Parser Symbol
forall v. ParserV v Symbol
lowerIdP
     lowerIdTail l

maybeBind :: Parser a -> Parser (Maybe Symbol, a)
maybeBind :: forall a. Parser a -> Parser (Maybe Symbol, a)
maybeBind Parser a
parser = do {bd <- Parser Symbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Maybe Symbol)
forall {f :: * -> *} {e} {s} {a}.
MonadParsec e s f =>
f a -> f (Maybe a)
maybeP' Parser Symbol
bbindP; ty <- parser ; return (bd, ty)}
  where
    maybeP' :: f a -> f (Maybe a)
maybeP' f a
p = f (Maybe a) -> f (Maybe a)
forall a. f a -> f a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> f a -> f (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f a
p)
             f (Maybe a) -> f (Maybe a) -> f (Maybe a)
forall a. f a -> f a -> f a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe a -> f (Maybe a)
forall a. a -> f a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall {a}. Maybe a
Nothing

lowerIdTail :: LocSymbol -> Parser (ReftV LocSymbol -> BareTypeParsed)
lowerIdTail :: LocSymbol
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
lowerIdTail LocSymbol
l =
          ([BareTypeParsed] -> ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [BareTypeParsed]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (BTyVar -> [BareTypeParsed] -> ReftV LocSymbol -> BareTypeParsed
forall (t :: * -> *).
Foldable t =>
BTyVar -> t BareTypeParsed -> ReftV LocSymbol -> BareTypeParsed
bAppTy (LocSymbol -> BTyVar
bTyVar LocSymbol
l)) (StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [BareTypeParsed]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTyArgP)
      StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (PredicateV LocSymbol -> ReftV LocSymbol -> BareTypeParsed)
-> Parser (PredicateV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (BTyVar -> PredicateV LocSymbol -> ReftV LocSymbol -> BareTypeParsed
forall tv v r c.
tv -> PredicateV v -> r -> RTypeV v c tv (UReftV v r)
bRVar (LocSymbol -> BTyVar
bTyVar LocSymbol
l)) Parser (PredicateV LocSymbol)
monoPredicateP

bTyConP :: Parser BTyCon
bTyConP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
bTyConP
  =  ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"'" ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Located LHName -> BTyCon
mkPromotedBTyCon (Located LHName -> BTyCon)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LHNameSpace
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locUpperIdLHNameP (LHThisModuleNameFlag -> LHNameSpace
LHDataConName LHThisModuleNameFlag
LHAnyModuleNameF))
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Located LHName -> BTyCon
mkBTyCon (Located LHName -> BTyCon)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LHNameSpace
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locUpperIdLHNameP LHNameSpace
LHTcName
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"*" ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
        BTyCon -> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Located LHName -> BTyCon
mkBTyCon (LHName -> Located LHName
forall a. a -> Located a
dummyLoc (LHName -> Located LHName) -> LHName -> Located LHName
forall a b. (a -> b) -> a -> b
$ LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName LHNameSpace
LHTcName (Symbol -> LHName) -> Symbol -> LHName
forall a b. (a -> b) -> a -> b
$ [Char] -> Symbol
forall a. Symbolic a => a -> Symbol
symbol ([Char]
"*" :: String)))
     )
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
-> [Char] -> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bTyConP"

locUpperIdLHNameP :: LHNameSpace -> Parser (Located LHName)
locUpperIdLHNameP :: LHNameSpace
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locUpperIdLHNameP LHNameSpace
ns = (Symbol -> LHName) -> LocSymbol -> Located LHName
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName LHNameSpace
ns) (LocSymbol -> Located LHName)
-> ParserV LocSymbol LocSymbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserV LocSymbol LocSymbol
forall v. ParserV v LocSymbol
locUpperIdP

mkPromotedBTyCon :: Located LHName -> BTyCon
mkPromotedBTyCon :: Located LHName -> BTyCon
mkPromotedBTyCon Located LHName
x = Located LHName -> Bool -> Bool -> BTyCon
BTyCon Located LHName
x Bool
False Bool
True -- (consSym '\'' <$> x) False True

classBTyConP :: Parser BTyCon
classBTyConP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
classBTyConP = Located LHName -> BTyCon
mkClassBTyCon (Located LHName -> BTyCon)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LHNameSpace
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locUpperIdLHNameP LHNameSpace
LHTcName

mkClassBTyCon :: Located LHName -> BTyCon
mkClassBTyCon :: Located LHName -> BTyCon
mkClassBTyCon Located LHName
x = Located LHName -> Bool -> Bool -> BTyCon
BTyCon Located LHName
x Bool
True Bool
False

bbaseNoAppP :: Parser (ReftV LocSymbol -> BareTypeParsed)
bbaseNoAppP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
bbaseNoAppP
  =  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
forall v. Parser (ReftV v -> BareTypeV v)
holeRefP
 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Maybe BareTypeParsed
 -> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
 -> ReftV LocSymbol
 -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Maybe BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Maybe BareTypeParsed
-> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> ReftV LocSymbol
-> BareTypeParsed
forall v tv r.
Maybe (RTypeV v BTyCon tv (UReftV v r))
-> [RTPropV v BTyCon tv (UReftV v r)]
-> r
-> RTypeV v BTyCon tv (UReftV v r)
bLst (StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Maybe BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Maybe BareTypeParsed)
forall v a. ParserV v a -> ParserV v a
brackets (StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Maybe BareTypeParsed)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP)) StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
forall r c.
Monoid r =>
Parser [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
predicatesP
 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([(Maybe Symbol, BareTypeParsed)]
 -> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
 -> ReftV LocSymbol
 -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Maybe Symbol, BareTypeParsed)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 [(Maybe Symbol, BareTypeParsed)]
-> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> ReftV LocSymbol
-> BareTypeParsed
bTup (StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [(Maybe Symbol, BareTypeParsed)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Maybe Symbol, BareTypeParsed)]
forall v a. ParserV v a -> ParserV v a
parens (StateT
   (PStateV LocSymbol)
   (Parsec Void [Char])
   [(Maybe Symbol, BareTypeParsed)]
 -> StateT
      (PStateV LocSymbol)
      (Parsec Void [Char])
      [(Maybe Symbol, BareTypeParsed)])
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Maybe Symbol, BareTypeParsed)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Maybe Symbol, BareTypeParsed)]
forall a b. (a -> b) -> a -> b
$ StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Maybe Symbol, BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Maybe Symbol, BareTypeParsed)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy (StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Maybe Symbol, BareTypeParsed)
forall a. Parser a -> Parser (Maybe Symbol, a)
maybeBind StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP) StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma) StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
forall r c.
Monoid r =>
Parser [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
predicatesP
 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ((BTyCon
 -> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
 -> [BareTypeParsed]
 -> PredicateV LocSymbol
 -> ReftV LocSymbol
 -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [BareTypeParsed]
-> Parser (PredicateV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall (m :: * -> *) a1 a2 a3 a4 r.
Monad m =>
(a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM4 BTyCon
-> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> [BareTypeParsed]
-> PredicateV LocSymbol
-> ReftV LocSymbol
-> BareTypeParsed
forall c v tv r.
c
-> [RTPropV v c tv (UReftV v r)]
-> [RTypeV v c tv (UReftV v r)]
-> PredicateV v
-> r
-> RTypeV v c tv (UReftV v r)
bCon StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
bTyConP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
forall r c.
Monoid r =>
Parser [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
predicatesP ([BareTypeParsed]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [BareTypeParsed]
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []) (PredicateV LocSymbol -> Parser (PredicateV LocSymbol)
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (PredicateV LocSymbol -> Parser (PredicateV LocSymbol))
-> PredicateV LocSymbol -> Parser (PredicateV LocSymbol)
forall a b. (a -> b) -> a -> b
$ [UsedPVarV LocSymbol] -> PredicateV LocSymbol
forall v. [UsedPVarV v] -> PredicateV v
Pr []))
 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (BTyVar
 -> PredicateV LocSymbol -> ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyVar
-> Parser (PredicateV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 BTyVar -> PredicateV LocSymbol -> ReftV LocSymbol -> BareTypeParsed
forall tv v r c.
tv -> PredicateV v -> r -> RTypeV v c tv (UReftV v r)
bRVar (LocSymbol -> BTyVar
bTyVar (LocSymbol -> BTyVar)
-> ParserV LocSymbol LocSymbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyVar
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol -> ParserV LocSymbol LocSymbol
forall v a. ParserV v a -> ParserV v (Located a)
located Parser Symbol
forall v. ParserV v Symbol
lowerIdP) Parser (PredicateV LocSymbol)
monoPredicateP
 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> [Char]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ReftV LocSymbol -> BareTypeParsed)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bbaseNoAppP"

bareTyArgP :: Parser BareTypeParsed
bareTyArgP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTyArgP
  =  (Located (ExprV LocSymbol) -> BareTypeParsed
forall v c tv r. Located (ExprV v) -> RTypeV v c tv r
RExprArg (Located (ExprV LocSymbol) -> BareTypeParsed)
-> (Located Integer -> Located (ExprV LocSymbol))
-> Located Integer
-> BareTypeParsed
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Integer -> ExprV LocSymbol)
-> Located Integer -> Located (ExprV LocSymbol)
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Constant -> ExprV LocSymbol
forall v. Constant -> ExprV v
ECon (Constant -> ExprV LocSymbol)
-> (Integer -> Constant) -> Integer -> ExprV LocSymbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Constant
I) (Located Integer -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located Integer)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located Integer)
forall v. ParserV v (Located Integer)
locNatural)
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall v a. ParserV v a -> ParserV v a
braces (StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
 -> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a b. (a -> b) -> a -> b
$ Located (ExprV LocSymbol) -> BareTypeParsed
forall v c tv r. Located (ExprV v) -> RTypeV v c tv r
RExprArg (Located (ExprV LocSymbol) -> BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (ExprV LocSymbol))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (ExprV LocSymbol))
forall v a. ParserV v a -> ParserV v (Located a)
located Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
exprP)
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareAtomNoAppP
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall v a. ParserV v a -> ParserV v a
parens StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP)
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bareTyArgP"

bareAtomNoAppP :: Parser BareTypeParsed
bareAtomNoAppP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareAtomNoAppP
  =  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
refP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
bbaseNoAppP
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall (m :: * -> *) b. Monad m => m (ReftV LocSymbol -> b) -> m b
dummyP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
bbaseNoAppP
 StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bareAtomNoAppP"


constraintP :: Parser BareTypeParsed
constraintP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
constraintP
  = do xts <- Parser [(LocSymbol, BareTypeParsed)]
constraintEnvP
       t1  <- bareTypeP
       reservedOp "<:"
       fromRTypeRep . RTypeRep [] []
                               ((val . fst <$> xts) ++ [dummySymbol])
                               (replicate (length xts + 1) defRFInfo)
                               (replicate (length xts + 1) trueURef)
                               ((snd <$> xts) ++ [t1]) <$> bareTypeP

trueURef :: UReftV v (ReftV v)
trueURef :: forall v. UReftV v (ReftV v)
trueURef = ReftV v -> PredicateV v -> UReftV v (ReftV v)
forall v r. r -> PredicateV v -> UReftV v r
MkUReft ReftV v
forall v. ReftV v
trueReft ([UsedPVarV v] -> PredicateV v
forall v. [UsedPVarV v] -> PredicateV v
Pr [])

constraintEnvP :: Parser [(LocSymbol, BareTypeParsed)]
constraintEnvP :: Parser [(LocSymbol, BareTypeParsed)]
constraintEnvP
   =  Parser [(LocSymbol, BareTypeParsed)]
-> Parser [(LocSymbol, BareTypeParsed)]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (do xts <- StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (LocSymbol, BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> Parser [(LocSymbol, BareTypeParsed)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (LocSymbol, BareTypeParsed)
tyBindNoLocP StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma
              reservedOp "|-"
              return xts)
  Parser [(LocSymbol, BareTypeParsed)]
-> Parser [(LocSymbol, BareTypeParsed)]
-> Parser [(LocSymbol, BareTypeParsed)]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [(LocSymbol, BareTypeParsed)]
-> Parser [(LocSymbol, BareTypeParsed)]
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []
  Parser [(LocSymbol, BareTypeParsed)]
-> [Char] -> Parser [(LocSymbol, BareTypeParsed)]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"constraintEnvP"

rrTy :: BareTypeParsed -> BareTypeParsed -> BareTypeParsed
rrTy :: BareTypeParsed -> BareTypeParsed -> BareTypeParsed
rrTy BareTypeParsed
ct = [(Symbol, BareTypeParsed)]
-> RReftV LocSymbol -> Oblig -> BareTypeParsed -> BareTypeParsed
forall v c tv r.
[(Symbol, RTypeV v c tv r)]
-> r -> Oblig -> RTypeV v c tv r -> RTypeV v c tv r
RRTy ([(Symbol, BareTypeParsed)]
xts [(Symbol, BareTypeParsed)]
-> [(Symbol, BareTypeParsed)] -> [(Symbol, BareTypeParsed)]
forall a. [a] -> [a] -> [a]
++ [(Symbol
dummySymbol, BareTypeParsed
tr)]) RReftV LocSymbol
forall v. UReftV v (ReftV v)
trueURef Oblig
OCons
  where
    tr :: BareTypeParsed
tr   = RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
-> BareTypeParsed
forall v c tv r. RTypeRepV v c tv r -> RTypeV v c tv r
ty_res RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
trep
    xts :: [(Symbol, BareTypeParsed)]
xts  = [Symbol] -> [BareTypeParsed] -> [(Symbol, BareTypeParsed)]
forall a b. [a] -> [b] -> [(a, b)]
zip (RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol) -> [Symbol]
forall v c tv r. RTypeRepV v c tv r -> [Symbol]
ty_binds RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
trep) (RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
-> [BareTypeParsed]
forall v c tv r. RTypeRepV v c tv r -> [RTypeV v c tv r]
ty_args RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
trep)
    trep :: RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
trep = BareTypeParsed
-> RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
forall v c tv r. RTypeV v c tv r -> RTypeRepV v c tv r
toRTypeRep BareTypeParsed
ct

--  "forall <z w> . TYPE"
-- or
--  "forall x y <z :: Nat, w :: Int> . TYPE"
bareAllP :: Parser BareTypeParsed
bareAllP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareAllP = do
  sp <- StateT (PStateV LocSymbol) (Parsec Void [Char]) SourcePos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m SourcePos
getSourcePos
  as  <- tyVarDefsP
  ps  <- angles inAngles
        <|> return []
  _ <- dot
  t <- bareTypeP
  return $ foldr rAllT (foldr (rAllP sp) t ps) (makeRTVar <$> as)
  where
    rAllT :: RTVUV v c tv
-> RTypeV v c tv (UReftV v (ReftV v))
-> RTypeV v c tv (UReftV v (ReftV v))
rAllT RTVUV v c tv
a RTypeV v c tv (UReftV v (ReftV v))
t = RTVUV v c tv
-> RTypeV v c tv (UReftV v (ReftV v))
-> UReftV v (ReftV v)
-> RTypeV v c tv (UReftV v (ReftV v))
forall v c tv r.
RTVUV v c tv -> RTypeV v c tv r -> r -> RTypeV v c tv r
RAllT RTVUV v c tv
a RTypeV v c tv (UReftV v (ReftV v))
t UReftV v (ReftV v)
forall v. UReftV v (ReftV v)
trueURef
    inAngles :: ParserV
  LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
inAngles  = ParserV
  LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
-> ParserV
     LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try  (StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ()))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> ParserV
     LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ()))
predVarDefP StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma)

-- See #1907 for why we have to alpha-rename pvar binders
rAllP :: SourcePos -> PVarV LocSymbol (BSortV LocSymbol) -> BareTypeParsed -> BareTypeParsed
rAllP :: SourcePos
-> PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())
-> BareTypeParsed
-> BareTypeParsed
rAllP SourcePos
sp PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())
p BareTypeParsed
t = PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())
-> BareTypeParsed -> BareTypeParsed
forall v c tv r. PVUV v c tv -> RTypeV v c tv r -> RTypeV v c tv r
RAllP PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())
p' ({- F.tracepp "rAllP" $ -} PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())
-> PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())
-> BareTypeParsed
-> BareTypeParsed
forall v.
PVarV v (BSortV v)
-> PVarV v (BSortV v) -> BareTypeParsed -> BareTypeParsed
substPVar PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())
p PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())
p' BareTypeParsed
t)
  where
    p' :: PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())
p'  = PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())
p { pname = pn' }
    pn' :: Symbol
pn' = PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ()) -> Symbol
forall v t. PVarV v t -> Symbol
pname PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())
p Symbol -> Int -> Symbol
forall a. Show a => Symbol -> a -> Symbol
`intSymbol` Int
lin Symbol -> Int -> Symbol
forall a. Show a => Symbol -> a -> Symbol
`intSymbol` Int
col
    lin :: Int
lin = Pos -> Int
unPos (SourcePos -> Pos
sourceLine SourcePos
sp)
    col :: Int
col = Pos -> Int
unPos (SourcePos -> Pos
sourceColumn  SourcePos
sp)

tyVarDefsP :: Parser [BTyVar]
tyVarDefsP :: Parser [BTyVar]
tyVarDefsP
  = Parser [BTyVar] -> Parser [BTyVar]
forall v a. ParserV v a -> ParserV v a
parens (StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyVar
-> Parser [BTyVar]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (LocSymbol -> BTyVar
bTyVar (LocSymbol -> BTyVar)
-> ParserV LocSymbol LocSymbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyVar
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol -> ParserV LocSymbol LocSymbol
forall v a. ParserV v a -> ParserV v (Located a)
located Parser Symbol
tyKindVarIdP))
 Parser [BTyVar] -> Parser [BTyVar] -> Parser [BTyVar]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyVar
-> Parser [BTyVar]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (LocSymbol -> BTyVar
bTyVar (LocSymbol -> BTyVar)
-> ParserV LocSymbol LocSymbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyVar
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol -> ParserV LocSymbol LocSymbol
forall v a. ParserV v a -> ParserV v (Located a)
located Parser Symbol
tyVarIdP)
 Parser [BTyVar] -> [Char] -> Parser [BTyVar]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"tyVarDefsP"

tyKindVarIdP :: Parser Symbol
tyKindVarIdP :: Parser Symbol
tyKindVarIdP = do
   tv <- Parser Symbol
tyVarIdP
   do reservedOp "::"; _ <- kindP; return tv <|> return tv

kindP :: Parser BareTypeParsed
kindP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
kindP = StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareAtomBindP

predVarDefsP :: Parser [PVarV LocSymbol (BSortV LocSymbol)]
predVarDefsP :: ParserV
  LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
predVarDefsP
  =  ParserV
  LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
-> ParserV
     LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
forall v a. ParserV v a -> ParserV v a
angles (StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ()))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> ParserV
     LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy1 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ()))
predVarDefP StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma)
 ParserV
  LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
-> ParserV
     LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
-> ParserV
     LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
-> ParserV
     LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []
 ParserV
  LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
-> [Char]
-> ParserV
     LocSymbol [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"predVarDefP"

predVarDefP :: Parser (PVarV LocSymbol (BSortV LocSymbol))
predVarDefP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ()))
predVarDefP
  = Symbol
-> ()
-> [(Symbol, RTypeV LocSymbol BTyCon BTyVar ())]
-> PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())
forall t t1. Symbol -> t -> [(Symbol, t1)] -> PVarV LocSymbol t1
bPVar (Symbol
 -> ()
 -> [(Symbol, RTypeV LocSymbol BTyCon BTyVar ())]
 -> PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ()))
-> Parser Symbol
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (()
      -> [(Symbol, RTypeV LocSymbol BTyCon BTyVar ())]
      -> PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
predVarIdP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (()
   -> [(Symbol, RTypeV LocSymbol BTyCon BTyVar ())]
   -> PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ()))
-> ParserV LocSymbol ()
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     ([(Symbol, RTypeV LocSymbol BTyCon BTyVar ())]
      -> PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ()))
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"::" StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  ([(Symbol, RTypeV LocSymbol BTyCon BTyVar ())]
   -> PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ()))
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Symbol, RTypeV LocSymbol BTyCon BTyVar ())]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ()))
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [(Symbol, RTypeV LocSymbol BTyCon BTyVar ())]
propositionSortP

predVarIdP :: Parser Symbol
predVarIdP :: Parser Symbol
predVarIdP
  = Symbol -> Symbol
forall a. Symbolic a => a -> Symbol
symbol (Symbol -> Symbol) -> Parser Symbol -> Parser Symbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
tyVarIdP

bPVar :: Symbol -> t -> [(Symbol, t1)] -> PVarV LocSymbol t1
bPVar :: forall t t1. Symbol -> t -> [(Symbol, t1)] -> PVarV LocSymbol t1
bPVar Symbol
p t
_ [(Symbol, t1)]
xts  = Symbol
-> t1
-> Symbol
-> [(t1, Symbol, ExprV LocSymbol)]
-> PVarV LocSymbol t1
forall v t.
Symbol -> t -> Symbol -> [(t, Symbol, ExprV v)] -> PVarV v t
PV Symbol
p t1
τ Symbol
dummySymbol [(t1, Symbol, ExprV LocSymbol)]
τxs
  where
    (Symbol
_, t1
τ) = [Char] -> [(Symbol, t1)] -> (Symbol, t1)
forall {a}. [Char] -> [a] -> a
safeLast [Char]
"bPVar last" [(Symbol, t1)]
xts
    τxs :: [(t1, Symbol, ExprV LocSymbol)]
τxs    = [ (t1
τ', Symbol
x, LocSymbol -> ExprV LocSymbol
forall v. v -> ExprV v
EVar (Symbol -> LocSymbol
forall a. a -> Located a
dummyLoc Symbol
x)) | (Symbol
x, t1
τ') <- [(Symbol, t1)] -> [(Symbol, t1)]
forall a. HasCallStack => [a] -> [a]
init [(Symbol, t1)]
xts ]
    safeLast :: [Char] -> [a] -> a
safeLast [Char]
_ xs :: [a]
xs@(a
_:[a]
_) = [a] -> a
forall a. HasCallStack => [a] -> a
last [a]
xs
    safeLast [Char]
msg [a]
_      = Maybe SrcSpan -> [Char] -> a
forall a. HasCallStack => Maybe SrcSpan -> [Char] -> a
panic Maybe SrcSpan
forall {a}. Maybe a
Nothing ([Char] -> a) -> [Char] -> a
forall a b. (a -> b) -> a -> b
$ [Char]
"safeLast with empty list " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
msg

propositionSortP :: Parser [(Symbol, BSortV LocSymbol)]
propositionSortP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [(Symbol, RTypeV LocSymbol BTyCon BTyVar ())]
propositionSortP = ((Symbol, BareTypeParsed)
 -> (Symbol, RTypeV LocSymbol BTyCon BTyVar ()))
-> [(Symbol, BareTypeParsed)]
-> [(Symbol, RTypeV LocSymbol BTyCon BTyVar ())]
forall a b. (a -> b) -> [a] -> [b]
map ((BareTypeParsed -> RTypeV LocSymbol BTyCon BTyVar ())
-> (Symbol, BareTypeParsed)
-> (Symbol, RTypeV LocSymbol BTyCon BTyVar ())
forall a b. (a -> b) -> (Symbol, a) -> (Symbol, b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BareTypeParsed -> RTypeV LocSymbol BTyCon BTyVar ()
forall v c tv r. RTypeV v c tv r -> RTypeV v c tv ()
toRSort) ([(Symbol, BareTypeParsed)]
 -> [(Symbol, RTypeV LocSymbol BTyCon BTyVar ())])
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Symbol, RTypeV LocSymbol BTyCon BTyVar ())]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
propositionTypeP

propositionTypeP :: Parser [(Symbol, BareTypeParsed)]
propositionTypeP :: StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
propositionTypeP = ([Char]
 -> StateT
      (PStateV LocSymbol)
      (Parsec Void [Char])
      [(Symbol, BareTypeParsed)])
-> ([(Symbol, BareTypeParsed)]
    -> StateT
         (PStateV LocSymbol)
         (Parsec Void [Char])
         [(Symbol, BareTypeParsed)])
-> Either [Char] [(Symbol, BareTypeParsed)]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either [Char]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
forall a.
[Char] -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [(Symbol, BareTypeParsed)]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either [Char] [(Symbol, BareTypeParsed)]
 -> StateT
      (PStateV LocSymbol)
      (Parsec Void [Char])
      [(Symbol, BareTypeParsed)])
-> (BareTypeParsed -> Either [Char] [(Symbol, BareTypeParsed)])
-> BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BareTypeParsed -> Either [Char] [(Symbol, BareTypeParsed)]
mkPropositionType (BareTypeParsed
 -> StateT
      (PStateV LocSymbol)
      (Parsec Void [Char])
      [(Symbol, BareTypeParsed)])
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP

mkPropositionType :: BareTypeParsed -> Either String [(Symbol, BareTypeParsed)]
mkPropositionType :: BareTypeParsed -> Either [Char] [(Symbol, BareTypeParsed)]
mkPropositionType BareTypeParsed
t
  | Bool
isOk      = [(Symbol, BareTypeParsed)]
-> Either [Char] [(Symbol, BareTypeParsed)]
forall a b. b -> Either a b
Right ([(Symbol, BareTypeParsed)]
 -> Either [Char] [(Symbol, BareTypeParsed)])
-> [(Symbol, BareTypeParsed)]
-> Either [Char] [(Symbol, BareTypeParsed)]
forall a b. (a -> b) -> a -> b
$ [Symbol] -> [BareTypeParsed] -> [(Symbol, BareTypeParsed)]
forall a b. [a] -> [b] -> [(a, b)]
zip (RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol) -> [Symbol]
forall v c tv r. RTypeRepV v c tv r -> [Symbol]
ty_binds RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
tRep) (RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
-> [BareTypeParsed]
forall v c tv r. RTypeRepV v c tv r -> [RTypeV v c tv r]
ty_args RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
tRep)
  | Bool
otherwise = [Char] -> Either [Char] [(Symbol, BareTypeParsed)]
forall a b. a -> Either a b
Left [Char]
mkErr
  where
    isOk :: Bool
isOk      = BareTypeParsed -> Bool
forall v t t1. RTypeV v BTyCon t t1 -> Bool
isPropBareType (RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
-> BareTypeParsed
forall v c tv r. RTypeRepV v c tv r -> RTypeV v c tv r
ty_res RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
tRep)
    tRep :: RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
tRep      = BareTypeParsed
-> RTypeRepV LocSymbol BTyCon BTyVar (RReftV LocSymbol)
forall v c tv r. RTypeV v c tv r -> RTypeRepV v c tv r
toRTypeRep BareTypeParsed
t
    mkErr :: [Char]
mkErr     = [Char]
"Proposition type with non-Bool output: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ BareType -> [Char]
forall a. PPrint a => a -> [Char]
showpp (BareTypeParsed -> BareType
parsedToBareType BareTypeParsed
t)

xyP :: Parser x -> Parser a -> Parser y -> Parser (x, y)
xyP :: forall x a y. Parser x -> Parser a -> Parser y -> Parser (x, y)
xyP Parser x
lP Parser a
sepP Parser y
rP =
  (,) (x -> y -> (x, y))
-> Parser x
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (y -> (x, y))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser x
lP StateT (PStateV LocSymbol) (Parsec Void [Char]) (y -> (x, y))
-> Parser a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (y -> (x, y))
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser a
sepP StateT (PStateV LocSymbol) (Parsec Void [Char]) (y -> (x, y))
-> Parser y
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (x, y)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser y
rP

dummyBindP :: Parser Symbol
dummyBindP :: Parser Symbol
dummyBindP = Symbol -> Integer -> Symbol
tempSymbol Symbol
"db" (Integer -> Symbol)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Integer
-> Parser Symbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) Integer
forall v. ParserV v Integer
freshIntP

isPropBareType :: RTypeV v BTyCon t t1 -> Bool
isPropBareType :: forall v t t1. RTypeV v BTyCon t t1 -> Bool
isPropBareType (RApp BTyCon
tc [] [RTPropV v BTyCon t t1]
_ t1
_) =
    case Located LHName -> LHName
forall a. Located a -> a
val (BTyCon -> Located LHName
btc_tc BTyCon
tc) of
      LHNUnresolved LHNameSpace
_ Symbol
s -> Symbol
s Symbol -> Symbol -> Bool
forall a. Eq a => a -> a -> Bool
== Symbol
boolConName
      LHName
_ -> Bool
False
isPropBareType RTypeV v BTyCon t t1
_ = Bool
False

getClasses :: RTypeV v BTyCon t t1 -> [RTypeV v BTyCon t t1]
getClasses :: forall v t t1. RTypeV v BTyCon t t1 -> [RTypeV v BTyCon t t1]
getClasses (RApp BTyCon
tc [RTypeV v BTyCon t t1]
ts [RTPropV v BTyCon t t1]
ps t1
r)
  | BTyCon -> Bool
forall c. TyConable c => c -> Bool
isTuple BTyCon
tc
  = (RTypeV v BTyCon t t1 -> [RTypeV v BTyCon t t1])
-> [RTypeV v BTyCon t t1] -> [RTypeV v BTyCon t t1]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap RTypeV v BTyCon t t1 -> [RTypeV v BTyCon t t1]
forall v t t1. RTypeV v BTyCon t t1 -> [RTypeV v BTyCon t t1]
getClasses [RTypeV v BTyCon t t1]
ts
  | Bool
otherwise
  = [BTyCon
-> [RTypeV v BTyCon t t1]
-> [RTPropV v BTyCon t t1]
-> t1
-> RTypeV v BTyCon t t1
forall v c tv r.
c
-> [RTypeV v c tv r] -> [RTPropV v c tv r] -> r -> RTypeV v c tv r
RApp (BTyCon
tc { btc_class = True }) [RTypeV v BTyCon t t1]
ts [RTPropV v BTyCon t t1]
ps t1
r]
getClasses RTypeV v BTyCon t t1
t
  = [RTypeV v BTyCon t t1
t]

dummyP ::  Monad m => m (ReftV LocSymbol -> b) -> m b
dummyP :: forall (m :: * -> *) b. Monad m => m (ReftV LocSymbol -> b) -> m b
dummyP m (ReftV LocSymbol -> b)
fm
  = m (ReftV LocSymbol -> b)
fm m (ReftV LocSymbol -> b) -> m (ReftV LocSymbol) -> m b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` ReftV LocSymbol -> m (ReftV LocSymbol)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ReftV LocSymbol
forall v. ReftV v
trueReft

symsP :: Monoid r
      => Parser [(Symbol, RTypeV v c BTyVar r)]
symsP :: forall r v c. Monoid r => Parser [(Symbol, RTypeV v c BTyVar r)]
symsP
  = do [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"\\"
       ss <- Parser Symbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Symbol]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many Parser Symbol
forall v. ParserV v Symbol
symbolP
       reservedOp "->"
       return $ (, dummyRSort) <$> ss
 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [(Symbol, RTypeV v c BTyVar r)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Symbol, RTypeV v c BTyVar r)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Symbol, RTypeV v c BTyVar r)]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [(Symbol, RTypeV v c BTyVar r)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Symbol, RTypeV v c BTyVar r)]
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []
 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [(Symbol, RTypeV v c BTyVar r)]
-> [Char]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Symbol, RTypeV v c BTyVar r)]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"symsP"

dummyRSort :: Monoid r => RTypeV v c BTyVar r
dummyRSort :: forall r v c. Monoid r => RTypeV v c BTyVar r
dummyRSort
  = BTyVar -> r -> RTypeV v c BTyVar r
forall v c tv r. tv -> r -> RTypeV v c tv r
RVar (LocSymbol -> BTyVar
BTV LocSymbol
"dummy") r
forall a. Monoid a => a
mempty

predicatesP :: Monoid r
            => Parser [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
predicatesP :: forall r c.
Monoid r =>
Parser [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
predicatesP
   =  ParserV
  LocSymbol [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
-> ParserV
     LocSymbol [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
forall v a. ParserV v a -> ParserV v a
angles (StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> ParserV
     LocSymbol [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy1 StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
forall r c.
Monoid r =>
Parser (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
predicate1P StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma)
  ParserV
  LocSymbol [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
-> ParserV
     LocSymbol [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
-> ParserV
     LocSymbol [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
-> ParserV
     LocSymbol [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []
  ParserV
  LocSymbol [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
-> [Char]
-> ParserV
     LocSymbol [Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"predicatesP"

predicate1P :: Monoid r
            => Parser (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
predicate1P :: forall r c.
Monoid r =>
Parser (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
predicate1P
   =  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ([(Symbol, RTypeV LocSymbol c BTyVar r)]
-> BareTypeParsed
-> Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed
forall τ t. [(Symbol, τ)] -> t -> Ref τ t
RProp ([(Symbol, RTypeV LocSymbol c BTyVar r)]
 -> BareTypeParsed
 -> Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(Symbol, RTypeV LocSymbol c BTyVar r)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (BareTypeParsed
      -> Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [(Symbol, RTypeV LocSymbol c BTyVar r)]
forall r v c. Monoid r => Parser [(Symbol, RTypeV v c BTyVar r)]
symsP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (BareTypeParsed
   -> Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
refP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ReftV LocSymbol -> BareTypeParsed)
bbaseP)
  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([(Symbol, RTypeV LocSymbol c BTyVar r)]
-> RReftV LocSymbol
-> Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed
forall τ r v c tv. [(Symbol, τ)] -> r -> Ref τ (RTypeV v c tv r)
rPropP [] (RReftV LocSymbol
 -> Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> (PredicateV LocSymbol -> RReftV LocSymbol)
-> PredicateV LocSymbol
-> Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateV LocSymbol -> RReftV LocSymbol
forall v. PredicateV v -> UReftV v (ReftV v)
predUReft (PredicateV LocSymbol
 -> Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> Parser (PredicateV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (PredicateV LocSymbol)
monoPredicate1P)
  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
forall v a. ParserV v a -> ParserV v a
braces ([((Symbol, RTypeV LocSymbol c BTyVar r), Symbol)]
-> ExprV LocSymbol
-> Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed
forall τ c.
[((Symbol, τ), Symbol)]
-> ExprV LocSymbol
-> Ref τ (RTypeV LocSymbol c BTyVar (RReftV LocSymbol))
bRProp ([((Symbol, RTypeV LocSymbol c BTyVar r), Symbol)]
 -> ExprV LocSymbol
 -> Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [((Symbol, RTypeV LocSymbol c BTyVar r), Symbol)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (ExprV LocSymbol
      -> Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [((Symbol, RTypeV LocSymbol c BTyVar r), Symbol)]
forall {r} {v} {c}.
Monoid r =>
StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [((Symbol, RTypeV v c BTyVar r), Symbol)]
symsP' StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (ExprV LocSymbol
   -> Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
refaP)
  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
-> [Char]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Ref (RTypeV LocSymbol c BTyVar r) BareTypeParsed)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"predicate1P"
   where
    symsP' :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [((Symbol, RTypeV v c BTyVar r), Symbol)]
symsP'       = do ss    <- Parser [(Symbol, RTypeV v c BTyVar r)]
forall r v c. Monoid r => Parser [(Symbol, RTypeV v c BTyVar r)]
symsP
                      fs    <- mapM refreshSym (fst <$> ss)
                      return $ zip ss fs
    refreshSym :: Symbol -> StateT (PStateV v) (Parsec Void [Char]) Symbol
refreshSym Symbol
s = Symbol -> Integer -> Symbol
forall a. Show a => Symbol -> a -> Symbol
intSymbol Symbol
s (Integer -> Symbol)
-> StateT (PStateV v) (Parsec Void [Char]) Integer
-> StateT (PStateV v) (Parsec Void [Char]) Symbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV v) (Parsec Void [Char]) Integer
forall v. ParserV v Integer
freshIntP

mmonoPredicateP :: Parser (PredicateV LocSymbol)
mmonoPredicateP :: Parser (PredicateV LocSymbol)
mmonoPredicateP
   = Parser (PredicateV LocSymbol) -> Parser (PredicateV LocSymbol)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser (PredicateV LocSymbol) -> Parser (PredicateV LocSymbol)
forall v a. ParserV v a -> ParserV v a
angles (Parser (PredicateV LocSymbol) -> Parser (PredicateV LocSymbol))
-> Parser (PredicateV LocSymbol) -> Parser (PredicateV LocSymbol)
forall a b. (a -> b) -> a -> b
$ Parser (PredicateV LocSymbol) -> Parser (PredicateV LocSymbol)
forall v a. ParserV v a -> ParserV v a
angles Parser (PredicateV LocSymbol)
monoPredicate1P)
  Parser (PredicateV LocSymbol)
-> Parser (PredicateV LocSymbol) -> Parser (PredicateV LocSymbol)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> PredicateV LocSymbol -> Parser (PredicateV LocSymbol)
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([UsedPVarV LocSymbol] -> PredicateV LocSymbol
forall v. [UsedPVarV v] -> PredicateV v
Pr [])
  Parser (PredicateV LocSymbol)
-> [Char] -> Parser (PredicateV LocSymbol)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"mmonoPredicateP"

monoPredicateP :: Parser (PredicateV LocSymbol)
monoPredicateP :: Parser (PredicateV LocSymbol)
monoPredicateP
   = Parser (PredicateV LocSymbol) -> Parser (PredicateV LocSymbol)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser (PredicateV LocSymbol) -> Parser (PredicateV LocSymbol)
forall v a. ParserV v a -> ParserV v a
angles Parser (PredicateV LocSymbol)
monoPredicate1P)
  Parser (PredicateV LocSymbol)
-> Parser (PredicateV LocSymbol) -> Parser (PredicateV LocSymbol)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> PredicateV LocSymbol -> Parser (PredicateV LocSymbol)
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([UsedPVarV LocSymbol] -> PredicateV LocSymbol
forall v. [UsedPVarV v] -> PredicateV v
Pr [])
  Parser (PredicateV LocSymbol)
-> [Char] -> Parser (PredicateV LocSymbol)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"monoPredicateP"

monoPredicate1P :: Parser (PredicateV LocSymbol)
monoPredicate1P :: Parser (PredicateV LocSymbol)
monoPredicate1P
   =  ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"True" ParserV LocSymbol ()
-> Parser (PredicateV LocSymbol) -> Parser (PredicateV LocSymbol)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> PredicateV LocSymbol -> Parser (PredicateV LocSymbol)
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([UsedPVarV LocSymbol] -> PredicateV LocSymbol
forall v. [UsedPVarV v] -> PredicateV v
Pr []))
  Parser (PredicateV LocSymbol)
-> Parser (PredicateV LocSymbol) -> Parser (PredicateV LocSymbol)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (PVarV LocSymbol [Char] -> PredicateV LocSymbol
forall v t. PVarV v t -> PredicateV v
pdVar (PVarV LocSymbol [Char] -> PredicateV LocSymbol)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (PVarV LocSymbol [Char])
-> Parser (PredicateV LocSymbol)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (PVarV LocSymbol [Char])
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (PVarV LocSymbol [Char])
forall v a. ParserV v a -> ParserV v a
parens StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (PVarV LocSymbol [Char])
predVarUseP)
  Parser (PredicateV LocSymbol)
-> Parser (PredicateV LocSymbol) -> Parser (PredicateV LocSymbol)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (PVarV LocSymbol [Char] -> PredicateV LocSymbol
forall v t. PVarV v t -> PredicateV v
pdVar (PVarV LocSymbol [Char] -> PredicateV LocSymbol)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (PVarV LocSymbol [Char])
-> Parser (PredicateV LocSymbol)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>        StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (PVarV LocSymbol [Char])
predVarUseP)
  Parser (PredicateV LocSymbol)
-> [Char] -> Parser (PredicateV LocSymbol)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"monoPredicate1P"

predVarUseP :: Parser (PVarV LocSymbol String)
predVarUseP :: StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (PVarV LocSymbol [Char])
predVarUseP
  = do (p, xs) <- Parser (Symbol, [ExprV LocSymbol])
funArgsP
       return   $ PV p dummyTyId dummySymbol [ (dummyTyId, dummySymbol, x) | x <- xs ]

funArgsP :: Parser (Symbol, [ExprV LocSymbol])
funArgsP :: Parser (Symbol, [ExprV LocSymbol])
funArgsP  = Parser (Symbol, [ExprV LocSymbol])
-> Parser (Symbol, [ExprV LocSymbol])
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser (Symbol, [ExprV LocSymbol])
forall {a}.
(ParseableV (Located a), Fixpoint a, Ord a) =>
StateT
  (PStateV (Located a)) (Parsec Void [Char]) (a, [ExprV (Located a)])
realP Parser (Symbol, [ExprV LocSymbol])
-> Parser (Symbol, [ExprV LocSymbol])
-> Parser (Symbol, [ExprV LocSymbol])
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Symbol, [ExprV LocSymbol])
forall {a}.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (Symbol, [a])
empP Parser (Symbol, [ExprV LocSymbol])
-> [Char] -> Parser (Symbol, [ExprV LocSymbol])
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"funArgsP"
  where
    empP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) (Symbol, [a])
empP  = (,[]) (Symbol -> (Symbol, [a]))
-> Parser Symbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Symbol, [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
predVarIdP
    realP :: StateT
  (PStateV (Located a)) (Parsec Void [Char]) (a, [ExprV (Located a)])
realP = do (EVar lp, xs) <- ExprV (Located a) -> (ExprV (Located a), [ExprV (Located a)])
forall v. ExprV v -> (ExprV v, [ExprV v])
splitEApp (ExprV (Located a) -> (ExprV (Located a), [ExprV (Located a)]))
-> StateT
     (PStateV (Located a)) (Parsec Void [Char]) (ExprV (Located a))
-> StateT
     (PStateV (Located a))
     (Parsec Void [Char])
     (ExprV (Located a), [ExprV (Located a)])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  (PStateV (Located a)) (Parsec Void [Char]) (ExprV (Located a))
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
funAppP
               return (val lp, xs)

boundP :: Parser (Bound (Located BareTypeParsed) (ExprV LocSymbol))
boundP :: Parser (Bound (Located BareTypeParsed) (ExprV LocSymbol))
boundP = do
  name   <- ParserV LocSymbol LocSymbol
forall v. ParserV v LocSymbol
locUpperIdP
  reservedOp "="
  vs      <- bvsP
  params' <- many (parens tyBindP)
  args    <- bargsP
  Bound name vs params' args <$> predP
 where
    bargsP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [(LocSymbol, Located BareTypeParsed)]
bargsP =     ( do [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"\\"
                      xs <- StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (LocSymbol, Located BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(LocSymbol, Located BareTypeParsed)]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (LocSymbol, Located BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (LocSymbol, Located BareTypeParsed)
forall v a. ParserV v a -> ParserV v a
parens StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (LocSymbol, Located BareTypeParsed)
tyBindP)
                      reservedOp  "->"
                      return xs
                 )
           StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [(LocSymbol, Located BareTypeParsed)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(LocSymbol, Located BareTypeParsed)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(LocSymbol, Located BareTypeParsed)]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [(LocSymbol, Located BareTypeParsed)]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(LocSymbol, Located BareTypeParsed)]
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []
           StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  [(LocSymbol, Located BareTypeParsed)]
-> [Char]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     [(LocSymbol, Located BareTypeParsed)]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bargsP"
    bvsP :: StateT
  (PStateV v)
  (Parsec Void [Char])
  [Located (RTypeV v c BTyVar (UReftV v (ReftV v)))]
bvsP   =     ( do [Char] -> ParserV v ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"forall"
                      xs <- StateT (PStateV v) (Parsec Void [Char]) (Located BTyVar)
-> StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (StateT (PStateV v) (Parsec Void [Char]) (Located BTyVar)
 -> StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar])
-> StateT (PStateV v) (Parsec Void [Char]) (Located BTyVar)
-> StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
forall a b. (a -> b) -> a -> b
$ do
                        ls <- ParserV v LocSymbol
forall v. ParserV v LocSymbol
locSymbolP
                        pure $ bTyVar ls <$ ls
                      reservedOp  "."
                      return (fmap (`RVar` trueURef) <$> xs)
                 )
           StateT
  (PStateV v)
  (Parsec Void [Char])
  [Located (RTypeV v c BTyVar (UReftV v (ReftV v)))]
-> StateT
     (PStateV v)
     (Parsec Void [Char])
     [Located (RTypeV v c BTyVar (UReftV v (ReftV v)))]
-> StateT
     (PStateV v)
     (Parsec Void [Char])
     [Located (RTypeV v c BTyVar (UReftV v (ReftV v)))]
forall a.
StateT (PStateV v) (Parsec Void [Char]) a
-> StateT (PStateV v) (Parsec Void [Char]) a
-> StateT (PStateV v) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Located (RTypeV v c BTyVar (UReftV v (ReftV v)))]
-> StateT
     (PStateV v)
     (Parsec Void [Char])
     [Located (RTypeV v c BTyVar (UReftV v (ReftV v)))]
forall a. a -> StateT (PStateV v) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []


infixGenP :: Assoc -> Parser ()
infixGenP :: Assoc -> ParserV LocSymbol ()
infixGenP Assoc
assoc = do
   p <- Parser (Maybe Int)
maybeDigit
   s <- infixIdP -- TODO: Andres: infixIdP was defined as many (satisfy (`notElem` [' ', '.'])) which does not make sense at all
   -- Andres: going via Symbol seems unnecessary and wasteful here
   addOperatorP (FInfix p (symbolString s) Nothing assoc)

infixP :: Parser ()
infixP :: ParserV LocSymbol ()
infixP = Assoc -> ParserV LocSymbol ()
infixGenP Assoc
AssocLeft

infixlP :: Parser ()
infixlP :: ParserV LocSymbol ()
infixlP = Assoc -> ParserV LocSymbol ()
infixGenP Assoc
AssocLeft

infixrP :: Parser ()
infixrP :: ParserV LocSymbol ()
infixrP = Assoc -> ParserV LocSymbol ()
infixGenP Assoc
AssocRight

maybeDigit :: Parser (Maybe Int)
maybeDigit :: Parser (Maybe Int)
maybeDigit
  = StateT (PStateV LocSymbol) (Parsec Void [Char]) Int
-> Parser (Maybe Int)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (StateT (PStateV LocSymbol) (Parsec Void [Char]) Int
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Int
forall v a. ParserV v a -> ParserV v a
lexeme ([Char] -> Int
forall a. Read a => [Char] -> a
read ([Char] -> Int) -> (Char -> [Char]) -> Char -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> [Char]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Char -> Int)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
digitChar))

------------------------------------------------------------------------
----------------------- Wrapped Constructors ---------------------------
------------------------------------------------------------------------

bRProp :: [((Symbol, τ), Symbol)]
       -> ExprV LocSymbol -> Ref τ (RTypeV LocSymbol c BTyVar (UReftV LocSymbol (ReftV LocSymbol)))
bRProp :: forall τ c.
[((Symbol, τ), Symbol)]
-> ExprV LocSymbol
-> Ref τ (RTypeV LocSymbol c BTyVar (RReftV LocSymbol))
bRProp []    ExprV LocSymbol
_    = Maybe SrcSpan
-> [Char] -> Ref τ (RTypeV LocSymbol c BTyVar (RReftV LocSymbol))
forall a. HasCallStack => Maybe SrcSpan -> [Char] -> a
panic Maybe SrcSpan
forall {a}. Maybe a
Nothing [Char]
"Parse.bRProp empty list"
bRProp [((Symbol, τ), Symbol)]
syms' ExprV LocSymbol
epr  = [(Symbol, τ)]
-> RTypeV LocSymbol c BTyVar (RReftV LocSymbol)
-> Ref τ (RTypeV LocSymbol c BTyVar (RReftV LocSymbol))
forall τ t. [(Symbol, τ)] -> t -> Ref τ t
RProp [(Symbol, τ)]
ss (RTypeV LocSymbol c BTyVar (RReftV LocSymbol)
 -> Ref τ (RTypeV LocSymbol c BTyVar (RReftV LocSymbol)))
-> RTypeV LocSymbol c BTyVar (RReftV LocSymbol)
-> Ref τ (RTypeV LocSymbol c BTyVar (RReftV LocSymbol))
forall a b. (a -> b) -> a -> b
$ BTyVar
-> PredicateV LocSymbol
-> ReftV LocSymbol
-> RTypeV LocSymbol c BTyVar (RReftV LocSymbol)
forall tv v r c.
tv -> PredicateV v -> r -> RTypeV v c tv (UReftV v r)
bRVar (LocSymbol -> BTyVar
BTV (LocSymbol -> BTyVar) -> LocSymbol -> BTyVar
forall a b. (a -> b) -> a -> b
$ Symbol -> LocSymbol
forall a. a -> Located a
dummyLoc Symbol
dummyName) ([UsedPVarV LocSymbol] -> PredicateV LocSymbol
forall v. [UsedPVarV v] -> PredicateV v
Pr []) ReftV LocSymbol
r
  where
    ([(Symbol, τ)]
ss, (Symbol
v, τ
_))  = ([(Symbol, τ)] -> [(Symbol, τ)]
forall a. HasCallStack => [a] -> [a]
init [(Symbol, τ)]
symsf, [(Symbol, τ)] -> (Symbol, τ)
forall a. HasCallStack => [a] -> a
last [(Symbol, τ)]
symsf)
    symsf :: [(Symbol, τ)]
symsf         = [(Symbol
y, τ
s) | ((Symbol
_, τ
s), Symbol
y) <- [((Symbol, τ), Symbol)]
syms']
    su :: SubstV LocSymbol
su            = [(Symbol, ExprV LocSymbol)] -> SubstV LocSymbol
mkSubstLocSymbol [(Symbol
x, LocSymbol -> ExprV LocSymbol
forall v. v -> ExprV v
EVar (LocSymbol -> ExprV LocSymbol) -> LocSymbol -> ExprV LocSymbol
forall a b. (a -> b) -> a -> b
$ Symbol -> LocSymbol
forall a. a -> Located a
dummyLoc Symbol
y) | ((Symbol
x, τ
_), Symbol
y) <- [((Symbol, τ), Symbol)]
syms', Symbol
x Symbol -> Symbol -> Bool
forall a. Eq a => a -> a -> Bool
/= Symbol
v]
    r :: ReftV LocSymbol
r             = (Symbol, ExprV LocSymbol) -> ReftV LocSymbol
forall v. (Symbol, ExprV v) -> ReftV v
Reft (Symbol
v, (LocSymbol -> Symbol)
-> SubstV LocSymbol -> ExprV LocSymbol -> ExprV LocSymbol
forall v. (v -> Symbol) -> SubstV v -> ExprV v -> ExprV v
substExprV LocSymbol -> Symbol
forall a. Located a -> a
val SubstV LocSymbol
su ExprV LocSymbol
epr)

mkSubstLocSymbol :: [(Symbol, ExprV LocSymbol)] -> SubstV LocSymbol
mkSubstLocSymbol :: [(Symbol, ExprV LocSymbol)] -> SubstV LocSymbol
mkSubstLocSymbol = HashMap Symbol (ExprV LocSymbol) -> SubstV LocSymbol
forall v. HashMap Symbol (ExprV v) -> SubstV v
Su (HashMap Symbol (ExprV LocSymbol) -> SubstV LocSymbol)
-> ([(Symbol, ExprV LocSymbol)]
    -> HashMap Symbol (ExprV LocSymbol))
-> [(Symbol, ExprV LocSymbol)]
-> SubstV LocSymbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Symbol, ExprV LocSymbol)] -> HashMap Symbol (ExprV LocSymbol)
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList ([(Symbol, ExprV LocSymbol)] -> HashMap Symbol (ExprV LocSymbol))
-> ([(Symbol, ExprV LocSymbol)] -> [(Symbol, ExprV LocSymbol)])
-> [(Symbol, ExprV LocSymbol)]
-> HashMap Symbol (ExprV LocSymbol)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Symbol, ExprV LocSymbol)] -> [(Symbol, ExprV LocSymbol)]
forall a. [a] -> [a]
reverse ([(Symbol, ExprV LocSymbol)] -> [(Symbol, ExprV LocSymbol)])
-> ([(Symbol, ExprV LocSymbol)] -> [(Symbol, ExprV LocSymbol)])
-> [(Symbol, ExprV LocSymbol)]
-> [(Symbol, ExprV LocSymbol)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Symbol, ExprV LocSymbol) -> Bool)
-> [(Symbol, ExprV LocSymbol)] -> [(Symbol, ExprV LocSymbol)]
forall a. (a -> Bool) -> [a] -> [a]
filter (Symbol, ExprV LocSymbol) -> Bool
forall {a}. Eq a => (a, ExprV (Located a)) -> Bool
notTrivial
  where
    notTrivial :: (a, ExprV (Located a)) -> Bool
notTrivial (a
x, EVar Located a
y) = a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
/= Located a -> a
forall a. Located a -> a
val Located a
y
    notTrivial (a, ExprV (Located a))
_           = Bool
True

bRVar :: tv -> PredicateV v -> r -> RTypeV v c tv (UReftV v r)
bRVar :: forall tv v r c.
tv -> PredicateV v -> r -> RTypeV v c tv (UReftV v r)
bRVar tv
α PredicateV v
p r
r = tv -> UReftV v r -> RTypeV v c tv (UReftV v r)
forall v c tv r. tv -> r -> RTypeV v c tv r
RVar tv
α (r -> PredicateV v -> UReftV v r
forall v r. r -> PredicateV v -> UReftV v r
MkUReft r
r PredicateV v
p)

bLst :: Maybe (RTypeV v BTyCon tv (UReftV v r))
     -> [RTPropV v BTyCon tv (UReftV v r)]
     -> r
     -> RTypeV v BTyCon tv (UReftV v r)
bLst :: forall v tv r.
Maybe (RTypeV v BTyCon tv (UReftV v r))
-> [RTPropV v BTyCon tv (UReftV v r)]
-> r
-> RTypeV v BTyCon tv (UReftV v r)
bLst (Just RTypeV v BTyCon tv (UReftV v r)
t) [RTPropV v BTyCon tv (UReftV v r)]
rs r
r = BTyCon
-> [RTypeV v BTyCon tv (UReftV v r)]
-> [RTPropV v BTyCon tv (UReftV v r)]
-> UReftV v r
-> RTypeV v BTyCon tv (UReftV v r)
forall v c tv r.
c
-> [RTypeV v c tv r] -> [RTPropV v c tv r] -> r -> RTypeV v c tv r
RApp (Located LHName -> BTyCon
mkBTyCon (Located LHName -> BTyCon) -> Located LHName -> BTyCon
forall a b. (a -> b) -> a -> b
$ LHName -> Located LHName
forall a. a -> Located a
dummyLoc (LHName -> Located LHName) -> LHName -> Located LHName
forall a b. (a -> b) -> a -> b
$ LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName LHNameSpace
LHTcName Symbol
listConName) [RTypeV v BTyCon tv (UReftV v r)
t] [RTPropV v BTyCon tv (UReftV v r)]
rs (r -> UReftV v r
forall r v. r -> UReftV v r
reftUReft r
r)
bLst Maybe (RTypeV v BTyCon tv (UReftV v r))
Nothing  [RTPropV v BTyCon tv (UReftV v r)]
rs r
r = BTyCon
-> [RTypeV v BTyCon tv (UReftV v r)]
-> [RTPropV v BTyCon tv (UReftV v r)]
-> UReftV v r
-> RTypeV v BTyCon tv (UReftV v r)
forall v c tv r.
c
-> [RTypeV v c tv r] -> [RTPropV v c tv r] -> r -> RTypeV v c tv r
RApp (Located LHName -> BTyCon
mkBTyCon (Located LHName -> BTyCon) -> Located LHName -> BTyCon
forall a b. (a -> b) -> a -> b
$ LHName -> Located LHName
forall a. a -> Located a
dummyLoc (LHName -> Located LHName) -> LHName -> Located LHName
forall a b. (a -> b) -> a -> b
$ LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName LHNameSpace
LHTcName Symbol
listConName) []  [RTPropV v BTyCon tv (UReftV v r)]
rs (r -> UReftV v r
forall r v. r -> UReftV v r
reftUReft r
r)

bTup :: [(Maybe Symbol, BareTypeParsed)]
     -> [RTPropV LocSymbol BTyCon BTyVar (UReftV LocSymbol (ReftV LocSymbol))]
     -> ReftV LocSymbol
     -> BareTypeParsed
bTup :: [(Maybe Symbol, BareTypeParsed)]
-> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> ReftV LocSymbol
-> BareTypeParsed
bTup [(Maybe Symbol
_,BareTypeParsed
t)] [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
_ ReftV LocSymbol
r
  | ReftV Symbol -> Bool
forall r. Reftable r => r -> Bool
isTauto ((LocSymbol -> Symbol) -> ReftV LocSymbol -> ReftV Symbol
forall a b. (a -> b) -> ReftV a -> ReftV b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> Symbol
forall a. Located a -> a
val ReftV LocSymbol
r)  = BareTypeParsed
t
  | Bool
otherwise  = BareTypeParsed
t BareTypeParsed -> RReftV LocSymbol -> BareTypeParsed
`strengthenUReft` ReftV LocSymbol -> RReftV LocSymbol
forall r v. r -> UReftV v r
reftUReft ReftV LocSymbol
r
bTup [(Maybe Symbol, BareTypeParsed)]
ts [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
rs ReftV LocSymbol
r
  | (Maybe Symbol -> Bool) -> [Maybe Symbol] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Maybe Symbol -> Bool
forall a. Maybe a -> Bool
Mb.isNothing ((Maybe Symbol, BareTypeParsed) -> Maybe Symbol
forall a b. (a, b) -> a
fst ((Maybe Symbol, BareTypeParsed) -> Maybe Symbol)
-> [(Maybe Symbol, BareTypeParsed)] -> [Maybe Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Maybe Symbol, BareTypeParsed)]
ts) Bool -> Bool -> Bool
|| [(Maybe Symbol, BareTypeParsed)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Maybe Symbol, BareTypeParsed)]
ts Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
2
  = BTyCon
-> [BareTypeParsed]
-> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> RReftV LocSymbol
-> BareTypeParsed
forall v c tv r.
c
-> [RTypeV v c tv r] -> [RTPropV v c tv r] -> r -> RTypeV v c tv r
RApp
      (Located LHName -> BTyCon
mkBTyCon (Located LHName -> BTyCon) -> Located LHName -> BTyCon
forall a b. (a -> b) -> a -> b
$ LHName -> Located LHName
forall a. a -> Located a
dummyLoc (LHName -> Located LHName) -> LHName -> Located LHName
forall a b. (a -> b) -> a -> b
$ LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName LHNameSpace
LHTcName (Symbol -> LHName) -> Symbol -> LHName
forall a b. (a -> b) -> a -> b
$ [Char] -> Symbol
forall a. IsString a => [Char] -> a
fromString ([Char] -> Symbol) -> [Char] -> Symbol
forall a b. (a -> b) -> a -> b
$ [Char]
"Tuple" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show ([(Maybe Symbol, BareTypeParsed)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Maybe Symbol, BareTypeParsed)]
ts))
      ((Maybe Symbol, BareTypeParsed) -> BareTypeParsed
forall a b. (a, b) -> b
snd ((Maybe Symbol, BareTypeParsed) -> BareTypeParsed)
-> [(Maybe Symbol, BareTypeParsed)] -> [BareTypeParsed]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Maybe Symbol, BareTypeParsed)]
ts) [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
rs (ReftV LocSymbol -> RReftV LocSymbol
forall r v. r -> UReftV v r
reftUReft ReftV LocSymbol
r)
  | Bool
otherwise
  = BTyCon
-> [BareTypeParsed]
-> [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
-> RReftV LocSymbol
-> BareTypeParsed
forall v c tv r.
c
-> [RTypeV v c tv r] -> [RTPropV v c tv r] -> r -> RTypeV v c tv r
RApp
      (Located LHName -> BTyCon
mkBTyCon (Located LHName -> BTyCon) -> Located LHName -> BTyCon
forall a b. (a -> b) -> a -> b
$ LHName -> Located LHName
forall a. a -> Located a
dummyLoc (LHName -> Located LHName) -> LHName -> Located LHName
forall a b. (a -> b) -> a -> b
$ LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName LHNameSpace
LHTcName (Symbol -> LHName) -> Symbol -> LHName
forall a b. (a -> b) -> a -> b
$ [Char] -> Symbol
forall a. IsString a => [Char] -> a
fromString ([Char] -> Symbol) -> [Char] -> Symbol
forall a b. (a -> b) -> a -> b
$ [Char]
"Tuple" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show ([(Maybe Symbol, BareTypeParsed)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Maybe Symbol, BareTypeParsed)]
ts))
      ((RReftV LocSymbol -> RReftV LocSymbol)
-> BareTypeParsed -> BareTypeParsed
forall r1 r2 v c tv.
(r1 -> r2) -> RTypeV v c tv r1 -> RTypeV v c tv r2
mapReft (RReftV LocSymbol -> RReftV LocSymbol -> RReftV LocSymbol
forall a b. a -> b -> a
const RReftV LocSymbol
forall v. UReftV v (ReftV v)
trueURef) (BareTypeParsed -> BareTypeParsed)
-> ((Maybe Symbol, BareTypeParsed) -> BareTypeParsed)
-> (Maybe Symbol, BareTypeParsed)
-> BareTypeParsed
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Symbol, BareTypeParsed) -> BareTypeParsed
forall a b. (a, b) -> b
snd ((Maybe Symbol, BareTypeParsed) -> BareTypeParsed)
-> [(Maybe Symbol, BareTypeParsed)] -> [BareTypeParsed]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Maybe Symbol, BareTypeParsed)]
ts)
      [RTPropV LocSymbol BTyCon BTyVar (RReftV LocSymbol)]
forall {r2}.
Monoid r2 =>
[Ref (RTypeV LocSymbol BTyCon BTyVar r2) BareTypeParsed]
rs'
      (ReftV LocSymbol -> RReftV LocSymbol
forall r v. r -> UReftV v r
reftUReft ReftV LocSymbol
r)
  where
    args :: [(Symbol, RTypeV LocSymbol BTyCon BTyVar r2)]
args       = [(Symbol -> Maybe Symbol -> Symbol
forall a. a -> Maybe a -> a
Mb.fromMaybe Symbol
dummySymbol Maybe Symbol
x, (RReftV LocSymbol -> r2)
-> BareTypeParsed -> RTypeV LocSymbol BTyCon BTyVar r2
forall r1 r2 v c tv.
(r1 -> r2) -> RTypeV v c tv r1 -> RTypeV v c tv r2
mapReft RReftV LocSymbol -> r2
forall a. Monoid a => a
mempty BareTypeParsed
t) | (Maybe Symbol
x,BareTypeParsed
t) <- [(Maybe Symbol, BareTypeParsed)]
ts]
    makeProp :: Int -> Ref (RTypeV LocSymbol BTyCon BTyVar r2) BareTypeParsed
makeProp Int
i = [(Symbol, RTypeV LocSymbol BTyCon BTyVar r2)]
-> BareTypeParsed
-> Ref (RTypeV LocSymbol BTyCon BTyVar r2) BareTypeParsed
forall τ t. [(Symbol, τ)] -> t -> Ref τ t
RProp ([(Symbol, RTypeV LocSymbol BTyCon BTyVar r2)]
-> [(Symbol, RTypeV LocSymbol BTyCon BTyVar r2)]
forall a. [a] -> [a]
reverse ([(Symbol, RTypeV LocSymbol BTyCon BTyVar r2)]
 -> [(Symbol, RTypeV LocSymbol BTyCon BTyVar r2)])
-> [(Symbol, RTypeV LocSymbol BTyCon BTyVar r2)]
-> [(Symbol, RTypeV LocSymbol BTyCon BTyVar r2)]
forall a b. (a -> b) -> a -> b
$ Int
-> [(Symbol, RTypeV LocSymbol BTyCon BTyVar r2)]
-> [(Symbol, RTypeV LocSymbol BTyCon BTyVar r2)]
forall a. Int -> [a] -> [a]
take Int
i [(Symbol, RTypeV LocSymbol BTyCon BTyVar r2)]
forall {r2}.
Monoid r2 =>
[(Symbol, RTypeV LocSymbol BTyCon BTyVar r2)]
args) (((Maybe Symbol, BareTypeParsed) -> BareTypeParsed
forall a b. (a, b) -> b
snd ((Maybe Symbol, BareTypeParsed) -> BareTypeParsed)
-> [(Maybe Symbol, BareTypeParsed)] -> [BareTypeParsed]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Maybe Symbol, BareTypeParsed)]
ts)[BareTypeParsed] -> Int -> BareTypeParsed
forall a. HasCallStack => [a] -> Int -> a
!!Int
i)
    rs' :: [Ref (RTypeV LocSymbol BTyCon BTyVar r2) BareTypeParsed]
rs'        = Int -> Ref (RTypeV LocSymbol BTyCon BTyVar r2) BareTypeParsed
forall {r2}.
Monoid r2 =>
Int -> Ref (RTypeV LocSymbol BTyCon BTyVar r2) BareTypeParsed
makeProp (Int -> Ref (RTypeV LocSymbol BTyCon BTyVar r2) BareTypeParsed)
-> [Int]
-> [Ref (RTypeV LocSymbol BTyCon BTyVar r2) BareTypeParsed]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Int
1..([(Maybe Symbol, BareTypeParsed)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Maybe Symbol, BareTypeParsed)]
tsInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)]


-- Temporarily restore this hack benchmarks/esop2013-submission/Array.hs fails
-- w/o it
-- TODO RApp Int [] [p] true should be syntactically different than RApp Int [] [] p
-- bCon b s [RProp _ (RHole r1)] [] _ r = RApp b [] [] $ r1 `meet` (MkUReft r mempty s)
bCon :: c
     -> [RTPropV v c tv (UReftV v r)]
     -> [RTypeV v c tv (UReftV v r)]
     -> PredicateV v
     -> r
     -> RTypeV v c tv (UReftV v r)
bCon :: forall c v tv r.
c
-> [RTPropV v c tv (UReftV v r)]
-> [RTypeV v c tv (UReftV v r)]
-> PredicateV v
-> r
-> RTypeV v c tv (UReftV v r)
bCon c
b [RTPropV v c tv (UReftV v r)]
rs [RTypeV v c tv (UReftV v r)]
ts PredicateV v
p r
r = c
-> [RTypeV v c tv (UReftV v r)]
-> [RTPropV v c tv (UReftV v r)]
-> UReftV v r
-> RTypeV v c tv (UReftV v r)
forall v c tv r.
c
-> [RTypeV v c tv r] -> [RTPropV v c tv r] -> r -> RTypeV v c tv r
RApp c
b [RTypeV v c tv (UReftV v r)]
ts [RTPropV v c tv (UReftV v r)]
rs (UReftV v r -> RTypeV v c tv (UReftV v r))
-> UReftV v r -> RTypeV v c tv (UReftV v r)
forall a b. (a -> b) -> a -> b
$ r -> PredicateV v -> UReftV v r
forall v r. r -> PredicateV v -> UReftV v r
MkUReft r
r PredicateV v
p

bAppTy :: Foldable t => BTyVar -> t BareTypeParsed -> ReftV LocSymbol -> BareTypeParsed
bAppTy :: forall (t :: * -> *).
Foldable t =>
BTyVar -> t BareTypeParsed -> ReftV LocSymbol -> BareTypeParsed
bAppTy BTyVar
v t BareTypeParsed
ts ReftV LocSymbol
r  = BareTypeParsed -> RReftV LocSymbol -> BareTypeParsed
strengthenUReft BareTypeParsed
ts' (ReftV LocSymbol -> RReftV LocSymbol
forall r v. r -> UReftV v r
reftUReft ReftV LocSymbol
r)
  where
    ts' :: BareTypeParsed
ts'        = (BareTypeParsed -> BareTypeParsed -> BareTypeParsed)
-> BareTypeParsed -> t BareTypeParsed -> BareTypeParsed
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\BareTypeParsed
a BareTypeParsed
b -> BareTypeParsed
-> BareTypeParsed -> RReftV LocSymbol -> BareTypeParsed
forall v c tv r.
RTypeV v c tv r -> RTypeV v c tv r -> r -> RTypeV v c tv r
RAppTy BareTypeParsed
a BareTypeParsed
b (ReftV LocSymbol -> RReftV LocSymbol
forall r v. r -> UReftV v r
uTop ReftV LocSymbol
forall v. ReftV v
trueReft)) (BTyVar -> RReftV LocSymbol -> BareTypeParsed
forall v c tv r. tv -> r -> RTypeV v c tv r
RVar BTyVar
v (ReftV LocSymbol -> RReftV LocSymbol
forall r v. r -> UReftV v r
uTop ReftV LocSymbol
forall v. ReftV v
trueReft)) t BareTypeParsed
ts

strengthenUReft
  :: BareTypeParsed -> UReftV LocSymbol (ReftV LocSymbol) -> BareTypeParsed
strengthenUReft :: BareTypeParsed -> RReftV LocSymbol -> BareTypeParsed
strengthenUReft = (RReftV LocSymbol -> RReftV LocSymbol -> RReftV LocSymbol)
-> BareTypeParsed -> RReftV LocSymbol -> BareTypeParsed
forall r v c tv.
(r -> r -> r) -> RTypeV v c tv r -> r -> RTypeV v c tv r
strengthenWith RReftV LocSymbol -> RReftV LocSymbol -> RReftV LocSymbol
forall {v}.
UReftV v (ReftV LocSymbol)
-> UReftV v (ReftV LocSymbol) -> UReftV v (ReftV LocSymbol)
meetUReft
  where
    meetUReft :: UReftV v (ReftV LocSymbol)
-> UReftV v (ReftV LocSymbol) -> UReftV v (ReftV LocSymbol)
meetUReft (MkUReft ReftV LocSymbol
r0 (Pr [UsedPVarV v]
p0)) (MkUReft ReftV LocSymbol
r1 (Pr [UsedPVarV v]
p1)) =
       ReftV LocSymbol -> PredicateV v -> UReftV v (ReftV LocSymbol)
forall v r. r -> PredicateV v -> UReftV v r
MkUReft (ReftV LocSymbol -> ReftV LocSymbol -> ReftV LocSymbol
meetReftV ReftV LocSymbol
r0 ReftV LocSymbol
r1) ([UsedPVarV v] -> PredicateV v
forall v. [UsedPVarV v] -> PredicateV v
Pr ([UsedPVarV v] -> PredicateV v) -> [UsedPVarV v] -> PredicateV v
forall a b. (a -> b) -> a -> b
$ [UsedPVarV v]
p0 [UsedPVarV v] -> [UsedPVarV v] -> [UsedPVarV v]
forall a. Semigroup a => a -> a -> a
<> [UsedPVarV v]
p1)

    meetReftV :: ReftV LocSymbol -> ReftV LocSymbol -> ReftV LocSymbol
    meetReftV :: ReftV LocSymbol -> ReftV LocSymbol -> ReftV LocSymbol
meetReftV (Reft (Symbol
v, ExprV LocSymbol
ra)) (Reft (Symbol
v', ExprV LocSymbol
ra'))
      | Symbol
v Symbol -> Symbol -> Bool
forall a. Eq a => a -> a -> Bool
== Symbol
v'          = (Symbol, ExprV LocSymbol) -> ReftV LocSymbol
forall v. (Symbol, ExprV v) -> ReftV v
Reft (Symbol
v , [ExprV LocSymbol] -> ExprV LocSymbol
forall v. (Fixpoint v, Ord v) => ListNE (ExprV v) -> ExprV v
pAnd [ExprV LocSymbol
ra, ExprV LocSymbol
ra'])
      | Symbol
v Symbol -> Symbol -> Bool
forall a. Eq a => a -> a -> Bool
== Symbol
dummySymbol = (Symbol, ExprV LocSymbol) -> ReftV LocSymbol
forall v. (Symbol, ExprV v) -> ReftV v
Reft (Symbol
v', [ExprV LocSymbol] -> ExprV LocSymbol
forall v. (Fixpoint v, Ord v) => ListNE (ExprV v) -> ExprV v
pAnd [ExprV LocSymbol
ra', (LocSymbol -> Symbol)
-> SubstV LocSymbol -> ExprV LocSymbol -> ExprV LocSymbol
forall v. (v -> Symbol) -> SubstV v -> ExprV v -> ExprV v
substExprV LocSymbol -> Symbol
forall a. Located a -> a
val (HashMap Symbol (ExprV LocSymbol) -> SubstV LocSymbol
forall v. HashMap Symbol (ExprV v) -> SubstV v
Su (HashMap Symbol (ExprV LocSymbol) -> SubstV LocSymbol)
-> HashMap Symbol (ExprV LocSymbol) -> SubstV LocSymbol
forall a b. (a -> b) -> a -> b
$ [(Symbol, ExprV LocSymbol)] -> HashMap Symbol (ExprV LocSymbol)
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList [(Symbol
v , LocSymbol -> ExprV LocSymbol
forall v. v -> ExprV v
EVar (Symbol -> LocSymbol
forall a. a -> Located a
dummyLoc Symbol
v'))]) ExprV LocSymbol
ra])
      | Bool
otherwise        = (Symbol, ExprV LocSymbol) -> ReftV LocSymbol
forall v. (Symbol, ExprV v) -> ReftV v
Reft (Symbol
v , [ExprV LocSymbol] -> ExprV LocSymbol
forall v. (Fixpoint v, Ord v) => ListNE (ExprV v) -> ExprV v
pAnd [ExprV LocSymbol
ra, (LocSymbol -> Symbol)
-> SubstV LocSymbol -> ExprV LocSymbol -> ExprV LocSymbol
forall v. (v -> Symbol) -> SubstV v -> ExprV v -> ExprV v
substExprV LocSymbol -> Symbol
forall a. Located a -> a
val (HashMap Symbol (ExprV LocSymbol) -> SubstV LocSymbol
forall v. HashMap Symbol (ExprV v) -> SubstV v
Su (HashMap Symbol (ExprV LocSymbol) -> SubstV LocSymbol)
-> HashMap Symbol (ExprV LocSymbol) -> SubstV LocSymbol
forall a b. (a -> b) -> a -> b
$ [(Symbol, ExprV LocSymbol)] -> HashMap Symbol (ExprV LocSymbol)
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList [(Symbol
v', LocSymbol -> ExprV LocSymbol
forall v. v -> ExprV v
EVar (Symbol -> LocSymbol
forall a. a -> Located a
dummyLoc Symbol
v))]) ExprV LocSymbol
ra'])

substExprV :: (v -> Symbol) -> SubstV v -> ExprV v -> ExprV v
substExprV :: forall v. (v -> Symbol) -> SubstV v -> ExprV v -> ExprV v
substExprV v -> Symbol
toSym SubstV v
su0 = ExprV v -> ExprV v
go
  where
    go :: ExprV v -> ExprV v
go (EApp ExprV v
f ExprV v
e) = ExprV v -> ExprV v -> ExprV v
forall v. ExprV v -> ExprV v -> ExprV v
EApp (ExprV v -> ExprV v
go ExprV v
f) (ExprV v -> ExprV v
go ExprV v
e)
    go (ELam (Symbol, Sort)
x ExprV v
e) = (Symbol, Sort) -> ExprV v -> ExprV v
forall v. (Symbol, Sort) -> ExprV v -> ExprV v
ELam (Symbol, Sort)
x ((v -> Symbol) -> SubstV v -> ExprV v -> ExprV v
forall v. (v -> Symbol) -> SubstV v -> ExprV v -> ExprV v
substExprV v -> Symbol
toSym (SubstV v -> Symbol -> SubstV v
forall {v}. SubstV v -> Symbol -> SubstV v
removeSubst SubstV v
su0 ((Symbol, Sort) -> Symbol
forall a b. (a, b) -> a
fst (Symbol, Sort)
x)) ExprV v
e)
    go (ECoerc Sort
a Sort
t ExprV v
e) = Sort -> Sort -> ExprV v -> ExprV v
forall v. Sort -> Sort -> ExprV v -> ExprV v
ECoerc Sort
a Sort
t (ExprV v -> ExprV v
go ExprV v
e)
    go (ENeg ExprV v
e) = ExprV v -> ExprV v
forall v. ExprV v -> ExprV v
ENeg (ExprV v -> ExprV v
go ExprV v
e)
    go (EBin Bop
op ExprV v
e1 ExprV v
e2) = Bop -> ExprV v -> ExprV v -> ExprV v
forall v. Bop -> ExprV v -> ExprV v -> ExprV v
EBin Bop
op (ExprV v -> ExprV v
go ExprV v
e1) (ExprV v -> ExprV v
go ExprV v
e2)
    go (EIte ExprV v
p ExprV v
e1 ExprV v
e2) = ExprV v -> ExprV v -> ExprV v -> ExprV v
forall v. ExprV v -> ExprV v -> ExprV v -> ExprV v
EIte (ExprV v -> ExprV v
go ExprV v
p) (ExprV v -> ExprV v
go ExprV v
e1) (ExprV v -> ExprV v
go ExprV v
e2)
    go (ECst ExprV v
e Sort
so) = ExprV v -> Sort -> ExprV v
forall v. ExprV v -> Sort -> ExprV v
ECst (ExprV v -> ExprV v
go ExprV v
e) Sort
so
    go (EVar v
x) = SubstV v -> v -> ExprV v
appSubst SubstV v
su0 v
x
    go (PAnd [ExprV v]
ps) = [ExprV v] -> ExprV v
forall v. [ExprV v] -> ExprV v
PAnd ([ExprV v] -> ExprV v) -> [ExprV v] -> ExprV v
forall a b. (a -> b) -> a -> b
$ (ExprV v -> ExprV v) -> [ExprV v] -> [ExprV v]
forall a b. (a -> b) -> [a] -> [b]
map ExprV v -> ExprV v
go [ExprV v]
ps
    go (POr  [ExprV v]
ps) = [ExprV v] -> ExprV v
forall v. [ExprV v] -> ExprV v
POr ([ExprV v] -> ExprV v) -> [ExprV v] -> ExprV v
forall a b. (a -> b) -> a -> b
$ (ExprV v -> ExprV v) -> [ExprV v] -> [ExprV v]
forall a b. (a -> b) -> [a] -> [b]
map ExprV v -> ExprV v
go [ExprV v]
ps
    go (PNot ExprV v
p) = ExprV v -> ExprV v
forall v. ExprV v -> ExprV v
PNot (ExprV v -> ExprV v
go ExprV v
p)
    go (PImp ExprV v
p1 ExprV v
p2) = ExprV v -> ExprV v -> ExprV v
forall v. ExprV v -> ExprV v -> ExprV v
PImp (ExprV v -> ExprV v
go ExprV v
p1) (ExprV v -> ExprV v
go ExprV v
p2)
    go (PIff ExprV v
p1 ExprV v
p2) = ExprV v -> ExprV v -> ExprV v
forall v. ExprV v -> ExprV v -> ExprV v
PIff (ExprV v -> ExprV v
go ExprV v
p1) (ExprV v -> ExprV v
go ExprV v
p2)
    go (PAtom Brel
r ExprV v
e1 ExprV v
e2) = Brel -> ExprV v -> ExprV v -> ExprV v
forall v. Brel -> ExprV v -> ExprV v -> ExprV v
PAtom Brel
r (ExprV v -> ExprV v
go ExprV v
e1) (ExprV v -> ExprV v
go ExprV v
e2)
    go (PKVar KVar
k SubstV v
su') = KVar -> SubstV v -> ExprV v
forall v. KVar -> SubstV v -> ExprV v
PKVar KVar
k (SubstV v -> ExprV v) -> SubstV v -> ExprV v
forall a b. (a -> b) -> a -> b
$ SubstV v
su' SubstV v -> SubstV v -> SubstV v
`appendSubst` SubstV v
su0
    go (PGrad KVar
k SubstV v
su' GradInfo
i ExprV v
e) = KVar -> SubstV v -> GradInfo -> ExprV v -> ExprV v
forall v. KVar -> SubstV v -> GradInfo -> ExprV v -> ExprV v
PGrad KVar
k (SubstV v
su' SubstV v -> SubstV v -> SubstV v
`appendSubst` SubstV v
su0) GradInfo
i (ExprV v -> ExprV v
go ExprV v
e)
    go (PAll [(Symbol, Sort)]
_ ExprV v
_) = Maybe SrcSpan -> [Char] -> ExprV v
forall a. HasCallStack => Maybe SrcSpan -> [Char] -> a
panic Maybe SrcSpan
forall {a}. Maybe a
Nothing [Char]
"substExprV: PAll"
    go (PExist [(Symbol, Sort)]
_ ExprV v
_) = Maybe SrcSpan -> [Char] -> ExprV v
forall a. HasCallStack => Maybe SrcSpan -> [Char] -> a
panic Maybe SrcSpan
forall {a}. Maybe a
Nothing [Char]
"substExprV: PExist"
    go ExprV v
p = ExprV v
p

    appSubst :: SubstV v -> v -> ExprV v
appSubst (Su HashMap Symbol (ExprV v)
s) v
x = ExprV v -> Maybe (ExprV v) -> ExprV v
forall a. a -> Maybe a -> a
Mb.fromMaybe (v -> ExprV v
forall v. v -> ExprV v
EVar v
x) (Symbol -> HashMap Symbol (ExprV v) -> Maybe (ExprV v)
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup (v -> Symbol
toSym v
x) HashMap Symbol (ExprV v)
s)

    removeSubst :: SubstV v -> Symbol -> SubstV v
removeSubst (Su HashMap Symbol (ExprV v)
su) Symbol
x = HashMap Symbol (ExprV v) -> SubstV v
forall v. HashMap Symbol (ExprV v) -> SubstV v
Su (HashMap Symbol (ExprV v) -> SubstV v)
-> HashMap Symbol (ExprV v) -> SubstV v
forall a b. (a -> b) -> a -> b
$ Symbol -> HashMap Symbol (ExprV v) -> HashMap Symbol (ExprV v)
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> HashMap k v
M.delete Symbol
x HashMap Symbol (ExprV v)
su

    appendSubst :: SubstV v -> SubstV v -> SubstV v
appendSubst (Su HashMap Symbol (ExprV v)
s1) θ2 :: SubstV v
θ2@(Su HashMap Symbol (ExprV v)
s2) = HashMap Symbol (ExprV v) -> SubstV v
forall v. HashMap Symbol (ExprV v) -> SubstV v
Su (HashMap Symbol (ExprV v) -> SubstV v)
-> HashMap Symbol (ExprV v) -> SubstV v
forall a b. (a -> b) -> a -> b
$ HashMap Symbol (ExprV v)
-> HashMap Symbol (ExprV v) -> HashMap Symbol (ExprV v)
forall k v. Eq k => HashMap k v -> HashMap k v -> HashMap k v
M.union HashMap Symbol (ExprV v)
s1' HashMap Symbol (ExprV v)
s2
      where
        s1' :: HashMap Symbol (ExprV v)
s1' = (v -> Symbol) -> SubstV v -> ExprV v -> ExprV v
forall v. (v -> Symbol) -> SubstV v -> ExprV v -> ExprV v
substExprV v -> Symbol
toSym SubstV v
θ2 (ExprV v -> ExprV v)
-> HashMap Symbol (ExprV v) -> HashMap Symbol (ExprV v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HashMap Symbol (ExprV v)
s1


reftUReft :: r -> UReftV v r
reftUReft :: forall r v. r -> UReftV v r
reftUReft r
r    = r -> PredicateV v -> UReftV v r
forall v r. r -> PredicateV v -> UReftV v r
MkUReft r
r ([UsedPVarV v] -> PredicateV v
forall v. [UsedPVarV v] -> PredicateV v
Pr [])

predUReft :: PredicateV v -> UReftV v (ReftV v)
predUReft :: forall v. PredicateV v -> UReftV v (ReftV v)
predUReft = ReftV v -> PredicateV v -> UReftV v (ReftV v)
forall v r. r -> PredicateV v -> UReftV v r
MkUReft ReftV v
forall v. ReftV v
trueReft

dummyTyId :: String
dummyTyId :: [Char]
dummyTyId = [Char]
""

------------------------------------------------------------------
--------------------------- Measures -----------------------------
------------------------------------------------------------------

-- | The AST for a single parsed spec.
data BPspec
  = Meas    (MeasureV LocSymbol LocBareTypeParsed (Located LHName)) -- ^ 'measure' definition
  | Assm    (Located LHName, LocBareTypeParsed)              -- ^ 'assume' signature (unchecked)
  | AssmReflect (Located LHName, Located LHName)             -- ^ 'assume reflects' signature (unchecked)
  | Asrt    (Located LHName, LocBareTypeParsed)              -- ^ 'assert' signature (checked)
  | Asrts   ([Located LHName], (LocBareTypeParsed, Maybe [Located (ExprV LocSymbol)])) -- ^ sym0, ..., symn :: ty / [m0,..., mn]
  | DDecl   DataDeclParsed                                -- ^ refined 'data'    declaration
  | NTDecl  DataDeclParsed                                -- ^ refined 'newtype' declaration
  | Relational (Located LHName, Located LHName, LocBareTypeParsed, LocBareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol) -- ^ relational signature
  | AssmRel (Located LHName, Located LHName, LocBareTypeParsed, LocBareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol) -- ^ 'assume' relational signature
  | Class   (RClass LocBareTypeParsed)                    -- ^ refined 'class' definition
  | RInst   (RInstance LocBareTypeParsed)                 -- ^ refined 'instance' definition
  | Invt    LocBareTypeParsed                             -- ^ 'invariant' specification
  | Using  (LocBareTypeParsed, LocBareTypeParsed)         -- ^ 'using' declaration (for local invariants on a type)
  | Alias   (Located (RTAlias Symbol BareTypeParsed))     -- ^ 'type' alias declaration
  | EAlias  (Located (RTAlias Symbol (ExprV LocSymbol)))  -- ^ 'predicate' alias declaration
  | Embed   (Located LHName, FTycon, TCArgs)              -- ^ 'embed' declaration
  | Qualif  (QualifierV LocSymbol)                        -- ^ 'qualif' definition
  | LVars   (Located LHName)                              -- ^ 'lazyvar' annotation, defer checks to *use* sites
  | Lazy    (Located LHName)                              -- ^ 'lazy' annotation, skip termination check on binder
  | Fail    (Located LHName)                              -- ^ 'fail' annotation, the binder should be unsafe
  | Rewrite (Located LHName)                              -- ^ 'rewrite' annotation, the binder generates a rewrite rule
  | Rewritewith (Located LHName, [Located LHName])        -- ^ 'rewritewith' annotation, the first binder is using the rewrite rules of the second list,
  | Insts   (Located LHName)                              -- ^ 'auto-inst' or 'ple' annotation; use ple locally on binder
  | HMeas   (Located LHName)                              -- ^ 'measure' annotation; lift Haskell binder as measure
  | Reflect (Located LHName)                              -- ^ 'reflect' annotation; reflect Haskell binder as function in logic
  | PrivateReflect LocSymbol                              -- ^ 'private-reflect' annotation
  | OpaqueReflect (Located LHName)                        -- ^ 'opaque-reflect' annotation
  | Inline  (Located LHName)                              -- ^ 'inline' annotation;  inline (non-recursive) binder as an alias
  | Ignore  (Located LHName)                              -- ^ 'ignore' annotation; skip all checks inside this binder
  | ASize   (Located LHName)                              -- ^ 'autosize' annotation; automatically generate size metric for this type
  | PBound  (Bound LocBareTypeParsed (ExprV LocSymbol))   -- ^ 'bound' definition
  | Pragma  (Located String)                              -- ^ 'LIQUID' pragma, used to save configuration options in source files
  | CMeas   (MeasureV LocSymbol LocBareTypeParsed ())     -- ^ 'class measure' definition
  | IMeas   (MeasureV LocSymbol LocBareTypeParsed (Located LHName)) -- ^ 'instance measure' definition
  | Varia   (Located LHName, [Variance])                  -- ^ 'variance' annotations, marking type constructor params as co-, contra-, or in-variant
  | DSize   ([LocBareTypeParsed], LocSymbol)              -- ^ 'data size' annotations, generating fancy termination metric
  | BFix    ()                                            -- ^ fixity annotation
  | Define  (Located LHName, ([Symbol], ExprV LocSymbol)) -- ^ 'define' annotation for specifying logic aliases
  deriving (Typeable BPspec
Typeable BPspec =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BPspec -> c BPspec)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BPspec)
-> (BPspec -> Constr)
-> (BPspec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BPspec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BPspec))
-> ((forall b. Data b => b -> b) -> BPspec -> BPspec)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BPspec -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BPspec -> r)
-> (forall u. (forall d. Data d => d -> u) -> BPspec -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> BPspec -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BPspec -> m BPspec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BPspec -> m BPspec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BPspec -> m BPspec)
-> Data BPspec
BPspec -> Constr
BPspec -> DataType
(forall b. Data b => b -> b) -> BPspec -> BPspec
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) -> BPspec -> u
forall u. (forall d. Data d => d -> u) -> BPspec -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BPspec -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BPspec -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BPspec -> m BPspec
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BPspec -> m BPspec
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BPspec
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BPspec -> c BPspec
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BPspec)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BPspec)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BPspec -> c BPspec
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BPspec -> c BPspec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BPspec
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BPspec
$ctoConstr :: BPspec -> Constr
toConstr :: BPspec -> Constr
$cdataTypeOf :: BPspec -> DataType
dataTypeOf :: BPspec -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BPspec)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BPspec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BPspec)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BPspec)
$cgmapT :: (forall b. Data b => b -> b) -> BPspec -> BPspec
gmapT :: (forall b. Data b => b -> b) -> BPspec -> BPspec
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BPspec -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BPspec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BPspec -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BPspec -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BPspec -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BPspec -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BPspec -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BPspec -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BPspec -> m BPspec
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BPspec -> m BPspec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BPspec -> m BPspec
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BPspec -> m BPspec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BPspec -> m BPspec
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BPspec -> m BPspec
Data, Typeable)

instance PPrint BPspec where
  pprintTidy :: Tidy -> BPspec -> Doc
pprintTidy = Tidy -> BPspec -> Doc
ppPspec

splice :: PJ.Doc -> [PJ.Doc] -> PJ.Doc
splice :: Doc -> [Doc] -> Doc
splice Doc
sep = [Doc] -> Doc
PJ.hcat ([Doc] -> Doc) -> ([Doc] -> [Doc]) -> [Doc] -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> [Doc] -> [Doc]
PJ.punctuate Doc
sep

ppAsserts :: (PPrint t) => Tidy -> [Located LHName] -> t -> Maybe [Located (ExprV LocSymbol)] -> PJ.Doc
ppAsserts :: forall t.
PPrint t =>
Tidy
-> [Located LHName]
-> t
-> Maybe [Located (ExprV LocSymbol)]
-> Doc
ppAsserts Tidy
k [Located LHName]
lxs t
t Maybe [Located (ExprV LocSymbol)]
mles
  = [Doc] -> Doc
PJ.hcat [ Doc -> [Doc] -> Doc
splice Doc
", " ((Located LHName -> Doc) -> [Located LHName] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (LHName -> Doc)
-> (Located LHName -> LHName) -> Located LHName -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Located LHName -> LHName
forall a. Located a -> a
val) [Located LHName]
lxs)
            , Doc
" :: "
            , Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k t
t
            , Maybe [Located (ExprV LocSymbol)] -> Doc
forall {f :: * -> *} {f :: * -> *} {b}.
(PPrint (f (f b)), Functor f, Functor f) =>
Maybe (f (Located (f (Located b)))) -> Doc
ppLes Maybe [Located (ExprV LocSymbol)]
mles
            ]
  where
    ppLes :: Maybe (f (Located (f (Located b)))) -> Doc
ppLes Maybe (f (Located (f (Located b))))
Nothing    = Doc
""
    ppLes (Just f (Located (f (Located b)))
les) = Doc
"/" Doc -> Doc -> Doc
<+> Tidy -> f (f b) -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k ((Located b -> b) -> f (Located b) -> f b
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located b -> b
forall a. Located a -> a
val (f (Located b) -> f b)
-> (Located (f (Located b)) -> f (Located b))
-> Located (f (Located b))
-> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Located (f (Located b)) -> f (Located b)
forall a. Located a -> a
val (Located (f (Located b)) -> f b)
-> f (Located (f (Located b))) -> f (f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (Located (f (Located b)))
les)

pprintSymbolWithParens :: LHName -> PJ.Doc
pprintSymbolWithParens :: LHName -> Doc
pprintSymbolWithParens LHName
lhname =
    case Symbol -> [Char]
symbolString (Symbol -> [Char]) -> Symbol -> [Char]
forall a b. (a -> b) -> a -> b
$ LHName -> Symbol
getLHNameSymbol LHName
lhname of
      n :: [Char]
n@(Char
c:[Char]
_) | Bool -> Bool
not (Char -> Bool
Char.isAlpha Char
c) -> Doc
"(" Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
PJ.text [Char]
n Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> Doc
")"
      [Char]
n -> [Char] -> Doc
PJ.text [Char]
n

ppPspec :: Tidy -> BPspec -> PJ.Doc
ppPspec :: Tidy -> BPspec -> Doc
ppPspec Tidy
k (Meas MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)
m)
  = Doc
"measure" Doc -> Doc -> Doc
<+> Tidy -> MeasureV Symbol LocBareType LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val (Located LHName -> LHName)
-> MeasureV Symbol LocBareType (Located LHName)
-> MeasureV Symbol LocBareType LHName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)
-> MeasureV Symbol LocBareType (Located LHName)
forall v.
MeasureV LocSymbol (Located BareTypeParsed) v
-> MeasureV Symbol LocBareType v
unLocMeasureV MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)
m)
ppPspec Tidy
k (Assm (Located LHName
lx, Located BareTypeParsed
t))
  = Doc
"assume"  Doc -> Doc -> Doc
<+> LHName -> Doc
pprintSymbolWithParens (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> LocBareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (BareTypeParsed -> BareType
parsedToBareType (BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Located BareTypeParsed
t)
ppPspec Tidy
k (AssmReflect (Located LHName
lx, Located LHName
ly))
  = Doc
"assume reflect"  Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx) Doc -> Doc -> Doc
<+> Doc
"as" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
ly)
ppPspec Tidy
k (Asrt (Located LHName
lx, Located BareTypeParsed
t))
  = Doc
"assert"  Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> LocBareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (BareTypeParsed -> BareType
parsedToBareType (BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Located BareTypeParsed
t)
ppPspec Tidy
k (Asrts ([Located LHName]
lxs, (Located BareTypeParsed
t, Maybe [Located (ExprV LocSymbol)]
les)))
  = Tidy
-> [Located LHName]
-> LocBareType
-> Maybe [Located (ExprV LocSymbol)]
-> Doc
forall t.
PPrint t =>
Tidy
-> [Located LHName]
-> t
-> Maybe [Located (ExprV LocSymbol)]
-> Doc
ppAsserts Tidy
k [Located LHName]
lxs (BareTypeParsed -> BareType
parsedToBareType (BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Located BareTypeParsed
t) Maybe [Located (ExprV LocSymbol)]
les
ppPspec Tidy
k (DDecl DataDeclParsed
d)
  = Tidy -> DataDeclP Symbol BareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (BareTypeParsed -> BareType
parsedToBareType (BareTypeParsed -> BareType)
-> DataDeclP Symbol BareTypeParsed -> DataDeclP Symbol BareType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (LocSymbol -> Symbol)
-> DataDeclParsed -> DataDeclP Symbol BareTypeParsed
forall v v' ty. (v -> v') -> DataDeclP v ty -> DataDeclP v' ty
mapDataDeclV LocSymbol -> Symbol
forall a. Located a -> a
val DataDeclParsed
d)
ppPspec Tidy
k (NTDecl DataDeclParsed
d)
  = Doc
"newtype" Doc -> Doc -> Doc
<+> Tidy -> DataDeclP Symbol BareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (BareTypeParsed -> BareType
parsedToBareType (BareTypeParsed -> BareType)
-> DataDeclP Symbol BareTypeParsed -> DataDeclP Symbol BareType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (LocSymbol -> Symbol)
-> DataDeclParsed -> DataDeclP Symbol BareTypeParsed
forall v v' ty. (v -> v') -> DataDeclP v ty -> DataDeclP v' ty
mapDataDeclV LocSymbol -> Symbol
forall a. Located a -> a
val DataDeclParsed
d)
ppPspec Tidy
k (Invt Located BareTypeParsed
t)
  = Doc
"invariant" Doc -> Doc -> Doc
<+> Tidy -> LocBareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (BareTypeParsed -> BareType
parsedToBareType (BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Located BareTypeParsed
t)
ppPspec Tidy
k (Using (Located BareTypeParsed
t1, Located BareTypeParsed
t2))
  = Doc
"using" Doc -> Doc -> Doc
<+> Tidy -> LocBareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (BareTypeParsed -> BareType
parsedToBareType (BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Located BareTypeParsed
t1) Doc -> Doc -> Doc
<+> Doc
"as" Doc -> Doc -> Doc
<+> Tidy -> LocBareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (BareTypeParsed -> BareType
parsedToBareType (BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Located BareTypeParsed
t2)
ppPspec Tidy
k (Alias   (Loc SourcePos
_ SourcePos
_ RTAlias Symbol BareTypeParsed
rta))
  = Doc
"type" Doc -> Doc -> Doc
<+> Tidy -> RTAlias Symbol BareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k ((BareTypeParsed -> BareType)
-> RTAlias Symbol BareTypeParsed -> RTAlias Symbol BareType
forall a b. (a -> b) -> RTAlias Symbol a -> RTAlias Symbol b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BareTypeParsed -> BareType
parsedToBareType RTAlias Symbol BareTypeParsed
rta)
ppPspec Tidy
k (EAlias  (Loc SourcePos
_ SourcePos
_ RTAlias Symbol (ExprV LocSymbol)
rte))
  = Doc
"predicate" Doc -> Doc -> Doc
<+> Tidy -> RTAlias Symbol (ExprV LocSymbol) -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k RTAlias Symbol (ExprV LocSymbol)
rte
ppPspec Tidy
k (Embed   (Located LHName
lx, FTycon
tc, TCArgs
NoArgs))
  = Doc
"embed" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx)         Doc -> Doc -> Doc
<+> Doc
"as" Doc -> Doc -> Doc
<+> Tidy -> FTycon -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k FTycon
tc
ppPspec Tidy
k (Embed   (Located LHName
lx, FTycon
tc, TCArgs
WithArgs))
  = Doc
"embed" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx) Doc -> Doc -> Doc
<+> Doc
"*" Doc -> Doc -> Doc
<+> Doc
"as" Doc -> Doc -> Doc
<+> Tidy -> FTycon -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k FTycon
tc
ppPspec Tidy
k (Qualif  QualifierV LocSymbol
q)
  = Tidy -> QualifierV LocSymbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k QualifierV LocSymbol
q
ppPspec Tidy
k (LVars   Located LHName
lx)
  = Doc
"lazyvar" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx)
ppPspec Tidy
k (Lazy   Located LHName
lx)
  = Doc
"lazy" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx)
ppPspec Tidy
k (Rewrite   Located LHName
lx)
  = Doc
"rewrite" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx)
ppPspec Tidy
k (Rewritewith (Located LHName
lx, [Located LHName]
lxs))
  = Doc
"rewriteWith" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx) Doc -> Doc -> Doc
<+> [Doc] -> Doc
PJ.hsep ((Located LHName -> Doc) -> [Located LHName] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map Located LHName -> Doc
forall {a}. PPrint a => Located a -> Doc
go [Located LHName]
lxs)
  where
    go :: Located a -> Doc
go Located a
s = Tidy -> a -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (a -> Doc) -> a -> Doc
forall a b. (a -> b) -> a -> b
$ Located a -> a
forall a. Located a -> a
val Located a
s
ppPspec Tidy
k (Fail   Located LHName
lx)
  = Doc
"fail" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx)
ppPspec Tidy
k (Insts   Located LHName
lx)
  = Doc
"automatic-instances" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx)
ppPspec Tidy
k (HMeas   Located LHName
lx)
  = Doc
"measure" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx)
ppPspec Tidy
k (Reflect Located LHName
lx)
  = Doc
"reflect" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx)
ppPspec Tidy
k (PrivateReflect LocSymbol
lx)
  = Doc
"private-reflect" Doc -> Doc -> Doc
<+> Tidy -> Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (LocSymbol -> Symbol
forall a. Located a -> a
val LocSymbol
lx)
ppPspec Tidy
k (OpaqueReflect Located LHName
lx)
  = Doc
"opaque-reflect" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx)
ppPspec Tidy
k (Inline  Located LHName
lx)
  = Doc
"inline" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx)
ppPspec Tidy
k (Ignore  Located LHName
lx)
  = Doc
"ignore" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx)
ppPspec Tidy
k (ASize   Located LHName
lx)
  = Doc
"autosize" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx)
ppPspec Tidy
k (PBound  Bound (Located BareTypeParsed) (ExprV LocSymbol)
bnd)
  = Tidy -> Bound LocBareType (ExprV LocSymbol) -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Bound LocBareType (ExprV LocSymbol) -> Doc)
-> Bound LocBareType (ExprV LocSymbol) -> Doc
forall a b. (a -> b) -> a -> b
$ (Located BareTypeParsed -> LocBareType)
-> Bound (Located BareTypeParsed) (ExprV LocSymbol)
-> Bound LocBareType (ExprV LocSymbol)
forall t0 t1 e. (t0 -> t1) -> Bound t0 e -> Bound t1 e
mapBoundTy ((BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BareTypeParsed -> BareType
parsedToBareType) Bound (Located BareTypeParsed) (ExprV LocSymbol)
bnd
ppPspec Tidy
_ (Pragma  (Loc SourcePos
_ SourcePos
_ [Char]
s))
  = Doc
"LIQUID" Doc -> Doc -> Doc
<+> [Char] -> Doc
PJ.text [Char]
s
ppPspec Tidy
k (CMeas   MeasureV LocSymbol (Located BareTypeParsed) ()
m)
  = Doc
"class measure" Doc -> Doc -> Doc
<+> Tidy -> MeasureV Symbol LocBareType () -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (MeasureV LocSymbol (Located BareTypeParsed) ()
-> MeasureV Symbol LocBareType ()
forall v.
MeasureV LocSymbol (Located BareTypeParsed) v
-> MeasureV Symbol LocBareType v
unLocMeasureV MeasureV LocSymbol (Located BareTypeParsed) ()
m)
ppPspec Tidy
k (IMeas   MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)
m)
  = Doc
"instance measure" Doc -> Doc -> Doc
<+> Tidy -> MeasureV Symbol LocBareType LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val (Located LHName -> LHName)
-> MeasureV Symbol LocBareType (Located LHName)
-> MeasureV Symbol LocBareType LHName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)
-> MeasureV Symbol LocBareType (Located LHName)
forall v.
MeasureV LocSymbol (Located BareTypeParsed) v
-> MeasureV Symbol LocBareType v
unLocMeasureV MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)
m)
ppPspec Tidy
k (Class   RClass (Located BareTypeParsed)
cls)
  = Tidy -> RClass LocBareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (RClass LocBareType -> Doc) -> RClass LocBareType -> Doc
forall a b. (a -> b) -> a -> b
$ (Located BareTypeParsed -> LocBareType)
-> RClass (Located BareTypeParsed) -> RClass LocBareType
forall a b. (a -> b) -> RClass a -> RClass b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BareTypeParsed -> BareType
parsedToBareType) RClass (Located BareTypeParsed)
cls
ppPspec Tidy
k (RInst   RInstance (Located BareTypeParsed)
inst)
  = Tidy -> RInstance LocBareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (RInstance LocBareType -> Doc) -> RInstance LocBareType -> Doc
forall a b. (a -> b) -> a -> b
$ (Located BareTypeParsed -> LocBareType)
-> RInstance (Located BareTypeParsed) -> RInstance LocBareType
forall a b. (a -> b) -> RInstance a -> RInstance b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BareTypeParsed -> BareType
parsedToBareType) RInstance (Located BareTypeParsed)
inst
ppPspec Tidy
k (Varia   (Located LHName
lx, [Variance]
vs))
  = Doc
"data variance" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx) Doc -> Doc -> Doc
<+> Doc -> [Doc] -> Doc
splice Doc
" " (Tidy -> Variance -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Variance -> Doc) -> [Variance] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Variance]
vs)
ppPspec Tidy
k (DSize   ([Located BareTypeParsed]
ds, LocSymbol
ss))
  = Doc
"data size" Doc -> Doc -> Doc
<+> Doc -> [Doc] -> Doc
splice Doc
" " (Tidy -> LocBareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (LocBareType -> Doc) -> [LocBareType] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Located BareTypeParsed -> LocBareType)
-> [Located BareTypeParsed] -> [LocBareType]
forall a b. (a -> b) -> [a] -> [b]
map ((BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BareTypeParsed -> BareType
parsedToBareType) [Located BareTypeParsed]
ds) Doc -> Doc -> Doc
<+> Tidy -> Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (LocSymbol -> Symbol
forall a. Located a -> a
val LocSymbol
ss)
ppPspec Tidy
_ (BFix    ()
_)           --
  = Doc
"fixity"
ppPspec Tidy
k (Define  (Located LHName
lx, ([Symbol]
ys, ExprV LocSymbol
e)))
  = Doc
"define" Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lx) Doc -> Doc -> Doc
<+> Doc
" " Doc -> Doc -> Doc
<+> Tidy -> [Symbol] -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k [Symbol]
ys Doc -> Doc -> Doc
<+> Doc
"=" Doc -> Doc -> Doc
<+> Tidy -> ExprV LocSymbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k ExprV LocSymbol
e
ppPspec Tidy
k (Relational (Located LHName
lxl, Located LHName
lxr, Located BareTypeParsed
tl, Located BareTypeParsed
tr, RelExprV LocSymbol
q, RelExprV LocSymbol
p))
  = Doc
"relational"
        Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lxl) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> LocBareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (BareTypeParsed -> BareType
parsedToBareType (BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Located BareTypeParsed
tl) Doc -> Doc -> Doc
<+> Doc
"~"
        Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lxr) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> LocBareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (BareTypeParsed -> BareType
parsedToBareType (BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Located BareTypeParsed
tr) Doc -> Doc -> Doc
<+> Doc
"|"
        Doc -> Doc -> Doc
<+> Tidy -> RelExprV Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k ((LocSymbol -> Symbol) -> RelExprV LocSymbol -> RelExprV Symbol
forall a b. (a -> b) -> RelExprV a -> RelExprV b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> Symbol
forall a. Located a -> a
val RelExprV LocSymbol
q) Doc -> Doc -> Doc
<+> Doc
"=>" Doc -> Doc -> Doc
<+> Tidy -> RelExprV Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k ((LocSymbol -> Symbol) -> RelExprV LocSymbol -> RelExprV Symbol
forall a b. (a -> b) -> RelExprV a -> RelExprV b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> Symbol
forall a. Located a -> a
val RelExprV LocSymbol
p)
ppPspec Tidy
k (AssmRel (Located LHName
lxl, Located LHName
lxr, Located BareTypeParsed
tl, Located BareTypeParsed
tr, RelExprV LocSymbol
q, RelExprV LocSymbol
p))
  = Doc
"assume relational"
        Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lxl) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> LocBareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (BareTypeParsed -> BareType
parsedToBareType (BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Located BareTypeParsed
tl) Doc -> Doc -> Doc
<+> Doc
"~"
        Doc -> Doc -> Doc
<+> Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
val Located LHName
lxr) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> LocBareType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (BareTypeParsed -> BareType
parsedToBareType (BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Located BareTypeParsed
tr) Doc -> Doc -> Doc
<+> Doc
"|"
        Doc -> Doc -> Doc
<+> Tidy -> RelExprV Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k ((LocSymbol -> Symbol) -> RelExprV LocSymbol -> RelExprV Symbol
forall a b. (a -> b) -> RelExprV a -> RelExprV b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> Symbol
forall a. Located a -> a
val RelExprV LocSymbol
q) Doc -> Doc -> Doc
<+> Doc
"=>" Doc -> Doc -> Doc
<+> Tidy -> RelExprV Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k ((LocSymbol -> Symbol) -> RelExprV LocSymbol -> RelExprV Symbol
forall a b. (a -> b) -> RelExprV a -> RelExprV b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> Symbol
forall a. Located a -> a
val RelExprV LocSymbol
p)

unLocMeasureV :: MeasureV LocSymbol LocBareTypeParsed v -> MeasureV Symbol LocBareType v
unLocMeasureV :: forall v.
MeasureV LocSymbol (Located BareTypeParsed) v
-> MeasureV Symbol LocBareType v
unLocMeasureV = (LocSymbol -> Symbol)
-> MeasureV LocSymbol LocBareType v
-> MeasureV Symbol LocBareType v
forall v v' ty ctor.
(v -> v') -> MeasureV v ty ctor -> MeasureV v' ty ctor
mapMeasureV LocSymbol -> Symbol
forall a. Located a -> a
val (MeasureV LocSymbol LocBareType v -> MeasureV Symbol LocBareType v)
-> (MeasureV LocSymbol (Located BareTypeParsed) v
    -> MeasureV LocSymbol LocBareType v)
-> MeasureV LocSymbol (Located BareTypeParsed) v
-> MeasureV Symbol LocBareType v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Located BareTypeParsed -> LocBareType)
-> MeasureV LocSymbol (Located BareTypeParsed) v
-> MeasureV LocSymbol LocBareType v
forall ty0 ty1 v ctor.
(ty0 -> ty1) -> MeasureV v ty0 ctor -> MeasureV v ty1 ctor
mapMeasureTy ((BareTypeParsed -> BareType)
-> Located BareTypeParsed -> LocBareType
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BareTypeParsed -> BareType
parsedToBareType)

-- | For debugging
{-instance Show (Pspec a b) where
  show (Meas   _) = "Meas"
  show (Assm   _) = "Assm"
  show (Asrt   _) = "Asrt"
  show (Asrts  _) = "Asrts"
  show (Impt   _) = "Impt"
  shcl  _) = "DDecl"
  show (NTDecl _) = "NTDecl"
  show (Invt   _) = "Invt"
  show (Using _) = "Using"
  show (Alias  _) = "Alias"
  show (EAlias _) = "EAlias"
  show (Embed  _) = "Embed"
  show (Qualif _) = "Qualif"
  show (Decr   _) = "Decr"
  show (LVars  _) = "LVars"
  show (Lazy   _) = "Lazy"
  -- show (Axiom  _) = "Axiom"
  show (Reflect _) = "Reflect"
  show (HMeas  _) = "HMeas"
  show (Inline _) = "Inline"
  show (Pragma _) = "Pragma"
  show (CMeas  _) = "CMeas"
  show (IMeas  _) = "IMeas"
  show (Class  _) = "Class"
  show (Varia  _) = "Varia"
  show (PBound _) = "Bound"
  show (RInst  _) = "RInst"
  show (ASize  _) = "ASize"
  show (BFix   _) = "BFix"
  show (Define _) = "Define"-}

-- | Turns a list of parsed specifications into a "bare spec".
--
-- This is primarily a rearrangement, as the bare spec is a record containing
-- different kinds of spec directives in different positions, whereas the input
-- list is a mixed list.
--
-- In addition, the sigs of the spec (these are asserted/checked LH type
-- signatues) are being qualified, i.e., the binding occurrences are prefixed
-- with the module name.
--
mkSpec :: [BPspec] -> Measure.Spec LocSymbol BareTypeParsed
mkSpec :: [BPspec] -> BareSpecParsed
mkSpec [BPspec]
xs = Measure.Spec
  { measures :: [MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)]
Measure.measures   = [MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)
m | Meas   MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)
m <- [BPspec]
xs]
  , asmSigs :: [(Located LHName, Located BareTypeParsed)]
Measure.asmSigs    = [(Located LHName, Located BareTypeParsed)
a | Assm   (Located LHName, Located BareTypeParsed)
a <- [BPspec]
xs]
  , asmReflectSigs :: [(Located LHName, Located LHName)]
Measure.asmReflectSigs = [(Located LHName
l, Located LHName
r) | AssmReflect (Located LHName
l, Located LHName
r) <- [BPspec]
xs]
  , sigs :: [(Located LHName, Located BareTypeParsed)]
Measure.sigs       = [(Located LHName, Located BareTypeParsed)
a | Asrt   (Located LHName, Located BareTypeParsed)
a <- [BPspec]
xs]
                      [(Located LHName, Located BareTypeParsed)]
-> [(Located LHName, Located BareTypeParsed)]
-> [(Located LHName, Located BareTypeParsed)]
forall a. [a] -> [a] -> [a]
++ [(Located LHName
y, Located BareTypeParsed
t) | Asrts ([Located LHName]
ys, (Located BareTypeParsed
t, Maybe [Located (ExprV LocSymbol)]
_)) <- [BPspec]
xs, Located LHName
y <- [Located LHName]
ys]
  , expSigs :: [(LocSymbol, Sort)]
Measure.expSigs    = []
  , invariants :: [(Maybe LocSymbol, Located BareTypeParsed)]
Measure.invariants = [(Maybe LocSymbol
forall {a}. Maybe a
Nothing, Located BareTypeParsed
t) | Invt   Located BareTypeParsed
t <- [BPspec]
xs]
  , ialiases :: [(Located BareTypeParsed, Located BareTypeParsed)]
Measure.ialiases   = [(Located BareTypeParsed, Located BareTypeParsed)
t | Using (Located BareTypeParsed, Located BareTypeParsed)
t <- [BPspec]
xs]
  , dataDecls :: [DataDeclParsed]
Measure.dataDecls  = [DataDeclParsed
d | DDecl  DataDeclParsed
d <- [BPspec]
xs] [DataDeclParsed] -> [DataDeclParsed] -> [DataDeclParsed]
forall a. [a] -> [a] -> [a]
++ [DataDeclParsed
d | NTDecl DataDeclParsed
d <- [BPspec]
xs]
  , newtyDecls :: [DataDeclParsed]
Measure.newtyDecls = [DataDeclParsed
d | NTDecl DataDeclParsed
d <- [BPspec]
xs]
  , aliases :: [Located (RTAlias Symbol BareTypeParsed)]
Measure.aliases    = [Located (RTAlias Symbol BareTypeParsed)
a | Alias  Located (RTAlias Symbol BareTypeParsed)
a <- [BPspec]
xs]
  , ealiases :: [Located (RTAlias Symbol (ExprV LocSymbol))]
Measure.ealiases   = [Located (RTAlias Symbol (ExprV LocSymbol))
e | EAlias Located (RTAlias Symbol (ExprV LocSymbol))
e <- [BPspec]
xs]
  , embeds :: TCEmb (Located LHName)
Measure.embeds     = [(Located LHName, (Sort, TCArgs))] -> TCEmb (Located LHName)
forall a. (Eq a, Hashable a) => [(a, (Sort, TCArgs))] -> TCEmb a
tceFromList [(Located LHName
c, (FTycon -> Sort
fTyconSort FTycon
tc, TCArgs
a)) | Embed (Located LHName
c, FTycon
tc, TCArgs
a) <- [BPspec]
xs]
  , qualifiers :: [QualifierV LocSymbol]
Measure.qualifiers = [QualifierV LocSymbol
q | Qualif QualifierV LocSymbol
q <- [BPspec]
xs]
  , lvars :: HashSet (Located LHName)
Measure.lvars      = [Located LHName] -> HashSet (Located LHName)
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [Located LHName
d | LVars Located LHName
d  <- [BPspec]
xs]
  , autois :: HashSet (Located LHName)
Measure.autois     = [Located LHName] -> HashSet (Located LHName)
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [Located LHName
s | Insts Located LHName
s <- [BPspec]
xs]
  , pragmas :: [Located [Char]]
Measure.pragmas    = [Located [Char]
s | Pragma Located [Char]
s <- [BPspec]
xs]
  , cmeasures :: [MeasureV LocSymbol (Located BareTypeParsed) ()]
Measure.cmeasures  = [MeasureV LocSymbol (Located BareTypeParsed) ()
m | CMeas  MeasureV LocSymbol (Located BareTypeParsed) ()
m <- [BPspec]
xs]
  , imeasures :: [MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)]
Measure.imeasures  = [MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)
m | IMeas  MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)
m <- [BPspec]
xs]
  , omeasures :: [MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)]
Measure.omeasures  = []
  , classes :: [RClass (Located BareTypeParsed)]
Measure.classes    = [RClass (Located BareTypeParsed)
c | Class  RClass (Located BareTypeParsed)
c <- [BPspec]
xs]
  , relational :: [(Located LHName, Located LHName, Located BareTypeParsed,
  Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)]
Measure.relational = [(Located LHName, Located LHName, Located BareTypeParsed,
 Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
r | Relational (Located LHName, Located LHName, Located BareTypeParsed,
 Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
r <- [BPspec]
xs]
  , asmRel :: [(Located LHName, Located LHName, Located BareTypeParsed,
  Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)]
Measure.asmRel     = [(Located LHName, Located LHName, Located BareTypeParsed,
 Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
r | AssmRel (Located LHName, Located LHName, Located BareTypeParsed,
 Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
r <- [BPspec]
xs]
  , dvariance :: [(Located LHName, [Variance])]
Measure.dvariance  = [(Located LHName, [Variance])
v | Varia  (Located LHName, [Variance])
v <- [BPspec]
xs]
  , dsize :: [([Located BareTypeParsed], LocSymbol)]
Measure.dsize      = [([Located BareTypeParsed], LocSymbol)
v | DSize  ([Located BareTypeParsed], LocSymbol)
v <- [BPspec]
xs]
  , rinstance :: [RInstance (Located BareTypeParsed)]
Measure.rinstance  = [RInstance (Located BareTypeParsed)
i | RInst  RInstance (Located BareTypeParsed)
i <- [BPspec]
xs]
  , termexprs :: [(Located LHName, [Located (ExprV LocSymbol)])]
Measure.termexprs  = [(Located LHName
y, [Located (ExprV LocSymbol)]
es) | Asrts ([Located LHName]
ys, (Located BareTypeParsed
_, Just [Located (ExprV LocSymbol)]
es)) <- [BPspec]
xs, Located LHName
y <- [Located LHName]
ys]
  , lazy :: HashSet (Located LHName)
Measure.lazy       = [Located LHName] -> HashSet (Located LHName)
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [Located LHName
s | Lazy   Located LHName
s <- [BPspec]
xs]
  , fails :: HashSet (Located LHName)
Measure.fails      = [Located LHName] -> HashSet (Located LHName)
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [Located LHName
s | Fail   Located LHName
s <- [BPspec]
xs]
  , rewrites :: HashSet (Located LHName)
Measure.rewrites   = [Located LHName] -> HashSet (Located LHName)
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [Located LHName
s | Rewrite Located LHName
s <- [BPspec]
xs]
  , rewriteWith :: HashMap (Located LHName) [Located LHName]
Measure.rewriteWith = [(Located LHName, [Located LHName])]
-> HashMap (Located LHName) [Located LHName]
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList [(Located LHName, [Located LHName])
s | Rewritewith (Located LHName, [Located LHName])
s <- [BPspec]
xs]
  , bounds :: RRBEnvV LocSymbol (Located BareTypeParsed)
Measure.bounds     = [(LocSymbol, Bound (Located BareTypeParsed) (ExprV LocSymbol))]
-> RRBEnvV LocSymbol (Located BareTypeParsed)
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList [(Bound (Located BareTypeParsed) (ExprV LocSymbol) -> LocSymbol
forall t e. Bound t e -> LocSymbol
bname Bound (Located BareTypeParsed) (ExprV LocSymbol)
i, Bound (Located BareTypeParsed) (ExprV LocSymbol)
i) | PBound Bound (Located BareTypeParsed) (ExprV LocSymbol)
i <- [BPspec]
xs]
  , reflects :: HashSet (Located LHName)
Measure.reflects   = [Located LHName] -> HashSet (Located LHName)
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [Located LHName
s | Reflect Located LHName
s <- [BPspec]
xs]
  , privateReflects :: HashSet LocSymbol
Measure.privateReflects = [LocSymbol] -> HashSet LocSymbol
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [LocSymbol
s | PrivateReflect LocSymbol
s <- [BPspec]
xs]
  , opaqueReflects :: HashSet (Located LHName)
Measure.opaqueReflects = [Located LHName] -> HashSet (Located LHName)
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [Located LHName
s | OpaqueReflect Located LHName
s <- [BPspec]
xs]
  , hmeas :: HashSet (Located LHName)
Measure.hmeas      = [Located LHName] -> HashSet (Located LHName)
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [Located LHName
s | HMeas  Located LHName
s <- [BPspec]
xs]
  , inlines :: HashSet (Located LHName)
Measure.inlines    = [Located LHName] -> HashSet (Located LHName)
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [Located LHName
s | Inline Located LHName
s <- [BPspec]
xs]
  , ignores :: HashSet (Located LHName)
Measure.ignores    = [Located LHName] -> HashSet (Located LHName)
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [Located LHName
s | Ignore Located LHName
s <- [BPspec]
xs]
  , autosize :: HashSet (Located LHName)
Measure.autosize   = [Located LHName] -> HashSet (Located LHName)
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [Located LHName
s | ASize  Located LHName
s <- [BPspec]
xs]
  , axeqs :: [EquationV LocSymbol]
Measure.axeqs      = []
  , defines :: [(Located LHName, LMapV LocSymbol)]
Measure.defines    = [ (Located LHName, ([Symbol], ExprV LocSymbol))
-> (Located LHName, LMapV LocSymbol)
forall v.
(Located LHName, ([Symbol], ExprV v)) -> (Located LHName, LMapV v)
toLMapV (Located LHName, ([Symbol], ExprV LocSymbol))
d | Define (Located LHName, ([Symbol], ExprV LocSymbol))
d <- [BPspec]
xs]
  , usedDataCons :: HashSet LHName
Measure.usedDataCons = HashSet LHName
forall a. Monoid a => a
mempty
  }

-- | Parse a single top level liquid specification
specP :: Parser BPspec
specP :: ParserV LocSymbol BPspec
specP
  = [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"assume" (([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"reflect" ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((Located LHName, Located LHName) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName, Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Located LHName, Located LHName) -> BPspec
AssmReflect StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located LHName)
assmReflectBindP)
        ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"relational" ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>  ((Located LHName, Located LHName, Located BareTypeParsed,
  Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
 -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName, Located LHName, Located BareTypeParsed,
      Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Located LHName, Located LHName, Located BareTypeParsed,
 Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
-> BPspec
AssmRel StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located LHName, Located BareTypeParsed,
   Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
relationalP)
        ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>                            ((Located LHName, Located BareTypeParsed) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName, Located BareTypeParsed)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Located LHName, Located BareTypeParsed) -> BPspec
Assm   StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located BareTypeParsed)
tyBindLHNameP  )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"assert"      (((Located LHName, Located BareTypeParsed) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName, Located BareTypeParsed)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Located LHName, Located BareTypeParsed) -> BPspec
Asrt    StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located BareTypeParsed)
tyBindLocalLHNameP)
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"autosize"    ((Located LHName -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located LHName -> BPspec
ASize   StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
tyConBindLHNameP)

    -- TODO: These next two are synonyms, kill one
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"axiomatize"  ((Located LHName -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located LHName -> BPspec
Reflect StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP)
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"reflect"     ((Located LHName -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located LHName -> BPspec
Reflect StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP)
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"private-reflect" ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (LocSymbol -> BPspec)
-> ParserV LocSymbol LocSymbol -> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> BPspec
PrivateReflect ParserV LocSymbol LocSymbol
axiomP  )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"opaque-reflect" ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located LHName -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located LHName -> BPspec
OpaqueReflect StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP  )

    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"define"  ParserV LocSymbol BPspec
logDefineP
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"measure" ParserV LocSymbol BPspec
hmeasureP

    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"infixl"        ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (() -> BPspec) -> ParserV LocSymbol () -> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap () -> BPspec
BFix    ParserV LocSymbol ()
infixlP  )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"infixr"        ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (() -> BPspec) -> ParserV LocSymbol () -> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap () -> BPspec
BFix    ParserV LocSymbol ()
infixrP  )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"infix"         ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (() -> BPspec) -> ParserV LocSymbol () -> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap () -> BPspec
BFix    ParserV LocSymbol ()
infixP   )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"inline"      ((Located LHName -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located LHName -> BPspec
Inline StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderThisModuleLHNameP)
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"ignore"      ((Located LHName -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located LHName -> BPspec
Ignore  StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderThisModuleLHNameP)

    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"bound"       ((Bound (Located BareTypeParsed) (ExprV LocSymbol) -> BPspec)
-> Parser (Bound (Located BareTypeParsed) (ExprV LocSymbol))
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bound (Located BareTypeParsed) (ExprV LocSymbol) -> BPspec
PBound  Parser (Bound (Located BareTypeParsed) (ExprV LocSymbol))
boundP)
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"class"
         ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"measure"  ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (MeasureV LocSymbol (Located BareTypeParsed) () -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (MeasureV LocSymbol (Located BareTypeParsed) ())
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MeasureV LocSymbol (Located BareTypeParsed) () -> BPspec
CMeas  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (MeasureV LocSymbol (Located BareTypeParsed) ())
cMeasureP )
         ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (RClass (Located BareTypeParsed) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (RClass (Located BareTypeParsed))
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RClass (Located BareTypeParsed) -> BPspec
Class  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (RClass (Located BareTypeParsed))
classP                            ))
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"instance"
         ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"measure"  ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)
 -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (MeasureV LocSymbol (Located BareTypeParsed) (Located LHName))
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MeasureV LocSymbol (Located BareTypeParsed) (Located LHName)
-> BPspec
IMeas  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (MeasureV LocSymbol (Located BareTypeParsed) (Located LHName))
iMeasureP )
         ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (RInstance (Located BareTypeParsed) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (RInstance (Located BareTypeParsed))
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RInstance (Located BareTypeParsed) -> BPspec
RInst  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (RInstance (Located BareTypeParsed))
instanceP ))

    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"data"
        ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"variance"  ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((Located LHName, [Variance]) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName, [Variance])
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Located LHName, [Variance]) -> BPspec
Varia  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, [Variance])
datavarianceP)
        ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"size"      ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (([Located BareTypeParsed], LocSymbol) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     ([Located BareTypeParsed], LocSymbol)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Located BareTypeParsed], LocSymbol) -> BPspec
DSize  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  ([Located BareTypeParsed], LocSymbol)
dsizeP)
        ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (DataDeclParsed -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) DataDeclParsed
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DataDeclParsed -> BPspec
DDecl  StateT (PStateV LocSymbol) (Parsec Void [Char]) DataDeclParsed
dataDeclP ))
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"newtype"       ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DataDeclParsed -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) DataDeclParsed
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DataDeclParsed -> BPspec
NTDecl StateT (PStateV LocSymbol) (Parsec Void [Char]) DataDeclParsed
dataDeclP )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"relational"    ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((Located LHName, Located LHName, Located BareTypeParsed,
  Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
 -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName, Located LHName, Located BareTypeParsed,
      Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Located LHName, Located LHName, Located BareTypeParsed,
 Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
-> BPspec
Relational StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located LHName, Located BareTypeParsed,
   Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
relationalP )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"invariant"   ((Located BareTypeParsed -> BPspec)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located BareTypeParsed -> BPspec
Invt   StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
invariantP)
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"using"          ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((Located BareTypeParsed, Located BareTypeParsed) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located BareTypeParsed, Located BareTypeParsed)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Located BareTypeParsed, Located BareTypeParsed) -> BPspec
Using StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located BareTypeParsed, Located BareTypeParsed)
invaliasP )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"type"          ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located (RTAlias Symbol BareTypeParsed) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (RTAlias Symbol BareTypeParsed))
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located (RTAlias Symbol BareTypeParsed) -> BPspec
Alias  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located (RTAlias Symbol BareTypeParsed))
aliasP    )

    -- TODO: Next two are basically synonyms
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"predicate"   ((Located (RTAlias Symbol (ExprV LocSymbol)) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (RTAlias Symbol (ExprV LocSymbol)))
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located (RTAlias Symbol (ExprV LocSymbol)) -> BPspec
EAlias StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located (RTAlias Symbol (ExprV LocSymbol)))
ealiasP   )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"expression"  ((Located (RTAlias Symbol (ExprV LocSymbol)) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (RTAlias Symbol (ExprV LocSymbol)))
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located (RTAlias Symbol (ExprV LocSymbol)) -> BPspec
EAlias StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located (RTAlias Symbol (ExprV LocSymbol)))
ealiasP   )

    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"embed"       (((Located LHName, FTycon, TCArgs) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName, FTycon, TCArgs)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Located LHName, FTycon, TCArgs) -> BPspec
Embed  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, FTycon, TCArgs)
embedP    )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
"qualif"      ((QualifierV LocSymbol -> BPspec)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (QualifierV LocSymbol)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap QualifierV LocSymbol -> BPspec
Qualif (ParserV LocSymbol Sort
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (QualifierV LocSymbol)
forall v.
ParseableV v =>
ParserV v Sort -> ParserV v (QualifierV v)
qualifierP ParserV LocSymbol Sort
forall v. ParserV v Sort
sortP))
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"lazyvar"       ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located LHName -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located LHName -> BPspec
LVars  StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderThisModuleLHNameP)

    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"lazy"          ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located LHName -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located LHName -> BPspec
Lazy   StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP)
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"rewrite"       ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located LHName -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located LHName -> BPspec
Rewrite StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP)
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"rewriteWith"   ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((Located LHName, [Located LHName]) -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName, [Located LHName])
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Located LHName, [Located LHName]) -> BPspec
Rewritewith   StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, [Located LHName])
rewriteWithP )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"fail"          ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located LHName -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located LHName -> BPspec
Fail StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderThisModuleLHNameP )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"ple"           ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located LHName -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located LHName -> BPspec
Insts StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderThisModuleLHNameP  )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"automatic-instances" ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located LHName -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located LHName -> BPspec
Insts StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderThisModuleLHNameP  )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"LIQUID"        ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located [Char] -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located [Char])
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located [Char] -> BPspec
Pragma StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located [Char])
pragmaP   )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"liquid"        ParserV LocSymbol ()
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located [Char] -> BPspec)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located [Char])
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located [Char] -> BPspec
Pragma StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located [Char])
pragmaP   )
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> {- DEFAULT -}                (([Located LHName],
  (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)]))
 -> BPspec)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     ([Located LHName],
      (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)]))
-> ParserV LocSymbol BPspec
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Located LHName],
 (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)]))
-> BPspec
Asrts  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  ([Located LHName],
   (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)]))
tyBindsP
    ParserV LocSymbol BPspec -> [Char] -> ParserV LocSymbol BPspec
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"specP"

-- | Try the given parser on the tail after matching the reserved word, and if
-- it fails fall back to parsing it as a haskell signature for a function with
-- the same name.
fallbackSpecP :: String -> Parser BPspec -> Parser BPspec
fallbackSpecP :: [Char] -> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
fallbackSpecP [Char]
kw ParserV LocSymbol BPspec
p = do
  (Loc l1 l2 _) <- [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located [Char])
forall v. [Char] -> ParserV v (Located [Char])
locReserved [Char]
kw
  p <|> fmap Asrts (tyBindsRemP (Loc l1 l2 (makeUnresolvedLHName (LHVarName LHThisModuleNameF) (symbol kw))))

-- | Same as tyBindsP, except the single initial symbol has already been matched
tyBindsRemP
  :: Located LHName
  -> Parser ([Located LHName], (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)]))
tyBindsRemP :: Located LHName
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     ([Located LHName],
      (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)]))
tyBindsRemP Located LHName
sy = do
  [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"::"
  tb <- Parser (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)])
termBareTypeP
  return ([sy],tb)

pragmaP :: Parser (Located String)
pragmaP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located [Char])
pragmaP = StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located [Char])
forall v. ParserV v (Located [Char])
locStringLiteral

rewriteWithP :: Parser (Located LHName, [Located LHName])
rewriteWithP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, [Located LHName])
rewriteWithP = (,) (Located LHName
 -> [Located LHName] -> (Located LHName, [Located LHName]))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     ([Located LHName] -> (Located LHName, [Located LHName]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  ([Located LHName] -> (Located LHName, [Located LHName]))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Located LHName]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName, [Located LHName])
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Located LHName]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Located LHName]
forall v a. ParserV v a -> ParserV v a
brackets (StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Located LHName]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy1 StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma)

axiomP :: Parser LocSymbol
axiomP :: ParserV LocSymbol LocSymbol
axiomP = ParserV LocSymbol LocSymbol
locBinderP

datavarianceP :: Parser (Located LHName, [Variance])
datavarianceP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, [Variance])
datavarianceP = (Located LHName -> [Variance] -> (Located LHName, [Variance]))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Variance]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName, [Variance])
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,) (LHNameSpace
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locUpperIdLHNameP LHNameSpace
LHTcName) (StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Variance]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
varianceP)

dsizeP :: Parser ([Located BareTypeParsed], Located Symbol)
dsizeP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  ([Located BareTypeParsed], LocSymbol)
dsizeP = ([Located BareTypeParsed]
 -> LocSymbol -> ([Located BareTypeParsed], LocSymbol))
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> ParserV LocSymbol LocSymbol
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     ([Located BareTypeParsed], LocSymbol)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,) (StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall v a. ParserV v a -> ParserV v a
parens (StateT
   (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
 -> StateT
      (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed])
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a b. (a -> b) -> a -> b
$ StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy (StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
forall v a. ParserV v a -> ParserV v (Located a)
located StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
genBareTypeP) StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma) ParserV LocSymbol LocSymbol
locBinderP


varianceP :: Parser Variance
varianceP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
varianceP = ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"bivariant"     ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Variance
Bivariant)
        StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"invariant"     ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Variance
Invariant)
        StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"covariant"     ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Variance
Covariant)
        StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"contravariant" ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Variance
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Variance
Contravariant)
        StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
-> [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Variance
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"Invalid variance annotation\t Use one of bivariant, invariant, covariant, contravariant"

tyBindsP :: Parser ([Located LHName], (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)]))
tyBindsP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  ([Located LHName],
   (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)]))
tyBindsP =
  StateT (PStateV LocSymbol) (Parsec Void [Char]) [Located LHName]
-> ParserV LocSymbol ()
-> Parser
     (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)])
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     ([Located LHName],
      (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)]))
forall x a y. Parser x -> Parser a -> Parser y -> Parser (x, y)
xyP (StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Located LHName]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy1 StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderThisModuleLHNameP StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma) ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"::") Parser (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)])
termBareTypeP

tyBindNoLocP :: Parser (LocSymbol, BareTypeParsed)
tyBindNoLocP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (LocSymbol, BareTypeParsed)
tyBindNoLocP = (Located BareTypeParsed -> BareTypeParsed)
-> (LocSymbol, Located BareTypeParsed)
-> (LocSymbol, BareTypeParsed)
forall b c d. (b -> c) -> (d, b) -> (d, c)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second Located BareTypeParsed -> BareTypeParsed
forall a. Located a -> a
val ((LocSymbol, Located BareTypeParsed)
 -> (LocSymbol, BareTypeParsed))
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (LocSymbol, Located BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (LocSymbol, BareTypeParsed)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (LocSymbol, Located BareTypeParsed)
tyBindP

-- | Parses a type signature as it occurs in "assume" and "assert" directives.
tyBindP :: Parser (LocSymbol, Located BareTypeParsed)
tyBindP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (LocSymbol, Located BareTypeParsed)
tyBindP =
  (,) (LocSymbol
 -> Located BareTypeParsed -> (LocSymbol, Located BareTypeParsed))
-> ParserV LocSymbol LocSymbol
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located BareTypeParsed -> (LocSymbol, Located BareTypeParsed))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserV LocSymbol LocSymbol
locBinderP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located BareTypeParsed -> (LocSymbol, Located BareTypeParsed))
-> ParserV LocSymbol ()
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located BareTypeParsed -> (LocSymbol, Located BareTypeParsed))
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"::" StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located BareTypeParsed -> (LocSymbol, Located BareTypeParsed))
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (LocSymbol, Located BareTypeParsed)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
forall v a. ParserV v a -> ParserV v (Located a)
located StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
genBareTypeP

tyBindLogicNameP :: Parser (Located LHName, Located BareTypeParsed)
tyBindLogicNameP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located BareTypeParsed)
tyBindLogicNameP =
  (,) (Located LHName
 -> Located BareTypeParsed
 -> (Located LHName, Located BareTypeParsed))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located BareTypeParsed
      -> (Located LHName, Located BareTypeParsed))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLogicNameP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located BareTypeParsed
   -> (Located LHName, Located BareTypeParsed))
-> ParserV LocSymbol ()
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located BareTypeParsed
      -> (Located LHName, Located BareTypeParsed))
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"::" StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located BareTypeParsed
   -> (Located LHName, Located BareTypeParsed))
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName, Located BareTypeParsed)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
forall v a. ParserV v a -> ParserV v (Located a)
located StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
genBareTypeP

tyBindLHNameP :: Parser (Located LHName, Located BareTypeParsed)
tyBindLHNameP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located BareTypeParsed)
tyBindLHNameP = do
    x <- StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP
    _ <- reservedOp "::"
    t <- located genBareTypeP
    return (x, t)

tyBindLocalLHNameP :: Parser (Located LHName, Located BareTypeParsed)
tyBindLocalLHNameP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located BareTypeParsed)
tyBindLocalLHNameP = do
    x <- StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderThisModuleLHNameP
    _ <- reservedOp "::"
    t <- located genBareTypeP
    return (x, t)

-- | Parses a loc symbol.
assmReflectBindP :: Parser (Located LHName, Located LHName)
assmReflectBindP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located LHName)
assmReflectBindP =
  (,) (Located LHName
 -> Located LHName -> (Located LHName, Located LHName))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName -> (Located LHName, Located LHName))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName -> (Located LHName, Located LHName))
-> ParserV LocSymbol ()
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName -> (Located LHName, Located LHName))
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"as" StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName -> (Located LHName, Located LHName))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located LHName, Located LHName)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP

termBareTypeP :: Parser (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)])
termBareTypeP :: Parser (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)])
termBareTypeP = do
  t <- StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
forall v a. ParserV v a -> ParserV v (Located a)
located StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
genBareTypeP
  termTypeP t <|> return (t, Nothing)

termTypeP :: Located BareTypeParsed -> Parser (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)])
termTypeP :: Located BareTypeParsed
-> Parser
     (Located BareTypeParsed, Maybe [Located (ExprV LocSymbol)])
termTypeP Located BareTypeParsed
t
  = do
       [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"/"
       es <- ParserV LocSymbol [Located (ExprV LocSymbol)]
-> ParserV LocSymbol [Located (ExprV LocSymbol)]
forall v a. ParserV v a -> ParserV v a
brackets (ParserV LocSymbol [Located (ExprV LocSymbol)]
 -> ParserV LocSymbol [Located (ExprV LocSymbol)])
-> ParserV LocSymbol [Located (ExprV LocSymbol)]
-> ParserV LocSymbol [Located (ExprV LocSymbol)]
forall a b. (a -> b) -> a -> b
$ StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located (ExprV LocSymbol))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> ParserV LocSymbol [Located (ExprV LocSymbol)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy (Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (ExprV LocSymbol))
forall v a. ParserV v a -> ParserV v (Located a)
located Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
exprP) StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma
       return (t, Just es)

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

invariantP :: Parser (Located BareTypeParsed)
invariantP :: StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
invariantP = StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
forall v a. ParserV v a -> ParserV v (Located a)
located StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
genBareTypeP

invaliasP :: Parser (Located BareTypeParsed, Located BareTypeParsed)
invaliasP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located BareTypeParsed, Located BareTypeParsed)
invaliasP
  = do t  <- StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
forall v a. ParserV v a -> ParserV v (Located a)
located StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
genBareTypeP
       reserved "as"
       ta <- located genBareTypeP
       return (t, ta)

genBareTypeP :: Parser BareTypeParsed
genBareTypeP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
genBareTypeP = StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP

embedP :: Parser (Located LHName, FTycon, TCArgs)
embedP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, FTycon, TCArgs)
embedP = do
  x <- LHNameSpace
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locUpperIdLHNameP LHNameSpace
LHTcName
  a <- try (reserved "*" >> return WithArgs) <|> return NoArgs -- TODO: reserved "*" looks suspicious
  _ <- reserved "as"
  t <- fTyConP
  return (x, t, a)
  --  = xyP locUpperIdP symbolTCArgs (reserved "as") fTyConP


aliasP :: Parser (Located (RTAlias Symbol BareTypeParsed))
aliasP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located (RTAlias Symbol BareTypeParsed))
aliasP  = (Symbol -> Symbol)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (RTAlias Symbol BareTypeParsed))
forall tv ty.
(Symbol -> tv) -> Parser ty -> Parser (Located (RTAlias tv ty))
rtAliasP Symbol -> Symbol
forall a. a -> a
id     StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located (RTAlias Symbol BareTypeParsed))
-> [Char]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (RTAlias Symbol BareTypeParsed))
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"aliasP"

ealiasP :: Parser (Located (RTAlias Symbol (ExprV LocSymbol)))
ealiasP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located (RTAlias Symbol (ExprV LocSymbol)))
ealiasP = StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located (RTAlias Symbol (ExprV LocSymbol)))
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (RTAlias Symbol (ExprV LocSymbol)))
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ((Symbol -> Symbol)
-> Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (RTAlias Symbol (ExprV LocSymbol)))
forall tv ty.
(Symbol -> tv) -> Parser ty -> Parser (Located (RTAlias tv ty))
rtAliasP Symbol -> Symbol
forall a. Symbolic a => a -> Symbol
symbol Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
predP)
      StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located (RTAlias Symbol (ExprV LocSymbol)))
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (RTAlias Symbol (ExprV LocSymbol)))
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (RTAlias Symbol (ExprV LocSymbol)))
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Symbol -> Symbol)
-> Parser (ExprV LocSymbol)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (RTAlias Symbol (ExprV LocSymbol)))
forall tv ty.
(Symbol -> tv) -> Parser ty -> Parser (Located (RTAlias tv ty))
rtAliasP Symbol -> Symbol
forall a. Symbolic a => a -> Symbol
symbol Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
exprP
      StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located (RTAlias Symbol (ExprV LocSymbol)))
-> [Char]
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located (RTAlias Symbol (ExprV LocSymbol)))
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"ealiasP"

-- | Parser for a LH type synonym.
rtAliasP :: (Symbol -> tv) -> Parser ty -> Parser (Located (RTAlias tv ty))
rtAliasP :: forall tv ty.
(Symbol -> tv) -> Parser ty -> Parser (Located (RTAlias tv ty))
rtAliasP Symbol -> tv
f Parser ty
bodyP
  = do pos  <- StateT (PStateV LocSymbol) (Parsec Void [Char]) SourcePos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m SourcePos
getSourcePos
       name <- upperIdP
       args <- many aliasIdP
       reservedOp "="
       body <- bodyP
       posE <- getSourcePos
       let (tArgs, vArgs) = partition (isSmall . headSym) args
       return $ Loc pos posE (RTA name (f <$> tArgs) vArgs body)

logDefineP :: Parser BPspec
logDefineP :: ParserV LocSymbol BPspec
logDefineP =
    do s <- StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP
       args <- many locSymbolP
       reservedOp "="
       e <- exprP <|> predP
       return (Define (s, (val <$> args, e)))

hmeasureP :: Parser BPspec
hmeasureP :: ParserV LocSymbol BPspec
hmeasureP = do
  ParserV LocSymbol ()
forall v. ParserV v ()
setLayout
  do b <- StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLogicNameP StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"::")
     ty <- located genBareTypeP
     popLayout >> popLayout
     eqns <- block $ try $ measureDefP LHLogicNameBinder (rawBodyP <|> tyBodyP ty)
     return (Meas $ Measure.mkM b ty eqns MsMeasure mempty)
    ParserV LocSymbol BPspec
-> ParserV LocSymbol BPspec -> ParserV LocSymbol BPspec
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
   do b <- StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP
      popLayout >> popLayout >> return (HMeas b)

iMeasureP :: Parser (MeasureV LocSymbol (Located BareTypeParsed) (Located LHName))
iMeasureP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (MeasureV LocSymbol (Located BareTypeParsed) (Located LHName))
iMeasureP = do
  (x, ty) <- StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (LocSymbol, Located BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (LocSymbol, Located BareTypeParsed)
forall v a. ParserV v a -> ParserV v a
indentedLine StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (LocSymbol, Located BareTypeParsed)
tyBindP
  _ <- optional semi
  eqns    <- block $ measureDefP LHLogicName (rawBodyP <|> tyBodyP ty)
  return   $ Measure.mkM (makeUnresolvedLHName LHLogicName <$> x) ty eqns MsMeasure mempty

-- | class measure
cMeasureP :: Parser (MeasureV LocSymbol (Located BareTypeParsed) ())
cMeasureP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (MeasureV LocSymbol (Located BareTypeParsed) ())
cMeasureP
  = do (x, ty) <- StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located BareTypeParsed)
tyBindLogicNameP
       return $ Measure.mkM x ty [] MsClass mempty

oneClassArg :: Parser [Located BareTypeParsed]
oneClassArg :: StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
oneClassArg
  = Located BareTypeParsed -> [Located BareTypeParsed]
forall a. a -> [a]
sing (Located BareTypeParsed -> [Located BareTypeParsed])
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
forall v a. ParserV v a -> ParserV v (Located a)
located (BTyCon -> [BTyVar] -> BareTypeParsed
forall {c} {tv} {v} {v}.
c -> [tv] -> RTypeV v c tv (UReftV v (ReftV v))
rit (BTyCon -> [BTyVar] -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     ([BTyVar] -> BareTypeParsed)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) BTyCon
classBTyConP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  ([BTyVar] -> BareTypeParsed)
-> Parser [BTyVar]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((Located BTyVar -> BTyVar) -> [Located BTyVar] -> [BTyVar]
forall a b. (a -> b) -> [a] -> [b]
map Located BTyVar -> BTyVar
forall a. Located a -> a
val ([Located BTyVar] -> [BTyVar])
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Located BTyVar]
-> Parser [BTyVar]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Located BTyVar]
forall {v}.
StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
classParams))
  where
    rit :: c -> [tv] -> RTypeV v c tv (UReftV v (ReftV v))
rit c
t [tv]
as    = c
-> [RTypeV v c tv (UReftV v (ReftV v))]
-> [RTPropV v c tv (UReftV v (ReftV v))]
-> UReftV v (ReftV v)
-> RTypeV v c tv (UReftV v (ReftV v))
forall v c tv r.
c
-> [RTypeV v c tv r] -> [RTPropV v c tv r] -> r -> RTypeV v c tv r
RApp c
t ((tv -> UReftV v (ReftV v) -> RTypeV v c tv (UReftV v (ReftV v))
forall v c tv r. tv -> r -> RTypeV v c tv r
`RVar` UReftV v (ReftV v)
forall v. UReftV v (ReftV v)
trueURef) (tv -> RTypeV v c tv (UReftV v (ReftV v)))
-> [tv] -> [RTypeV v c tv (UReftV v (ReftV v))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [tv]
as) [] UReftV v (ReftV v)
forall v. UReftV v (ReftV v)
trueURef
    classParams :: StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
classParams =  ([Char] -> ParserV v ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"where" ParserV v ()
-> StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
-> StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
forall a b.
StateT (PStateV v) (Parsec Void [Char]) a
-> StateT (PStateV v) (Parsec Void [Char]) b
-> StateT (PStateV v) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Located BTyVar]
-> StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
forall a. a -> StateT (PStateV v) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return [])
               StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
-> StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
-> StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
forall a.
StateT (PStateV v) (Parsec Void [Char]) a
-> StateT (PStateV v) (Parsec Void [Char]) a
-> StateT (PStateV v) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((:) (Located BTyVar -> [Located BTyVar] -> [Located BTyVar])
-> StateT (PStateV v) (Parsec Void [Char]) (Located BTyVar)
-> StateT
     (PStateV v)
     (Parsec Void [Char])
     ([Located BTyVar] -> [Located BTyVar])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\LocSymbol
ls -> LocSymbol -> BTyVar
bTyVar LocSymbol
ls BTyVar -> LocSymbol -> Located BTyVar
forall a b. a -> Located b -> Located a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ LocSymbol
ls) (LocSymbol -> Located BTyVar)
-> StateT (PStateV v) (Parsec Void [Char]) LocSymbol
-> StateT (PStateV v) (Parsec Void [Char]) (Located BTyVar)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV v) (Parsec Void [Char]) LocSymbol
forall v. ParserV v LocSymbol
locLowerIdP) StateT
  (PStateV v)
  (Parsec Void [Char])
  ([Located BTyVar] -> [Located BTyVar])
-> StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
-> StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
forall a b.
StateT (PStateV v) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV v) (Parsec Void [Char]) a
-> StateT (PStateV v) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT (PStateV v) (Parsec Void [Char]) [Located BTyVar]
classParams)
    sing :: a -> [a]
sing a
x      = [a
x]


superP :: Parser (Located BareTypeParsed)
superP :: StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
superP = StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
forall v a. ParserV v a -> ParserV v (Located a)
located (BareTypeParsed -> BareTypeParsed
forall a. a -> a
toRCls (BareTypeParsed -> BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareAtomBindP)
  where toRCls :: p -> p
toRCls p
x = p
x

instanceP :: Parser (RInstance (Located BareTypeParsed))
instanceP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (RInstance (Located BareTypeParsed))
instanceP
  = do _    <- StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
supersP
       c    <- classBTyConP
       tvs  <- try oneClassArg <|> manyTill iargsP (try $ reserved "where")
       ms   <- block riMethodSigP
       return $ RI c Nothing tvs ms
  where
    supersP :: StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
supersP  = StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ((StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall v a. ParserV v a -> ParserV v a
parens (StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
superP StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
`sepBy1` StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma) StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Located BareTypeParsed -> [Located BareTypeParsed])
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located BareTypeParsed -> [Located BareTypeParsed]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
superP)
                       StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> ParserV LocSymbol ()
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"=>")
               StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []

    iargsP :: StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
iargsP   =   (BTyVar -> Located BareTypeParsed
forall {tv} {v} {c} {v} {v}.
tv -> Located (RTypeV v c tv (UReftV v (ReftV v)))
mkVar (BTyVar -> Located BareTypeParsed)
-> (LocSymbol -> BTyVar) -> LocSymbol -> Located BareTypeParsed
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocSymbol -> BTyVar
bTyVar (LocSymbol -> Located BareTypeParsed)
-> ParserV LocSymbol LocSymbol
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol -> ParserV LocSymbol LocSymbol
forall v a. ParserV v a -> ParserV v (Located a)
located Parser Symbol
tyVarIdP)
            StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
forall v a. ParserV v a -> ParserV v a
parens (StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
forall v a. ParserV v a -> ParserV v (Located a)
located StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP)


    mkVar :: tv -> Located (RTypeV v c tv (UReftV v (ReftV v)))
mkVar tv
v  = RTypeV v c tv (UReftV v (ReftV v))
-> Located (RTypeV v c tv (UReftV v (ReftV v)))
forall a. a -> Located a
dummyLoc (RTypeV v c tv (UReftV v (ReftV v))
 -> Located (RTypeV v c tv (UReftV v (ReftV v))))
-> RTypeV v c tv (UReftV v (ReftV v))
-> Located (RTypeV v c tv (UReftV v (ReftV v)))
forall a b. (a -> b) -> a -> b
$ tv -> UReftV v (ReftV v) -> RTypeV v c tv (UReftV v (ReftV v))
forall v c tv r. tv -> r -> RTypeV v c tv r
RVar tv
v (ReftV v -> UReftV v (ReftV v)
forall r v. r -> UReftV v r
uTop ReftV v
forall v. ReftV v
trueReft)


riMethodSigP :: Parser (Located LHName, RISig (Located BareTypeParsed))
riMethodSigP :: ParserV LocSymbol (Located LHName, RISig (Located BareTypeParsed))
riMethodSigP
  = ParserV LocSymbol (Located LHName, RISig (Located BareTypeParsed))
-> ParserV
     LocSymbol (Located LHName, RISig (Located BareTypeParsed))
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (do [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"assume"
            (x, t) <- StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located BareTypeParsed)
tyBindLHNameP
            return (x, RIAssumed t) )
 ParserV LocSymbol (Located LHName, RISig (Located BareTypeParsed))
-> ParserV
     LocSymbol (Located LHName, RISig (Located BareTypeParsed))
-> ParserV
     LocSymbol (Located LHName, RISig (Located BareTypeParsed))
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> do (x, t) <- StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located BareTypeParsed)
tyBindLHNameP
        return (x, RISig t)
 ParserV LocSymbol (Located LHName, RISig (Located BareTypeParsed))
-> [Char]
-> ParserV
     LocSymbol (Located LHName, RISig (Located BareTypeParsed))
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"riMethodSigP"

classP :: Parser (RClass (Located BareTypeParsed))
classP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (RClass (Located BareTypeParsed))
classP
  = do sups <- StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
supersP
       c    <- classBTyConP
       tvs  <- manyTill (bTyVar <$> located tyVarIdP) (try $ reserved "where")
       ms   <- block tyBindLHNameP -- <|> sepBy tyBindP semi
       return $ RClass c sups tvs ms
  where
    supersP :: StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
supersP  = StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ((StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall v a. ParserV v a -> ParserV v a
parens (StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
superP StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
`sepBy1` StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma) StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Located BareTypeParsed -> [Located BareTypeParsed])
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a b.
(a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located BareTypeParsed -> [Located BareTypeParsed]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Located BareTypeParsed)
superP)
                       StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> ParserV LocSymbol ()
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"=>")
               StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Located BareTypeParsed]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [Located BareTypeParsed]
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []

rawBodyP :: Parser (BodyV LocSymbol)
rawBodyP :: Parser (BodyV LocSymbol)
rawBodyP
  = Parser (BodyV LocSymbol) -> Parser (BodyV LocSymbol)
forall v a. ParserV v a -> ParserV v a
braces (Parser (BodyV LocSymbol) -> Parser (BodyV LocSymbol))
-> Parser (BodyV LocSymbol) -> Parser (BodyV LocSymbol)
forall a b. (a -> b) -> a -> b
$ do
      v <- Parser Symbol
forall v. ParserV v Symbol
symbolP
      reservedOp "|"
      R v <$> predP

tyBodyP :: Located BareTypeParsed -> Parser (BodyV LocSymbol)
tyBodyP :: Located BareTypeParsed -> Parser (BodyV LocSymbol)
tyBodyP Located BareTypeParsed
ty
  = case BareTypeParsed -> Maybe BareTypeParsed
forall {v} {c} {tv} {r}. RTypeV v c tv r -> Maybe (RTypeV v c tv r)
outTy (Located BareTypeParsed -> BareTypeParsed
forall a. Located a -> a
val Located BareTypeParsed
ty) of
      Just BareTypeParsed
bt | BareTypeParsed -> Bool
forall v t t1. RTypeV v BTyCon t t1 -> Bool
isPropBareType BareTypeParsed
bt
                -> ExprV LocSymbol -> BodyV LocSymbol
forall v. ExprV v -> BodyV v
P (ExprV LocSymbol -> BodyV LocSymbol)
-> Parser (ExprV LocSymbol) -> Parser (BodyV LocSymbol)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
predP
      Maybe BareTypeParsed
_         -> ExprV LocSymbol -> BodyV LocSymbol
forall v. ExprV v -> BodyV v
E (ExprV LocSymbol -> BodyV LocSymbol)
-> Parser (ExprV LocSymbol) -> Parser (BodyV LocSymbol)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (ExprV LocSymbol)
forall {v}.
ParseableV v =>
StateT (PStateV v) (Parsec Void [Char]) (ExprV v)
exprP
    where outTy :: RTypeV v c tv r -> Maybe (RTypeV v c tv r)
outTy (RAllT RTVUV v c tv
_ RTypeV v c tv r
t r
_)    = RTypeV v c tv r -> Maybe (RTypeV v c tv r)
outTy RTypeV v c tv r
t
          outTy (RAllP PVUV v c tv
_ RTypeV v c tv r
t)      = RTypeV v c tv r -> Maybe (RTypeV v c tv r)
outTy RTypeV v c tv r
t
          outTy (RFun Symbol
_ RFInfo
_ RTypeV v c tv r
_ RTypeV v c tv r
t r
_) = RTypeV v c tv r -> Maybe (RTypeV v c tv r)
forall a. a -> Maybe a
Just RTypeV v c tv r
t
          outTy RTypeV v c tv r
_                = Maybe (RTypeV v c tv r)
forall {a}. Maybe a
Nothing

locUpperOrInfixIdP :: Parser (Located Symbol)
locUpperOrInfixIdP :: ParserV LocSymbol LocSymbol
locUpperOrInfixIdP = ParserV LocSymbol LocSymbol
locUpperIdP' ParserV LocSymbol LocSymbol
-> ParserV LocSymbol LocSymbol -> ParserV LocSymbol LocSymbol
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserV LocSymbol LocSymbol
locInfixCondIdP

locBinderP :: Parser (Located Symbol)
locBinderP :: ParserV LocSymbol LocSymbol
locBinderP =
  Parser Symbol -> ParserV LocSymbol LocSymbol
forall v a. ParserV v a -> ParserV v (Located a)
located Parser Symbol
binderP -- TODO

locBinderLogicNameP :: Parser (Located LHName)
locBinderLogicNameP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLogicNameP =
  (Symbol -> LHName) -> LocSymbol -> Located LHName
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName LHNameSpace
LHLogicNameBinder) (LocSymbol -> Located LHName)
-> ParserV LocSymbol LocSymbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol -> ParserV LocSymbol LocSymbol
forall v a. ParserV v a -> ParserV v (Located a)
located Parser Symbol
binderP

locBinderLHNameP :: Parser (Located LHName)
locBinderLHNameP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP =
  ParserV LocSymbol LHName
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
forall v a. ParserV v a -> ParserV v (Located a)
located (ParserV LocSymbol LHName
 -> StateT
      (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName))
-> ParserV LocSymbol LHName
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
forall a b. (a -> b) -> a -> b
$ LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName (LHThisModuleNameFlag -> LHNameSpace
LHVarName LHThisModuleNameFlag
LHAnyModuleNameF) (Symbol -> LHName) -> Parser Symbol -> ParserV LocSymbol LHName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
binderP

locBinderThisModuleLHNameP :: Parser (Located LHName)
locBinderThisModuleLHNameP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderThisModuleLHNameP =
  ParserV LocSymbol LHName
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
forall v a. ParserV v a -> ParserV v (Located a)
located (ParserV LocSymbol LHName
 -> StateT
      (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName))
-> ParserV LocSymbol LHName
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
forall a b. (a -> b) -> a -> b
$ LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName (LHThisModuleNameFlag -> LHNameSpace
LHVarName LHThisModuleNameFlag
LHThisModuleNameF) (Symbol -> LHName) -> Parser Symbol -> ParserV LocSymbol LHName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
binderP

-- | LHS of the thing being defined
--
-- TODO, Andres: this is still very broken
--
{-
binderP :: Parser Symbol
binderP    = pwr    <$> parens (idP bad)
         <|> symbol <$> idP badc
  where
    idP p  = takeWhile1P Nothing (not . p)
    badc c = (c == ':') || (c == ',') || bad c
    bad c  = isSpace c || c `elem` ("(,)[]" :: String)
    pwr s  = symbol $ "(" `mappend` s `mappend` ")"
-}
binderP :: Parser Symbol
binderP :: Parser Symbol
binderP =
      Parser Symbol -> Parser Symbol
forall v a. ParserV v a -> ParserV v a
parens Parser Symbol
infixBinderIdP
  Parser Symbol -> Parser Symbol -> Parser Symbol
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Symbol
binderIdP
  -- Note: It is important that we do *not* use the LH/fixpoint reserved words here,
  -- because, for example, we must be able to use "assert" as an identifier.

measureDefP :: LHNameSpace -> Parser (BodyV LocSymbol) -> Parser (DefV LocSymbol (Located BareTypeParsed) (Located LHName))
measureDefP :: LHNameSpace
-> Parser (BodyV LocSymbol)
-> ParserV
     LocSymbol
     (DefV LocSymbol (Located BareTypeParsed) (Located LHName))
measureDefP LHNameSpace
ns Parser (BodyV LocSymbol)
bodyP
  = do mname   <- (Symbol -> LHName) -> LocSymbol -> Located LHName
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName LHNameSpace
ns) (LocSymbol -> Located LHName)
-> ParserV LocSymbol LocSymbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserV LocSymbol LocSymbol
forall v. ParserV v LocSymbol
locSymbolP
       (c, xs) <- measurePatP
       reservedOp "="
       body    <- bodyP
       let xs'  = Symbol -> Symbol
forall a. Symbolic a => a -> Symbol
symbol (Symbol -> Symbol) -> (LocSymbol -> Symbol) -> LocSymbol -> Symbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocSymbol -> Symbol
forall a. Located a -> a
val (LocSymbol -> Symbol) -> [LocSymbol] -> [Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [LocSymbol]
xs
       return   $ Def mname c Nothing ((, Nothing) <$> xs') body

measurePatP :: Parser (Located LHName, [LocSymbol])
measurePatP :: Parser (Located LHName, [LocSymbol])
measurePatP
  =  Parser (Located LHName, [LocSymbol])
-> Parser (Located LHName, [LocSymbol])
forall v a. ParserV v a -> ParserV v a
parens (Parser (Located LHName, [LocSymbol])
-> Parser (Located LHName, [LocSymbol])
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser (Located LHName, [LocSymbol])
conPatP Parser (Located LHName, [LocSymbol])
-> Parser (Located LHName, [LocSymbol])
-> Parser (Located LHName, [LocSymbol])
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Located LHName, [LocSymbol])
-> Parser (Located LHName, [LocSymbol])
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser (Located LHName, [LocSymbol])
consPatP Parser (Located LHName, [LocSymbol])
-> Parser (Located LHName, [LocSymbol])
-> Parser (Located LHName, [LocSymbol])
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Located LHName, [LocSymbol])
forall t. Parser (Located LHName, [t])
nilPatP Parser (Located LHName, [LocSymbol])
-> Parser (Located LHName, [LocSymbol])
-> Parser (Located LHName, [LocSymbol])
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Located LHName, [LocSymbol])
tupPatP)
 Parser (Located LHName, [LocSymbol])
-> Parser (Located LHName, [LocSymbol])
-> Parser (Located LHName, [LocSymbol])
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Located LHName, [LocSymbol])
forall t. Parser (Located LHName, [t])
nullaryConPatP
 Parser (Located LHName, [LocSymbol])
-> [Char] -> Parser (Located LHName, [LocSymbol])
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"measurePatP"

tupPatP :: Parser (Located LHName, [Located Symbol])
tupPatP :: Parser (Located LHName, [LocSymbol])
tupPatP  = Located [LocSymbol] -> (Located LHName, [LocSymbol])
forall (t :: * -> *) a.
Foldable t =>
Located (t a) -> (Located LHName, t a)
mkTupPat  (Located [LocSymbol] -> (Located LHName, [LocSymbol]))
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located [LocSymbol])
-> Parser (Located LHName, [LocSymbol])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) [LocSymbol]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located [LocSymbol])
forall v a. ParserV v a -> ParserV v (Located a)
located (ParserV LocSymbol LocSymbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [LocSymbol]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy1 ParserV LocSymbol LocSymbol
forall v. ParserV v LocSymbol
locLowerIdP StateT (PStateV LocSymbol) (Parsec Void [Char]) [Char]
forall v. ParserV v [Char]
comma)

conPatP :: Parser (Located LHName, [Located Symbol])
conPatP :: Parser (Located LHName, [LocSymbol])
conPatP  = (,)       (Located LHName -> [LocSymbol] -> (Located LHName, [LocSymbol]))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     ([LocSymbol] -> (Located LHName, [LocSymbol]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
dataConLHNameP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  ([LocSymbol] -> (Located LHName, [LocSymbol]))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [LocSymbol]
-> Parser (Located LHName, [LocSymbol])
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParserV LocSymbol LocSymbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [LocSymbol]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many ParserV LocSymbol LocSymbol
forall v. ParserV v LocSymbol
locLowerIdP

consPatP :: Parser (Located LHName, [Located Symbol])
consPatP :: Parser (Located LHName, [LocSymbol])
consPatP = LocSymbol
-> Located () -> LocSymbol -> (Located LHName, [LocSymbol])
forall t1 t. t1 -> Located t -> t1 -> (Located LHName, [t1])
mkConsPat (LocSymbol
 -> Located () -> LocSymbol -> (Located LHName, [LocSymbol]))
-> ParserV LocSymbol LocSymbol
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (Located () -> LocSymbol -> (Located LHName, [LocSymbol]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserV LocSymbol LocSymbol
forall v. ParserV v LocSymbol
locLowerIdP  StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located () -> LocSymbol -> (Located LHName, [LocSymbol]))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located ())
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (LocSymbol -> (Located LHName, [LocSymbol]))
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located ())
forall v a. ParserV v a -> ParserV v (Located a)
located ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
":") StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (LocSymbol -> (Located LHName, [LocSymbol]))
-> ParserV LocSymbol LocSymbol
-> Parser (Located LHName, [LocSymbol])
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParserV LocSymbol LocSymbol
forall v. ParserV v LocSymbol
locLowerIdP

nilPatP :: Parser (Located LHName, [t])
nilPatP :: forall t. Parser (Located LHName, [t])
nilPatP  = Located () -> (Located LHName, [t])
forall t t1. Located t -> (Located LHName, [t1])
mkNilPat  (Located () -> (Located LHName, [t]))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located ())
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName, [t])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located ())
forall v a. ParserV v a -> ParserV v (Located a)
located (ParserV LocSymbol () -> ParserV LocSymbol ()
forall v a. ParserV v a -> ParserV v a
brackets (() -> ParserV LocSymbol ()
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()))

nullaryConPatP :: Parser (Located LHName, [t])
nullaryConPatP :: forall t. Parser (Located LHName, [t])
nullaryConPatP = Parser (Located LHName, [t])
forall t. Parser (Located LHName, [t])
nilPatP Parser (Located LHName, [t])
-> Parser (Located LHName, [t]) -> Parser (Located LHName, [t])
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((,[]) (Located LHName -> (Located LHName, [t]))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
-> Parser (Located LHName, [t])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
dataConLHNameP)
                 Parser (Located LHName, [t])
-> [Char] -> Parser (Located LHName, [t])
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"nullaryConPatP"

mkTupPat :: Foldable t => Located (t a) -> (Located LHName, t a)
mkTupPat :: forall (t :: * -> *) a.
Foldable t =>
Located (t a) -> (Located LHName, t a)
mkTupPat Located (t a)
lzs =
    let tupledDC :: DataCon
tupledDC = Boxity -> Int -> DataCon
GHC.tupleDataCon Boxity
GHC.Boxed (t a -> Int
forall a. t a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Located (t a) -> t a
forall a. Located a -> a
val Located (t a)
lzs))
     in (Name -> Symbol -> LHName
makeGHCLHName (DataCon -> Name
forall a. NamedThing a => a -> Name
GHC.getName DataCon
tupledDC) (DataCon -> Symbol
forall a. Symbolic a => a -> Symbol
symbol DataCon
tupledDC) LHName -> Located (t a) -> Located LHName
forall a b. a -> Located b -> Located a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Located (t a)
lzs, Located (t a) -> t a
forall a. Located a -> a
val Located (t a)
lzs)

mkNilPat :: Located t -> (Located LHName, [t1])
mkNilPat :: forall t t1. Located t -> (Located LHName, [t1])
mkNilPat Located t
lx     = (Name -> Symbol -> LHName
makeGHCLHName (DataCon -> Name
forall a. NamedThing a => a -> Name
GHC.getName DataCon
GHC.nilDataCon) (DataCon -> Symbol
forall a. Symbolic a => a -> Symbol
symbol DataCon
GHC.nilDataCon) LHName -> Located t -> Located LHName
forall a b. a -> Located b -> Located a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Located t
lx, [])

mkConsPat :: t1 -> Located t -> t1 -> (Located LHName, [t1])
mkConsPat :: forall t1 t. t1 -> Located t -> t1 -> (Located LHName, [t1])
mkConsPat t1
x Located t
lc t1
y = (Name -> Symbol -> LHName
makeGHCLHName (DataCon -> Name
forall a. NamedThing a => a -> Name
GHC.getName DataCon
GHC.consDataCon) (DataCon -> Symbol
forall a. Symbolic a => a -> Symbol
symbol DataCon
GHC.consDataCon) LHName -> Located t -> Located LHName
forall a b. a -> Located b -> Located a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Located t
lc, [t1
x, t1
y])

-------------------------------------------------------------------------------
--------------------------------- Predicates ----------------------------------
-------------------------------------------------------------------------------

dataConFieldsP :: Parser [(LHName, BareTypeParsed)]
dataConFieldsP :: Parser [(LHName, BareTypeParsed)]
dataConFieldsP
   = ((Symbol, BareTypeParsed) -> (LHName, BareTypeParsed))
-> [(Symbol, BareTypeParsed)] -> [(LHName, BareTypeParsed)]
forall a b. (a -> b) -> [a] -> [b]
map ((Symbol -> LHName)
-> (Symbol, BareTypeParsed) -> (LHName, BareTypeParsed)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName LHNameSpace
LHLogicNameBinder)) ([(Symbol, BareTypeParsed)] -> [(LHName, BareTypeParsed)])
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
-> Parser [(LHName, BareTypeParsed)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
     (ParserV LocSymbol (Symbol, BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
forall v a. ParserV v a -> ParserV v [a]
explicitCommaBlock ParserV LocSymbol (Symbol, BareTypeParsed)
predTypeDDP -- braces (sepBy predTypeDDP comma)
       StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserV LocSymbol (Symbol, BareTypeParsed)
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many ParserV LocSymbol (Symbol, BareTypeParsed)
dataConFieldP
       StateT
  (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
-> [Char]
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) [(Symbol, BareTypeParsed)]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"dataConFieldP"
     )

dataConFieldP :: Parser (Symbol, BareTypeParsed)
dataConFieldP :: ParserV LocSymbol (Symbol, BareTypeParsed)
dataConFieldP
   =  ParserV LocSymbol (Symbol, BareTypeParsed)
-> ParserV LocSymbol (Symbol, BareTypeParsed)
forall v a. ParserV v a -> ParserV v a
parens (ParserV LocSymbol (Symbol, BareTypeParsed)
-> ParserV LocSymbol (Symbol, BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ParserV LocSymbol (Symbol, BareTypeParsed)
predTypeDDP ParserV LocSymbol (Symbol, BareTypeParsed)
-> ParserV LocSymbol (Symbol, BareTypeParsed)
-> ParserV LocSymbol (Symbol, BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserV LocSymbol (Symbol, BareTypeParsed)
dbTypeP)
  ParserV LocSymbol (Symbol, BareTypeParsed)
-> ParserV LocSymbol (Symbol, BareTypeParsed)
-> ParserV LocSymbol (Symbol, BareTypeParsed)
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserV LocSymbol (Symbol, BareTypeParsed)
dbTyArgP -- unparenthesised constructor fields must be "atomic"
  ParserV LocSymbol (Symbol, BareTypeParsed)
-> [Char] -> ParserV LocSymbol (Symbol, BareTypeParsed)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"dataConFieldP"
  where
    dbTypeP :: ParserV LocSymbol (Symbol, BareTypeParsed)
dbTypeP = (,) (Symbol -> BareTypeParsed -> (Symbol, BareTypeParsed))
-> Parser Symbol
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (BareTypeParsed -> (Symbol, BareTypeParsed))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
dummyBindP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (BareTypeParsed -> (Symbol, BareTypeParsed))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> ParserV LocSymbol (Symbol, BareTypeParsed)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP
    dbTyArgP :: ParserV LocSymbol (Symbol, BareTypeParsed)
dbTyArgP = (,) (Symbol -> BareTypeParsed -> (Symbol, BareTypeParsed))
-> Parser Symbol
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (BareTypeParsed -> (Symbol, BareTypeParsed))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
dummyBindP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (BareTypeParsed -> (Symbol, BareTypeParsed))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> ParserV LocSymbol (Symbol, BareTypeParsed)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTyArgP

predTypeDDP :: Parser (Symbol, BareTypeParsed)
predTypeDDP :: ParserV LocSymbol (Symbol, BareTypeParsed)
predTypeDDP = (,) (Symbol -> BareTypeParsed -> (Symbol, BareTypeParsed))
-> Parser Symbol
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     (BareTypeParsed -> (Symbol, BareTypeParsed))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
bbindP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (BareTypeParsed -> (Symbol, BareTypeParsed))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> ParserV LocSymbol (Symbol, BareTypeParsed)
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP

bbindP   :: Parser Symbol
bbindP :: Parser Symbol
bbindP   = Parser Symbol
forall v. ParserV v Symbol
lowerIdP Parser Symbol -> ParserV LocSymbol () -> Parser Symbol
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"::"

tyConBindLHNameP :: Parser (Located LHName)
tyConBindLHNameP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
tyConBindLHNameP = LHNameSpace
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locUpperIdLHNameP LHNameSpace
LHTcName

dataConP :: [Symbol] -> Parser DataCtorParsed
dataConP :: [Symbol] -> Parser DataCtorParsed
dataConP [Symbol]
as = do
  x   <- StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
dataConLHNameP
  xts <- dataConFieldsP
  return $ DataCtor x as [] xts Nothing

adtDataConP :: [Symbol] -> Parser DataCtorParsed
adtDataConP :: [Symbol] -> Parser DataCtorParsed
adtDataConP [Symbol]
as = do
  x     <- StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
dataConLHNameP
  reservedOp "::"
  tr    <- toRTypeRep <$> bareTypeP
  return $ DataCtor x (tRepVars as tr) [] (tRepFields tr) (Just $ ty_res tr)

tRepVars :: Symbolic a => [Symbol] -> RTypeRepV v c a r -> [Symbol]
tRepVars :: forall a v c r.
Symbolic a =>
[Symbol] -> RTypeRepV v c a r -> [Symbol]
tRepVars [Symbol]
as RTypeRepV v c a r
tr = case (RTVar a (RTypeV v c a ()), r) -> RTVar a (RTypeV v c a ())
forall a b. (a, b) -> a
fst ((RTVar a (RTypeV v c a ()), r) -> RTVar a (RTypeV v c a ()))
-> [(RTVar a (RTypeV v c a ()), r)] -> [RTVar a (RTypeV v c a ())]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RTypeRepV v c a r -> [(RTVar a (RTypeV v c a ()), r)]
forall v c tv r.
RTypeRepV v c tv r -> [(RTVar tv (RTypeV v c tv ()), r)]
ty_vars RTypeRepV v c a r
tr of
  [] -> [Symbol]
as
  [RTVar a (RTypeV v c a ())]
vs -> a -> Symbol
forall a. Symbolic a => a -> Symbol
symbol (a -> Symbol)
-> (RTVar a (RTypeV v c a ()) -> a)
-> RTVar a (RTypeV v c a ())
-> Symbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RTVar a (RTypeV v c a ()) -> a
forall tv s. RTVar tv s -> tv
ty_var_value (RTVar a (RTypeV v c a ()) -> Symbol)
-> [RTVar a (RTypeV v c a ())] -> [Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [RTVar a (RTypeV v c a ())]
vs

tRepFields :: RTypeRepV v c tv r -> [(LHName, RTypeV v c tv r)]
tRepFields :: forall v c tv r. RTypeRepV v c tv r -> [(LHName, RTypeV v c tv r)]
tRepFields RTypeRepV v c tv r
tr = [LHName] -> [RTypeV v c tv r] -> [(LHName, RTypeV v c tv r)]
forall a b. [a] -> [b] -> [(a, b)]
zip ((Symbol -> LHName) -> [Symbol] -> [LHName]
forall a b. (a -> b) -> [a] -> [b]
map (LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName LHNameSpace
LHLogicNameBinder) ([Symbol] -> [LHName]) -> [Symbol] -> [LHName]
forall a b. (a -> b) -> a -> b
$ RTypeRepV v c tv r -> [Symbol]
forall v c tv r. RTypeRepV v c tv r -> [Symbol]
ty_binds RTypeRepV v c tv r
tr) (RTypeRepV v c tv r -> [RTypeV v c tv r]
forall v c tv r. RTypeRepV v c tv r -> [RTypeV v c tv r]
ty_args RTypeRepV v c tv r
tr)

-- TODO: fix Located
dataConNameP :: Parser (Located Symbol)
dataConNameP :: ParserV LocSymbol LocSymbol
dataConNameP
  =  Parser Symbol -> ParserV LocSymbol LocSymbol
forall v a. ParserV v a -> ParserV v (Located a)
located
 (   Parser Symbol -> Parser Symbol
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser Symbol
forall v. ParserV v Symbol
upperIdP
 Parser Symbol -> Parser Symbol -> Parser Symbol
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Tokens [Char] -> Symbol
forall a. Symbolic a => a -> Symbol
pwr (Tokens [Char] -> Symbol)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Tokens [Char])
-> Parser Symbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Tokens [Char])
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Tokens [Char])
forall v a. ParserV v a -> ParserV v a
parens ((Token [Char] -> Bool)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Tokens [Char])
forall {e} {s} {m :: * -> *}.
MonadParsec e s m =>
(Token s -> Bool) -> m (Tokens s)
idP Char -> Bool
Token [Char] -> Bool
bad)
 Parser Symbol -> [Char] -> Parser Symbol
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"dataConNameP"
 )
  where
     idP :: (Token s -> Bool) -> m (Tokens s)
idP Token s -> Bool
p  = Maybe [Char] -> (Token s -> Bool) -> m (Tokens s)
forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe [Char] -> (Token s -> Bool) -> m (Tokens s)
takeWhile1P Maybe [Char]
forall {a}. Maybe a
Nothing (Bool -> Bool
not (Bool -> Bool) -> (Token s -> Bool) -> Token s -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Token s -> Bool
p)
     bad :: Char -> Bool
bad Char
c  = Char -> Bool
isSpace Char
c Bool -> Bool -> Bool
|| Char
c Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` ([Char]
"(,)" :: String)
     pwr :: a -> Symbol
pwr a
s  = a -> Symbol
forall a. Symbolic a => a -> Symbol
symbol a
s

dataConLHNameP :: Parser (Located LHName)
dataConLHNameP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
dataConLHNameP = (Symbol -> LHName) -> LocSymbol -> Located LHName
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName (LHThisModuleNameFlag -> LHNameSpace
LHDataConName LHThisModuleNameFlag
LHAnyModuleNameF)) (LocSymbol -> Located LHName)
-> ParserV LocSymbol LocSymbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserV LocSymbol LocSymbol
dataConNameP

dataSizeP :: Parser (Maybe (SizeFunV LocSymbol))
dataSizeP :: Parser (Maybe (SizeFunV LocSymbol))
dataSizeP
  = Parser (Maybe (SizeFunV LocSymbol))
-> Parser (Maybe (SizeFunV LocSymbol))
forall v a. ParserV v a -> ParserV v a
brackets (SizeFunV LocSymbol -> Maybe (SizeFunV LocSymbol)
forall a. a -> Maybe a
Just (SizeFunV LocSymbol -> Maybe (SizeFunV LocSymbol))
-> (Located LocSymbol -> SizeFunV LocSymbol)
-> Located LocSymbol
-> Maybe (SizeFunV LocSymbol)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Located LocSymbol -> SizeFunV LocSymbol
forall v. Located v -> SizeFunV v
SymSizeFun (Located LocSymbol -> Maybe (SizeFunV LocSymbol))
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located LocSymbol)
-> Parser (Maybe (SizeFunV LocSymbol))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserV LocSymbol LocSymbol
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Located LocSymbol)
forall v a. ParserV v a -> ParserV v (Located a)
located ParserV LocSymbol LocSymbol
forall v. ParserV v LocSymbol
locLowerIdP)
  Parser (Maybe (SizeFunV LocSymbol))
-> Parser (Maybe (SizeFunV LocSymbol))
-> Parser (Maybe (SizeFunV LocSymbol))
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe (SizeFunV LocSymbol) -> Parser (Maybe (SizeFunV LocSymbol))
forall a. a -> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (SizeFunV LocSymbol)
forall {a}. Maybe a
Nothing

relationalP :: Parser (Located LHName, Located LHName, LocBareTypeParsed, LocBareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
relationalP :: StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  (Located LHName, Located LHName, Located BareTypeParsed,
   Located BareTypeParsed, RelExprV LocSymbol, RelExprV LocSymbol)
relationalP = do
   x <- StateT (PStateV LocSymbol) (Parsec Void [Char]) (Located LHName)
locBinderLHNameP
   reserved "~"
   y <- locBinderLHNameP
   reserved "::"
   braces $ do
    tx <- located genBareTypeP
    reserved "~"
    ty <- located genBareTypeP
    reserved "|"
    assm <- try (relrefaP <* reserved "|-") <|> return (ERBasic PTrue)
    ex <- relrefaP
    return (x,y,tx,ty,assm,ex)

dataDeclP :: Parser DataDeclParsed
dataDeclP :: StateT (PStateV LocSymbol) (Parsec Void [Char]) DataDeclParsed
dataDeclP = do
  pos <- StateT (PStateV LocSymbol) (Parsec Void [Char]) SourcePos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m SourcePos
getSourcePos
  x   <- locUpperOrInfixIdP
  fsize <- dataSizeP
  dataDeclBodyP pos x fsize <|> return (emptyDecl x pos fsize)

emptyDecl :: LocSymbol -> SourcePos -> Maybe (SizeFunV LocSymbol) -> DataDeclParsed
emptyDecl :: LocSymbol
-> SourcePos -> Maybe (SizeFunV LocSymbol) -> DataDeclParsed
emptyDecl LocSymbol
x SourcePos
pos fsize :: Maybe (SizeFunV LocSymbol)
fsize@(Just SizeFunV LocSymbol
_)
  = DataName
-> [Symbol]
-> [PVarV LocSymbol (RTypeV LocSymbol BTyCon BTyVar ())]
-> Maybe [DataCtorParsed]
-> SourcePos
-> Maybe (SizeFunV LocSymbol)
-> Maybe BareTypeParsed
-> DataDeclKind
-> DataDeclParsed
forall v ty.
DataName
-> [Symbol]
-> [PVarV v (BSortV v)]
-> Maybe [DataCtorP ty]
-> SourcePos
-> Maybe (SizeFunV v)
-> Maybe ty
-> DataDeclKind
-> DataDeclP v ty
DataDecl (Located LHName -> DataName
DnName (Located LHName -> DataName) -> Located LHName -> DataName
forall a b. (a -> b) -> a -> b
$ LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName LHNameSpace
LHTcName (Symbol -> LHName) -> LocSymbol -> Located LHName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LocSymbol
x) [] [] Maybe [DataCtorParsed]
forall {a}. Maybe a
Nothing SourcePos
pos Maybe (SizeFunV LocSymbol)
fsize Maybe BareTypeParsed
forall {a}. Maybe a
Nothing DataDeclKind
DataUser
emptyDecl LocSymbol
x SourcePos
pos Maybe (SizeFunV LocSymbol)
_
  = UserError -> DataDeclParsed
forall a. UserError -> a
uError (SrcSpan -> Doc -> Doc -> UserError
forall t. SrcSpan -> Doc -> Doc -> TError t
ErrBadData (SourcePos -> SrcSpan
sourcePosSrcSpan SourcePos
pos) (Symbol -> Doc
forall a. PPrint a => a -> Doc
pprint (LocSymbol -> Symbol
forall a. Located a -> a
val LocSymbol
x)) Doc
forall {a}. IsString a => a
msg)
  where
    msg :: a
msg = a
"You should specify either a default [size] or one or more fields in the data declaration"

dataDeclBodyP :: SourcePos -> LocSymbol -> Maybe (SizeFunV LocSymbol) -> Parser DataDeclParsed
dataDeclBodyP :: SourcePos
-> LocSymbol
-> Maybe (SizeFunV LocSymbol)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) DataDeclParsed
dataDeclBodyP SourcePos
pos LocSymbol
x Maybe (SizeFunV LocSymbol)
fsize = do
  vanilla    <- [LocSymbol] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([LocSymbol] -> Bool)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [LocSymbol]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserV LocSymbol LocSymbol
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [LocSymbol]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many ParserV LocSymbol LocSymbol
forall v. ParserV v LocSymbol
locUpperIdP
  as         <- many noWhere -- TODO: check this again
  ps         <- predVarDefsP
  (pTy, dcs) <- dataCtorsP as
  let dn      = SourcePos -> LocSymbol -> Bool -> [DataCtorParsed] -> DataName
dataDeclName SourcePos
pos LocSymbol
x Bool
vanilla [DataCtorParsed]
dcs
  return      $ DataDecl dn as ps (Just dcs) pos fsize pTy DataUser

dataDeclName :: SourcePos -> LocSymbol -> Bool -> [DataCtorParsed] -> DataName
dataDeclName :: SourcePos -> LocSymbol -> Bool -> [DataCtorParsed] -> DataName
dataDeclName SourcePos
_ LocSymbol
x Bool
True  [DataCtorParsed]
_     = Located LHName -> DataName
DnName (Located LHName -> DataName) -> Located LHName -> DataName
forall a b. (a -> b) -> a -> b
$ LHNameSpace -> Symbol -> LHName
makeUnresolvedLHName LHNameSpace
LHTcName (Symbol -> LHName) -> LocSymbol -> Located LHName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LocSymbol
x  -- vanilla data    declaration
dataDeclName SourcePos
_ LocSymbol
_ Bool
False (DataCtorParsed
d:[DataCtorParsed]
_) = Located LHName -> DataName
DnCon  (Located LHName -> DataName) -> Located LHName -> DataName
forall a b. (a -> b) -> a -> b
$ DataCtorParsed -> Located LHName
forall ty. DataCtorP ty -> Located LHName
dcName DataCtorParsed
d                             -- family instance declaration
dataDeclName SourcePos
p LocSymbol
x Bool
_  [DataCtorParsed]
_        = UserError -> DataName
forall a. UserError -> a
uError (SrcSpan -> Doc -> Doc -> UserError
forall t. SrcSpan -> Doc -> Doc -> TError t
ErrBadData (SourcePos -> SrcSpan
sourcePosSrcSpan SourcePos
p) (Symbol -> Doc
forall a. PPrint a => a -> Doc
pprint (LocSymbol -> Symbol
forall a. Located a -> a
val LocSymbol
x)) Doc
forall {a}. IsString a => a
msg)
  where
    msg :: a
msg                  = a
"You should specify at least one data constructor for a family instance"

-- | Parse the constructors of a datatype, allowing both classic and GADT-style syntax.
--
-- Note that as of 2020-10-14, we changed the syntax of GADT-style datatype declarations
-- to match Haskell more closely and parse all constructors in a layout-sensitive block,
-- whereas before we required them to be separated by @|@.
--
dataCtorsP :: [Symbol] -> Parser (Maybe BareTypeParsed, [DataCtorParsed])
dataCtorsP :: [Symbol] -> Parser (Maybe BareTypeParsed, [DataCtorParsed])
dataCtorsP [Symbol]
as = do
  (pTy, dcs) <-     ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"="     ParserV LocSymbol ()
-> Parser (Maybe BareTypeParsed, [DataCtorParsed])
-> Parser (Maybe BareTypeParsed, [DataCtorParsed])
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((Maybe BareTypeParsed
forall {a}. Maybe a
Nothing, ) ([DataCtorParsed] -> (Maybe BareTypeParsed, [DataCtorParsed]))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [DataCtorParsed]
-> Parser (Maybe BareTypeParsed, [DataCtorParsed])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>                 Parser DataCtorParsed
-> ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [DataCtorParsed]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy ([Symbol] -> Parser DataCtorParsed
dataConP    [Symbol]
as) ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"|")))
                Parser (Maybe BareTypeParsed, [DataCtorParsed])
-> Parser (Maybe BareTypeParsed, [DataCtorParsed])
-> Parser (Maybe BareTypeParsed, [DataCtorParsed])
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved   [Char]
"where" ParserV LocSymbol ()
-> Parser (Maybe BareTypeParsed, [DataCtorParsed])
-> Parser (Maybe BareTypeParsed, [DataCtorParsed])
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((Maybe BareTypeParsed
forall {a}. Maybe a
Nothing, ) ([DataCtorParsed] -> (Maybe BareTypeParsed, [DataCtorParsed]))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [DataCtorParsed]
-> Parser (Maybe BareTypeParsed, [DataCtorParsed])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>                 Parser DataCtorParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [DataCtorParsed]
forall v a. ParserV v a -> ParserV v [a]
block ([Symbol] -> Parser DataCtorParsed
adtDataConP [Symbol]
as)                 ))
                Parser (Maybe BareTypeParsed, [DataCtorParsed])
-> Parser (Maybe BareTypeParsed, [DataCtorParsed])
-> Parser (Maybe BareTypeParsed, [DataCtorParsed])
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>                        ((,)         (Maybe BareTypeParsed
 -> [DataCtorParsed] -> (Maybe BareTypeParsed, [DataCtorParsed]))
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Maybe BareTypeParsed)
-> StateT
     (PStateV LocSymbol)
     (Parsec Void [Char])
     ([DataCtorParsed] -> (Maybe BareTypeParsed, [DataCtorParsed]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Maybe BareTypeParsed)
dataPropTyP StateT
  (PStateV LocSymbol)
  (Parsec Void [Char])
  ([DataCtorParsed] -> (Maybe BareTypeParsed, [DataCtorParsed]))
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [DataCtorParsed]
-> Parser (Maybe BareTypeParsed, [DataCtorParsed])
forall a b.
StateT (PStateV LocSymbol) (Parsec Void [Char]) (a -> b)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser DataCtorParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) [DataCtorParsed]
forall v a. ParserV v a -> ParserV v [a]
block ([Symbol] -> Parser DataCtorParsed
adtDataConP [Symbol]
as)                  )
  return (pTy, Misc.sortOn (val . dcName) dcs)

noWhere :: Parser Symbol
noWhere :: Parser Symbol
noWhere =
  Parser Symbol -> Parser Symbol
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser Symbol -> Parser Symbol) -> Parser Symbol -> Parser Symbol
forall a b. (a -> b) -> a -> b
$ do
  s <- Parser Symbol
tyVarIdP
  guard (s /= "where")
  return s

dataPropTyP :: Parser (Maybe BareTypeParsed)
dataPropTyP :: StateT
  (PStateV LocSymbol) (Parsec Void [Char]) (Maybe BareTypeParsed)
dataPropTyP = BareTypeParsed -> Maybe BareTypeParsed
forall a. a -> Maybe a
Just (BareTypeParsed -> Maybe BareTypeParsed)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT
     (PStateV LocSymbol) (Parsec Void [Char]) (Maybe BareTypeParsed)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserV LocSymbol ()
-> ParserV LocSymbol ()
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reservedOp [Char]
"::") ([Char] -> ParserV LocSymbol ()
forall v. [Char] -> ParserV v ()
reserved [Char]
"where") StateT (PStateV LocSymbol) (Parsec Void [Char]) BareTypeParsed
bareTypeP

---------------------------------------------------------------------
-- Identifiers ------------------------------------------------------
---------------------------------------------------------------------

-- Andres, TODO: Fix all the rules for identifiers. This was limited to all lowercase letters before.
tyVarIdR :: Parser Symbol
tyVarIdR :: Parser Symbol
tyVarIdR =
  StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
forall v.
ParserV v Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> ParserV v Symbol
condIdR (StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
lowerChar StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Token [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
Token [Char]
'_') Char -> Bool
isAlphaNum [Char] -> Bool
isNotReserved [Char]
"unexpected reserved name"

tyVarIdP :: Parser Symbol
tyVarIdP :: Parser Symbol
tyVarIdP =
  Parser Symbol -> Parser Symbol
forall v a. ParserV v a -> ParserV v a
lexeme Parser Symbol
tyVarIdR

aliasIdR :: Parser Symbol
aliasIdR :: Parser Symbol
aliasIdR =
  StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
forall v.
ParserV v Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> ParserV v Symbol
condIdR (StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
letterChar StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Token [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
Token [Char]
'_') Char -> Bool
isAlphaNum (Bool -> [Char] -> Bool
forall a b. a -> b -> a
const Bool
True) [Char]
"unexpected"

aliasIdP :: Parser Symbol
aliasIdP :: Parser Symbol
aliasIdP =
  Parser Symbol -> Parser Symbol
forall v a. ParserV v a -> ParserV v a
lexeme Parser Symbol
aliasIdR

-- | Andres, TODO: This must be liberal with respect to reserved words (LH reserved words are
-- not Haskell reserved words, and we want to redefine all sorts of internal stuff).
--
-- Also, this currently accepts qualified names by allowing '.' ...
-- Moreover, it seems that it is currently allowed to use qualified symbolic names in
-- unparenthesised form. Oh, the parser is also used for reflect, where apparently
-- symbolic names appear in unqualified and unparenthesised form.
-- Furthermore, : is explicitly excluded because a : can directly, without whitespace,
-- follow a binder ...
--
binderIdR :: Parser Symbol
binderIdR :: Parser Symbol
binderIdR =
  StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
forall v.
ParserV v Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> ParserV v Symbol
condIdR (StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
letterChar StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Token [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
Token [Char]
'_' StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Token [Char] -> Bool)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy Char -> Bool
Token [Char] -> Bool
isHaskellOpStartChar) (\ Char
c -> Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char -> Bool
isHaskellOpStartChar Char
c Bool -> Bool -> Bool
|| Char
c Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` ([Char]
"_'" :: String)) (Bool -> [Char] -> Bool
forall a b. a -> b -> a
const Bool
True) [Char]
"unexpected"

binderIdP :: Parser Symbol
binderIdP :: Parser Symbol
binderIdP =
  Parser Symbol -> Parser Symbol
forall v a. ParserV v a -> ParserV v a
lexeme Parser Symbol
binderIdR

infixBinderIdR :: Parser Symbol
infixBinderIdR :: Parser Symbol
infixBinderIdR =
  StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
forall v.
ParserV v Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> ParserV v Symbol
condIdR (StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
letterChar StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Token [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
Token [Char]
'_' StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
forall a.
StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Token [Char] -> Bool)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy Char -> Bool
Token [Char] -> Bool
isHaskellOpChar) (\ Char
c -> Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char -> Bool
isHaskellOpChar Char
c Bool -> Bool -> Bool
|| Char
c Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` ([Char]
"_'" :: String)) (Bool -> [Char] -> Bool
forall a b. a -> b -> a
const Bool
True) [Char]
"unexpected"

infixBinderIdP :: Parser Symbol
infixBinderIdP :: Parser Symbol
infixBinderIdP =
  Parser Symbol -> Parser Symbol
forall v a. ParserV v a -> ParserV v a
lexeme Parser Symbol
infixBinderIdR

upperIdR' :: Parser Symbol
upperIdR' :: Parser Symbol
upperIdR' =
  StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
forall v.
ParserV v Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> ParserV v Symbol
condIdR StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
upperChar (\ Char
c -> Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\'') (Bool -> [Char] -> Bool
forall a b. a -> b -> a
const Bool
True) [Char]
"unexpected"

locUpperIdP' :: Parser (Located Symbol)
locUpperIdP' :: ParserV LocSymbol LocSymbol
locUpperIdP' =
  Parser Symbol -> ParserV LocSymbol LocSymbol
forall v a. ParserV v a -> ParserV v (Located a)
locLexeme Parser Symbol
upperIdR'

-- Andres, TODO: This used to force a colon at the end. Also, it used to not
-- allow colons in the middle. Finally, it should probably exclude all reserved
-- operators. I'm just excluding :: because I'm pretty sure that would be
-- undesired.
--
infixCondIdR :: Parser Symbol
infixCondIdR :: Parser Symbol
infixCondIdR =
  StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
forall v.
ParserV v Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> ParserV v Symbol
condIdR (Token [Char]
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
Token [Char]
':') Char -> Bool
isHaskellOpChar ([Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
/= [Char]
"::") [Char]
"unexpected double colon"

-- Andres, TODO: This used to be completely ad-hoc. It's still not good though.
infixIdR :: Parser Symbol
infixIdR :: Parser Symbol
infixIdR =
  StateT (PStateV LocSymbol) (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
forall v.
ParserV v Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> ParserV v Symbol
condIdR ((Token [Char] -> Bool)
-> StateT (PStateV LocSymbol) (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy Char -> Bool
Token [Char] -> Bool
isHaskellOpChar) Char -> Bool
isHaskellOpChar ([Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
/= [Char]
"::") [Char]
"unexpected double colon"

infixIdP :: Parser Symbol
infixIdP :: Parser Symbol
infixIdP =
  Parser Symbol -> Parser Symbol
forall v a. ParserV v a -> ParserV v a
lexeme Parser Symbol
infixIdR

{-
infixVarIdR :: Parser Symbol
infixVarIdR =
  condIdR (satisfy isHaskellOpStartChar) isHaskellOpChar (const True)

infixVarIdP :: Parser Symbol
infixVarIdP =
  lexeme infixVarIdR
-}

isHaskellOpChar :: Char -> Bool
isHaskellOpChar :: Char -> Bool
isHaskellOpChar Char
c
  = Char
c Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` ([Char]
":!#$%&*+./<=>?@\\^|~-" :: String)

isHaskellOpStartChar :: Char -> Bool
isHaskellOpStartChar :: Char -> Bool
isHaskellOpStartChar Char
c
  = Char
c Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` ([Char]
"!#$%&*+./<=>?@\\^|~-" :: String)

locInfixCondIdP :: Parser (Located Symbol)
locInfixCondIdP :: ParserV LocSymbol LocSymbol
locInfixCondIdP =
  Parser Symbol -> ParserV LocSymbol LocSymbol
forall v a. ParserV v a -> ParserV v (Located a)
locLexeme Parser Symbol
infixCondIdR